Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Turvallisuusarkkitehtuuri kokonaisuudessaan

Oppitunti 12 / 12 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Kaikkien palasten kokoaminen
  2. Arkkitehtuurin yleiskatsaus
  3. Täydellinen toteutus
  4. Käyttö tuotannossa
  5. Valvonta ja hälytykset
  6. Kurssin yhteenveto
  7. Keskeiset asiat
  8. Testaa tietosi

Päivitetty 3. marraskuuta 2026. Generointikerros välitti aiemmin keksityn suodatusmuodon (enabled), ja tuotantokäytäntö käytti olemattomia kategorioita (hate, violence, unpredictable). Koodi noudattaa nyt virallista moderation_llm_v2-muotoa ja mistral-moderation-2603:n yhdeksäätoista avainta. SDK:ssa valinnaiset pisteytykset luetaan varoarvolla. Koodi on varmennettu mistralai-SDK-tyyppien versiota 3.7.0 vasten. Lähteet: Moderation & Guardrailing · Python SDK mistralai.

Kaikkien palasten kokoaminen

Olet tämän kurssin aikana tutustunut suodatusmekanismeihin, Moderation APIiin, 11 kategoriaan, kynnysarvoihin, jailbreak-tunnistukseen, GDPR-vaatimustenmukaisuuteen ja sisältöpolitiikkoihin. Tämä viimeinen oppitunti kokoaa kaikki nämä rakennuspalikat yhtenäiseksi, tuotantovalmiiksi turvallisuusarkkitehtuuriksi.

Arkkitehtuurin yleiskatsaus

Järjestelmä koostuu viidestä kerroksesta, joita ohjaa yksi periaate: mikään niistä ei ole luotettava yksinään. Suodatusmekanismi voidaan kiertää odottamattomalla formuloinnilla, moderointimalli tuottaa vääriä negatiivisia tuloksia, eikä sisältöpolitiikka kata koskaan jokaista tapausta. Kerrosten pinnoittaminen toimii, koska aukot eivät ole päällekkäisiä – mitä ensimmäinen kerros päästää läpi, toinen kerros todennäköisesti havaitsee.

Käytännön seuraus on tiukka järjestys: jokaisen kerroksen on oltava mahdollisimman kevyt ennen seuraavan suorittamista. Tarkistat muodon ennen suodatusmekanismin kutsumista, ja kutsut suodatusmekanismin ennen generointia – koska vaiheessa 1 hylätty sisältö ei kuluta lainkaan tokeneita.

User
    ↓
[1. Input Validation] → Regex, patterns, rate limiting
    ↓
[2. Mistral Guardrails]  → Pre-generation blocking (403)
    ↓
[3. LLM Generation]      → safe_prompt + secure instructions
    ↓
[4. Output Moderation]   → Moderation API post-generation
    ↓
[5. Logging & Audit]     → Scores, decisions, GDPR audit trail
    ↓
User Response

Täydellinen toteutus

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

# Configuration
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:
    """Complete security architecture for AI applications."""

    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}

    # --- Layer 1: Input Validation ---

    def validate_input(self, text: str) -> dict:
        """Fast validation before any API call."""
        # Maximum length
        if len(text) > 10000:
            return {"valid": False, "reason": "Message too long"}

        # Suspicious characters (Unicode injections)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Invalid characters"}

        # Obvious jailbreak patterns
        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": "Injection pattern detected"
                }

        return {"valid": True}

    # --- Layer 2: Input Moderation ---

    def moderate_input(self, text: str) -> dict:
        """Prompt moderation via 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
        }

    # --- Layer 3: Secure Generation ---

    def generate(self, messages: list) -> str:
        """Generation with guardrails and 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 ""

    # --- Layer 4: Output Moderation ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Response moderation in context."""
        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
        }

    # --- Layer 5: Logging ---

    def log_decision(self, decision: Decision, data: dict):
        """Records the decision for auditing."""
        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))

    # --- Main Pipeline ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Complete secure processing pipeline."""

        # Layer 1: Validation
        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": "Your message cannot be processed."
            }

        # Layer 2: Input Moderation
        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": "This content violates our policy."
            }

        # Layer 3: Generation
        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": "Request blocked by guardrails."
                }
            raise

        # Layer 4: Output Moderation
        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": "The response was filtered."
            }

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

    # --- Utilities ---

    def _check_thresholds(self, scores: dict) -> list:
        """Checks scores against policy thresholds."""
        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:
        """Generates a statistics report."""
        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
            )
        }

Käyttö tuotannossa

# Define the policy
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
    }
}

# Instantiate the architecture
arch = SecureArchitecture(prod_policy)

# Process requests
result = arch.process(
    "Explain how transformers work",
    system_prompt="You are an AI instructor."
)
print(result["status"])   # expected: "allowed"
print(result["content"])

# Consult statistics
print(arch.report())

Valvonta ja hälytykset

Kahden mittarin seuraaminen riittää moderointijärjestelmän ohjaamiseen, ja sinun on tarkkailtava niitä vastakkaisiin suuntiin. Estosuhdetteen tulee pysyä vakaana: äkillinen piikki kertoo joko hyökkäyksestä tai liian tiukasta kynnysarvosta, joka alkaa haitata legitiimejä käyttäjiä. Myös pistejakauma on yhtä tärkeä – jos sisältösi keskittyy juuri kynnysarvon alapuolelle, kynnys on sijoitettu huonosti, ja käyttäjiesi seuraava säätö rikkoo sen.

def configure_alerts(arch: SecureArchitecture):
    """Configures alerts for monitoring."""
    report = arch.report()

    # Alert if block rate is abnormal
    if report["block_rate"] > 0.15:
        logger.warning(
            f"High block rate: "
            f"{report['block_rate']:.1%}"
        )

    # Alert if jailbreak spikes occur
    # Integrate with Prometheus, Grafana, Datadog, etc.

Kurssin yhteenveto

Kurssin päätteeksi olet hallinnut seuraavat asiat:

  • Mukautetut suodatusmekanismit: Estä vaaralliset kehotteet ennen generointia, määritä kynnysarvot kategorioittain ja sovella niitä agenteille.
  • Moderation API: Luokittele sisältöä Mistral Moderation 2:lla, tulkitse pisteitä 11 kategoriassa ja tee automatisoituja päätöksiä.
  • Tuotantoturvallisuus: Määritä sisältöpolitiikat, tunnista kehotteiden injektioyritykset ja varmista GDPR-vaatimustenmukaisuus.
  • Kokonaisarkkitehtuuri: Yhdistä suodatusmekanismit, moderointi ja valvonta robustiksi putkeksi.

Sinulla on nyt kaikki koodi, jota tarvitset täydellisen AI-moderointijärjestelmän käyttöönottoon Mistral API:n avulla.

Keskeiset asiat

  • Turvallisuusarkkitehtuuri sisältää 5 kerrosta: validointi, suodatusmekanismit, generointi, moderointi ja lokitus.
  • Jokainen kerros kompensoi muiden heikkouksia – tämä on syvyyssuuntainen puolustus (defense in depth).
  • Valvo estosuhdetta ja pisteitä tuotannossa.
  • Pidä politiikkasi ajan tasalla säännöllisillä katselmuksilla.
  • Tämän oppitunnin täydellinen koodi on lähtökohta – sovita se omaan kontekstiisi.

Testaa tietosi

Ovatko suodatusmekanismit, moderointi ja injektio selkeitä osana puolustusarkkitehtuuria?

1. Missä vaiheessa mukautetut suodatusmekanismit puuttuvat peliin?

Vastaus: Ennen mallia: ne suodattavat syötteet sääntöjesi mukaan (kielletyt aiheet, muodot) – tämä on ensimmäinen kerros, joka estää pyynnön tekemisen ollenkaan, jos se ei kuulu aihepiiriin.

2. Mitä Mistral Moderation API kattaa?

Vastaus: Yksitoista riskialtista sisältökategoriaa, joista jokaiselle annetaan pistemäärä: kynnysarvosi päättävät, estetäänkö sisältö, merkitäänkö se vai sallitaanko – näin sisältöpolitiikka muutetaan koodiksi.

3. Miten hyvä sisältöpolitiikka määritellään?

Vastaus: Käyttötapauksen perusteella: mikä on sovellukselle hyväksyttävää, kynnysarvot kategorioittain ja niihin liittyvät toimet (esto, uudelleenkirjoitus, eskalointi) – dokumentoituna ja testattuna, ei implisiittisenä.

4. Miten havaitset kehotteiden injektioyritykset?

Vastaus: Kohtelemalla kaikkea ulkoista sisältöä epäilyttävänä: tunnistamalla ohjekuvioita datasta, erottamalla ohjeet datasta, validoimalla tulosteet ja suorittamalla säännöllisiä hyökkäystestejä.

5. Miltä täydellinen turvallisuusarkkitehtuuri näyttää?

Vastaus: Kerrokset: syötteen suodatusmekanismit, sisältömoderointi, tulosteen valvonta, GDPR-vaatimustenmukaisuus (minimointi, oikeudet) ja jäljitettävyys – mikään yksittäinen kerros ei ole täydellinen, mutta niiden pinnoittaminen kompensoi puutteet.

Syvyyssuuntainen puolustus ei ole vain iskulause: tämän kurssin jokainen kerros nappaa kiinni sen, minkä edellinen kerros päästi läpi.