Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Visiška saugumo architektūra

Paskaita 12 iš 12 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Visų dalių sujungimas
  2. Architektūros apžvalga
  3. Pilnas įgyvendinimas
  4. Naudojimas gamyboje
  5. Stebėsena ir įspėjimai
  6. Kurso santrauka
  7. Svarbiausi punktai
  8. Patikrink savo žinias

Atnaujinta 2026 m. lapkričio 3 d. Anksčiau generavimo sluoksnis naudojo išgalvotą apsaugos taisyklių formatą (enabled), o gamybos politika rėmėsi neegzistuojančiomis kategorijomis (hate, violence, unpredictable). Dabar kodas atitinka oficialų moderation_llm_v2 formatą ir vienuolika raktų iš mistral-moderation-2603. Balai, kurie SDK yra neprivalomi, nuskaityti su atsargine verte. Kodas patikrintas pagal mistralai SDK tipų 3.7.0 versiją. Šaltiniai: Moderavimas ir apsaugos taisyklės · Python SDK mistralai.

Visų dalių sujungimas

Šio kurso metu nagrinėjai apsaugos taisykles, Moderavimo API, 11 kategorijų, slenkstines vertes, „jailbreak“ aptikimą, BDAR atitiktį ir turinio politiką. Šioje paskutinėje pamokoje visi šie statybiniai blokai sujungiami į vientisą saugumo architektūrą, paruoštą gamybai.

Architektūros apžvalga

Yra penki sluoksniai, kuriuos valdo vienas principas: nė vienas iš jų nėra patikimas atskirai. Apsaugos taisykles galima apeiti netikėta formuluote, moderavimo modelis gali praleisti pažeidimus (klaidingai neigiami rezultatai), o turinio politika niekada neapima visų atvejų. Sluoksnių derinimas veikia todėl, kad jų spragos nesutampa – tai, kas prasprūsta pro pirmąjį sluoksnį, turi didelę tikimybę būti sulaikyta antrojo.

Praktinė išvada – griežta tvarka: kiekvienas sluoksnis turi būti kuo pigesnis, prieš įsijungiant kitam. Pirmiausia patikrini formatą prieš kviesdamas apsaugos taisykles, o apsaugos taisykles kvieti prieš generavimą – nes turinys, atmestas 1 žingsnyje, nesuvartoja nė vieno tokeno.

Naudotojas
    ↓
[1. Įvesties validavimas] → Reguliarieji reiškiniai, šablonai, dažnio ribojimas
    ↓
[2. Mistral apsaugos taisyklės]  → Blokavimas prieš generavimą (403)
    ↓
[3. DDK generavimas]      → safe_prompt + saugios instrukcijos
    ↓
[4. Išvesties moderavimas]   → Moderavimo API po generavimo
    ↓
[5. Registravimas ir auditas]     → Balai, sprendimai, BDAR audito takas
    ↓
Atsakymas naudotojui

Pilnas įgyvendinimas

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import re
import json
import logging
from datetime import datetime, timezone
from enum import Enum

# Konfigūracija
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("moderation")


class Decision(Enum):
    ALLOWED = "allowed"
    BLOCKED_INPUT = "blocked_input"
    BLOCKED_GUARDRAIL = "blocked_guardrail"
    BLOCKED_OUTPUT = "blocked_output"
    ERROR = "error"


class SecureArchitecture:
    """Pilna saugumo architektūra DDK programoms."""

    def __init__(self, policy: dict, model: str = "mistral-large-latest"):
        self.policy = policy
        self.model = model
        self.stats = {d.value: 0 for d in Decision}

    # --- 1 sluoksnis: Įvesties validavimas ---

    def validate_input(self, text: str) -> dict:
        """Greitas validavimas prieš bet kokį API kvietimą."""
        # Maksimalus ilgis
        if len(text) > 10000:
            return {"valid": False, "reason": "Žinutė per ilga"}

        # Įtartini simboliai (Unicode injekcijos)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Neteisingi simboliai"}

        # Akivaizdūs „jailbreak“ šablonai
        patterns = [
            r"ignore\s+(all\s+)?(previous|prior|above)",
            r"you\s+are\s+now\s+(DAN|unfiltered)",
            r"oublie\s+(toutes?\s+)?(tes|vos)\s+instructions",
            r"system\s*prompt",
        ]
        for pattern in patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return {
                    "valid": False,
                    "reason": "Aptiktas injekcijos šablonas"
                }

        return {"valid": True}

    # --- 2 sluoksnis: Įvesties moderavimas ---

    def moderate_input(self, text: str) -> dict:
        """Užklausos moderavimas per API."""
        response = client.classifiers.moderate(
            model="mistral-moderation-2603",
            inputs=[text]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- 3 sluoksnis: Saugus generavimas ---

    def generate(self, messages: list) -> str:
        """Generavimas su apsaugos taisyklėmis ir safe_prompt."""
        response = client.chat.complete(
            model=self.model,
            messages=messages,
            safe_prompt=True,
            guardrails=[
                {
                    "block_on_error": True,
                    "moderation_llm_v2": {
                        "custom_category_thresholds": self.policy["thresholds"],
                        "action": "block",
                    },
                }
            ],
        )
        content = response.choices[0].message.content
        return content if isinstance(content, str) else ""

    # --- 4 sluoksnis: Išvesties moderavimas ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Atsakymo moderavimas kontekste."""
        response = client.classifiers.moderate_chat(
            model="mistral-moderation-2603",
            inputs=[[
                {"role": "user", "content": prompt},
                {"role": "assistant", "content": response_text}
            ]]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- 5 sluoksnis: Registravimas ---

    def log_decision(self, decision: Decision, data: dict):
        """Įrašo sprendimą auditui."""
        self.stats[decision.value] += 1
        entry = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "decision": decision.value,
            "policy": self.policy["name"],
            **data
        }
        logger.info(json.dumps(entry, ensure_ascii=False))

    # --- Pagrindinė grandinė ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Pilna saugi apdorojimo grandinė."""

        # 1 sluoksnis: Validavimas
        validation = self.validate_input(user_message)
        if not validation["valid"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "reason": validation["reason"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "Jūsų žinutės negalima apdoroti."
            }

        # 2 sluoksnis: Įvesties moderavimas
        check_input = self.moderate_input(user_message)
        if not check_input["allowed"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "violations": check_input["violations"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "Šis turinys pažeidžia mūsų politiką."
            }

        # 3 sluoksnis: Generavimas
        messages = []
        if system_prompt:
            messages.append({"role": "system",
                           "content": system_prompt})
        messages.append({"role": "user",
                        "content": user_message})

        try:
            response_text = self.generate(messages)
        except SDKError as e:
            if e.status_code == 403:
                self.log_decision(Decision.BLOCKED_GUARDRAIL, {})
                return {
                    "status": Decision.BLOCKED_GUARDRAIL.value,
                    "message": "Užklausa užblokuota apsaugos taisyklių."
                }
            raise

        # 4 sluoksnis: Išvesties moderavimas
        check_output = self.moderate_output(user_message, response_text)
        if not check_output["allowed"]:
            self.log_decision(Decision.BLOCKED_OUTPUT, {
                "violations": check_output["violations"]
            })
            return {
                "status": Decision.BLOCKED_OUTPUT.value,
                "message": "Atsakymas buvo filtruotas."
            }

        # Sėkmė
        self.log_decision(Decision.ALLOWED, {
            "input_max_score": max(check_input["scores"].values(), default=0.0),
            "output_max_score": max(check_output["scores"].values(), default=0.0),
        })

        return {
            "status": Decision.ALLOWED.value,
            "content": response_text,
            "moderation": {
                "input": check_input["scores"],
                "output": check_output["scores"]
            }
        }

    # --- Pagalbinės funkcijos ---

    def _check_thresholds(self, scores: dict) -> list:
        """Tikrina balus pagal politikos slenkstines vertes."""
        violations = []
        for cat, threshold in self.policy["thresholds"].items():
            score = scores.get(cat, 0)
            if score > threshold:
                violations.append({
                    "category": cat,
                    "score": round(score, 3),
                    "threshold": threshold
                })
        return violations

    def report(self) -> dict:
        """Generuoja statistikos ataskaitą."""
        total = sum(self.stats.values())
        return {
            "policy": self.policy["name"],
            "total_requests": total,
            "decisions": self.stats,
            "block_rate": round(
                (self.stats["blocked_input"] +
                 self.stats["blocked_guardrail"] +
                 self.stats["blocked_output"]) / max(total, 1),
                3
            )
        }

Naudojimas gamyboje

# Apibrėžkite politiką
prod_policy = {
    "name": "Gamyba v1.2",
    "thresholds": {
        "sexual": 0.15, "hate_and_discrimination": 0.1, "violence_and_threats": 0.2,
        "dangerous": 0.1, "criminal": 0.1, "selfharm": 0.1, "health": 0.4,
        "financial": 0.4, "law": 0.4, "pii": 0.15,
        "jailbreaking": 0.1
    }
}

# Inicijuokite architektūrą
arch = SecureArchitecture(prod_policy)

# Apdorokite užklausas
result = arch.process(
    "Paaiškinkite, kaip veikia transformatoriai",
    system_prompt="Esi DI instruktorius."
)
print(result["status"])   # tikėtina: "allowed"
print(result["content"])

# Peržiūrėkite statistiką
print(arch.report())

Stebėsena ir įspėjimai

Moderavimo sistemai valdyti pakanka dviejų rodiklių, ir juos turi stebėti priešingomis kryptimis. Blokavimo rodiklis turi išlikti stabilus: staigus šuolis signalizuoja arba apie ataką, arba apie per griežtą slenkstinę vertę, kuri pradeda trukdyti teisėtiems naudotojams. Ne mažiau svarbus ir balų pasiskirstymas – jei tavo turinys grupuojasi tiesiai po slenkstine verte, ji nustatyta netinkamai, ir kitas naudotojų pokytis ją sugriaus.

def configure_alerts(arch: SecureArchitecture):
    """Konfigūruoja įspėjimus stebėsenai."""
    report = arch.report()

    # Įspėjimas, jei blokavimo rodiklis nenormalus
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Didelis blokavimo rodiklis: "
            f"{report['block_rate']:.1%}"
        )

    # Įspėjimas, jei šuoliai dėl „jailbreak“
    # Integruokite su Prometheus, Grafana, Datadog ir kt.

Kurso santrauka

Baigęs šį kursą, įvaldei:

  • Tinkintas apsaugos taisykles: Blokuok pavojingas užklausas prieš generavimą, konfigūruok slenkstines vertes pagal kategorijas, taikyk agentams
  • Moderavimo API: Klasifikuok turinį naudodamas „Mistral Moderation 2“, interpretuok balus pagal 11 kategorijų, priimk automatizuotus sprendimus
  • Gamybinį saugumą: Apibrėžk turinio politiką, aptikyk užklausų injekcijas, užtikrink BDAR atitiktį
  • Pilną architektūrą: Sujunk apsaugos taisykles + moderavimą + stebėseną į patikimą grandinę

Dabar turi visą kodą, reikalingą diegti pilną DI moderavimo sistemą su „Mistral“ API.

Svarbiausi punktai

  • Saugumo architektūrą sudaro 5 sluoksniai: validavimas, apsaugos taisyklės, generavimas, moderavimas, registravimas
  • Kiekvienas sluoksnis kompensuoja kitų silpnybes – tai yra gynyba gylyje
  • Gamyboje stebėk blokavimo rodiklį ir balus
  • Nuolat atnaujink savo politiką atlikdamas reguliarias peržiūras
  • Šioje pamokoje pateiktas pilnas kodas yra tik pradinis taškas – pritaikyk jį savo kontekstui

Patikrink savo žinias

Apsaugos taisyklės, moderavimas, injekcijos: ar gynybinė architektūra aiški?

1. Kur įsiterpia tinkintos apsaugos taisyklės?

Atsakymas: Prieš modelį: jos filtruoja įvestis pagal tavo taisykles (draudžiamos temos, formatai) – tai pirmasis sluoksnis, leidžiantis išvengti net užklausos siuntimo, jei ji nepatenka į leistiną sritį.

2. Ką apima „Mistral“ moderavimo API?

Atsakymas: Vienuolika rizikingo turinio kategorijų su balu kiekvienai kategorijai: tavo slenkstinės vertės nusprendžia, ar blokuoti, žymėti, ar leisti – taip turinio politika paverčiama kodu.

3. Kaip apibrėžiama gera turinio politika?

Atsakymas: Pagal naudojimo atvejį: kas priimtina konkrečiai programai, slenkstinės vertės kiekvienai kategorijai, susiję veiksmai (blokavimas, perrašymas, eskalavimas) – tai turi būti dokumentuota ir testuojama, o ne numanoma.

4. Kaip aptikti užklausų injekcijų bandymus?

Atsakymas: Traktuojant visą išorinį turinį kaip įtartiną: aptinkant instrukcijų šablonus duomenyse, atskiriant instrukcijas nuo duomenų, validuojant išvestis ir reguliariai atliekant puolimo testus.

5. Kaip atrodo pilna saugumo architektūra?

Atsakymas: Sluoksniai: įvesties apsaugos taisyklės, turinio moderavimas, išvesties kontrolė, BDAR atitiktis (duomenų mažinimas, teisės) ir atsekamumas – joks vienas sluoksnis nėra tobulas, tačiau jų derinimas kompensuoja trūkumus.

Gynyba gylyje nėra tik šūkis: kiekvienas šio kurso sluoksnis sulaiko tai, ką praleido prieš tai buvęs.