Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Terviklik turvarhitektuur

Õppetund 12 / 12 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Kõikide osade kokkupanek
  2. Arhitektuuri ülevaade
  3. Terviklik teostus
  4. Kasutamine tootmises
  5. Jälgimine ja hoiatused
  6. Kursuse kokkuvõte
  7. Peamised punktid
  8. Testi oma teadmisi

Uuendatud 3. novembril 2026. Varasem genereerimiskiht kasutas väljamõeldud turvapiirangute vormingut (enabled) ja tootmispoliitika tugines olematutele kategooriatele (hate, violence, unpredictable). Kood järgib nüüd ametlikku moderation_llm_v2 vormingut ja ühteteist võtit failist mistral-moderation-2603. Tulemusi, mis on SDK-s valikulised, loetakse varuväärtusega. Kood on kontrollitud mistralai SDK tüüpide versiooni 3.7.0 vastu. Allikad: Moderation & Guardrailing · Python SDK mistralai.

Kõikide osade kokkupanek

Selle kursuse vältel oled tutvunud turvapiirangute, Moderatsiooni API, 11 kategooria, lävendite, jailbreak-i tuvastamise, GDPR-i nõuete ja sisupoliitikatega. See viimane õppetund paneb kõik need ehitusplokid kokku terviklikuks turvarhitektuuriks, mis on valmis tootmisse viimiseks.

Arhitektuuri ülevaade

Süsteem koosneb viiest kihist, mida juhib üks põhimõte: ükski neist ei ole iseseisvalt usaldusväärne. Turvapiiranguid saab ootamatu sõnastusega mööda hiilida, moderatsioonimudelil esineb valepositiivseid tulemusi ja sisupoliitika ei kata kunagi kõiki juhtumeid. Kihtide virnastamine toimib seetõttu, et lüngad ei kattu – mis libiseb läbi esimesest kihist, jääb suure tõenäosusega kinni teises.

Praktiline järeldus on range järjekord: iga kiht peab olema enne järgmise käivitumist võimalikult odav. Sa valideerid vormingu enne turvapiirangu kutsumist ja kutsud turvapiirangu enne genereerimist – sest esimeses etapis tagasi lükatud sisu ei tarbi ühtegi tokenit.

Kasutaja
    ↓
[1. Sisendi valideerimine] → Regex, mustrid, kiiruse piiramine
    ↓
[2. Mistrali turvapiirangud]  → Eel-generatsiooni blokeerimine (403)
    ↓
[3. LLM-i genereerimine]      → safe_prompt + turvalised juhised
    ↓
[4. Väljundi moderatsioon]   → Moderatsiooni API pärast genereerimist
    ↓
[5. Logimine ja audit]     → Tulemused, otsused, GDPR-i auditi jälg
    ↓
Kasutaja vastus

Terviklik teostus

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

# Konfiguratsioon
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:
    """AI-rakenduste terviklik turvarhitektuur."""

    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}

    # --- Kiht 1: Sisendi valideerimine ---

    def validate_input(self, text: str) -> dict:
        """Kiire valideerimine enne ühtegi API kutset."""
        # Maksimaalne pikkus
        if len(text) > 10000:
            return {"valid": False, "reason": "Sõnum on liiga pikk"}

        # Kahtlased märgid (Unicode süstid)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Vigased märgid"}

        # Ilmsed jailbreak-i mustrid
        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": "Süsteemi süstimise muster tuvastatud"
                }

        return {"valid": True}

    # --- Kiht 2: Sisendi moderatsioon ---

    def moderate_input(self, text: str) -> dict:
        """Sisendi moderatsioon API kaudu."""
        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
        }

    # --- Kiht 3: Turvaline genereerimine ---

    def generate(self, messages: list) -> str:
        """Generatsioon turvapiirangute ja safe_promptiga."""
        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 ""

    # --- Kiht 4: Väljundi moderatsioon ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Vastuse moderatsioon kontekstis."""
        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
        }

    # --- Kiht 5: Logimine ---

    def log_decision(self, decision: Decision, data: dict):
        """Salvestab otsuse auditeerimiseks."""
        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))

    # --- Peamine torustik ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Terviklik turvaline töötlemistorustik."""

        # Kiht 1: Valideerimine
        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": "Sinu sõnumit ei saa töödelda."
            }

        # Kiht 2: Sisendi moderatsioon
        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": "See sisu rikub meie poliitikat."
            }

        # Kiht 3: Generatsioon
        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": "Päring blokeeriti turvapiirangute poolt."
                }
            raise

        # Kiht 4: Väljundi moderatsioon
        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": "Vastus filtreeriti."
            }

        # Õnnestumine
        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"]
            }
        }

    # --- Utiliidid ---

    def _check_thresholds(self, scores: dict) -> list:
        """Kontrollib tulemusi poliitika lävendite vastu."""
        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:
        """Genereerib statistikaaruande."""
        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
            )
        }

Kasutamine tootmises

# Määratle poliitika
prod_policy = {
    "name": "Production 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
    }
}

# Loo arhitektuuri instants
arch = SecureArchitecture(prod_policy)

# Töötle päringuid
result = arch.process(
    "Selgita, kuidas transformerid töötavad",
    system_prompt="Sa oled AI-instruktor."
)
print(result["status"])   # eeldatav: "allowed"
print(result["content"])

# Vaata statistikat
print(arch.report())

Jälgimine ja hoiatused

Moderatsioonisüsteemi juhtimiseks piisab kahest mõõdikust ja sa pead neid jälgima vastassuundades. Blokimise määr peaks püsima stabiilsena: järsk tõus annab märku kas rünnakust või liiga rangest lävendist, mis hakkab takistama legitiimseid kasutajaid. Sama oluline on tulemuste jaotus – kui sinu sisu klastrid asuvad vahetult enne lävendit, on lävend valesti paigutatud ja järgmine kasutajapoolne kohendus rikub selle.

def configure_alerts(arch: SecureArchitecture):
    """Seadistab hoiatused jälgimiseks."""
    report = arch.report()

    # Hoiatus, kui blokimise määr on ebanormaalne
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Kõrge blokimise määr: "
            f"{report['block_rate']:.1%}"
        )

    # Hoiatus, kui jailbreak-i tõusud toimuvad
    # Integreeri Prometheus, Grafana, Datadog vms teenustega

Kursuse kokkuvõte

Selle kursuse lõpuks oled omandanud:

  • Kohandatud turvapiirangud: Blokeeri ohtlikud sisendid enne genereerimist, seadista lävendid kategooria haaval, rakenda agentidele
  • Moderatsiooni API: Klassifitseeri sisu Mistral Moderation 2 abil, tõlgenda tulemusi üle 11 kategooria, tee automatiseeritud otsuseid
  • Tootmise turvalisus: Määratle sisupoliitikad, tuvasta sisendi süstimised (prompt injections), taga GDPR-i vastavus
  • Terviklik arhitektuur: Ühenda turvapiirangud + moderatsioon + jälgimine robustseks torustikuks

Sul on nüüd olemas kogu kood, mis on vajalik Mistrali API-ga tervikliku AI-moderatsioonisüsteemi kasutuselevõtuks.

Peamised punktid

  • Turvarhitektuur hõlmab 5 kihti: valideerimine, turvapiirangud, genereerimine, moderatsioon, logimine
  • Iga kiht kompenseerib teiste nõrkusi – see on sügavuskaitse (defense in depth)
  • Jälgi tootmises blokimise määra ja tulemusi
  • Hoia oma poliitika ajakohasena korrapäraste ülevaadetega
  • Selles õppetunnis olev täielik kood on lähtepunkt – kohanda seda oma kontekstis

Testi oma teadmisi

Kas turvapiirangud, moderatsioon ja süstimine on kaitsva arhitektuuri osana selged?

1. Millal sekkuvad kohandatud turvapiirangud?

Vastus: Enne mudelit: need filtreerivad sisendeid vastavalt sinu reeglitele (keelatud teemad, vormingud) – see on esimene kiht, mis väldib päringu tegemist, kui see jääb väljapoole lubatud piire.

2. Mida hõlmab Mistrali moderatsiooni API?

Vastus: Üksteist riskantse sisu kategooriat, igaühele oma tulemus: sinu lävendid otsustavad, kas blokeerida, märgistada või lubada – muutes sisupoliitika koodiks.

3. Kuidas defineeritakse hea sisupoliitika?

Vastus: Kasutusjuhu põhjal: mis on rakenduse jaoks vastuvõetav, lävendid kategooria haaval, seotud tegevused (blokeerimine, ümberkirjutamine, eskaleerimine) – dokumenteeritud ja testitud, mitte kaudne.

4. Kuidas tuvastada sisendi süstimise (prompt injection) katseid?

Vastus: Koheldes kogu välist sisu kahtlasena: tuvastades juhiste mustreid andmetes, eraldades juhised andmetest, valideerides väljundeid – ja tehes korrapäraseid ründavaid teste.

5. Kuidas näeb välja terviklik turvarhitektuur?

Vastus: Kihid: sisendi turvapiirangud, sisu moderatsioon, väljundi kontrollid, GDPR-i vastavus (minimeerimine, õigused) ja jälgitavus – ükski kiht pole täiuslik, kuid nende virnastamine kompenseerib puudujääke.

Sügavuskaitse ei ole loosung: iga kiht selles kursuses püüab kinni selle, mille eelmine kiht läbi laskis.