Przejdź do głównej treści
Polski— Wybierz język
Menu

Kompletna architektura bezpieczeństwa

Lekcja 12 z 12 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Łączenie wszystkich elementów
  2. Przegląd architektury
  3. Kompletna implementacja
  4. Użycie produkcyjne
  5. Monitorowanie i alerty
  6. Podsumowanie kursu
  7. Kluczowe wnioski
  8. Sprawdź swoją wiedzę

Zaktualizowano 3 listopada 2026 r. Warstwa generowania wcześniej przekazywała wymyślony format guardrails (enabled), a polityka produkcyjna używała nieistniejących kategorii (hate, violence, unpredictable). Kod został dostosowany do oficjalnego formatu moderation_llm_v2 oraz jedenastu kluczy z mistral-moderation-2603. Wyniki (scores), które są opcjonalne w SDK, są odczytywane z wartością domyślną (fallback). Kod zweryfikowany względem typów SDK mistralai w wersji 3.7.0. Źródła: Moderation & Guardrailing · Python SDK mistralai.

Łączenie wszystkich elementów

W trakcie tego kursu poznałeś guardrails, API Moderation, 11 kategorii, progi, wykrywanie jailbreaków, zgodność z RODO oraz polityki treści. Ta ostatnia lekcja scala wszystkie te elementy w kompletną architekturę bezpieczeństwa gotową do środowiska produkcyjnego.

Przegląd architektury

Mamy pięć warstw, którymi kieruje jedna zasada: żadna z nich nie jest niezawodna sama w sobie. Guardrails można obejść dzięki nieoczekiwanemu sformułowaniu, model moderacji generuje fałszywe negatywy, a polityka treści nigdy nie obejmuje każdego przypadku. Ich warstwowe stosowanie działa, ponieważ luki w ochronie nie nakładają się na siebie – to, co wymknie się pierwszej warstwie, ma duże szanse zostać wychwycone przez drugą.

Praktyczną konsekwencją jest ścisła kolejność: każda warstwa musi być jak najtańsza, zanim uruchomi się kolejna. Walidujesz format przed wywołaniem guardrails, a guardrails wywołujesz przed generowaniem – ponieważ treść odrzucona na etapie 1 nie zużywa ani jednego tokena.

Użytkownik
    ↓
[1. Walidacja wejścia] → Regex, wzorce, limitowanie częstotliwości (rate limiting)
    ↓
[2. Mistral Guardrails]  → Blokowanie przed generowaniem (403)
    ↓
[3. Generowanie LLM]      → safe_prompt + bezpieczne instrukcje
    ↓
[4. Moderacja wyjścia]   → Moderation API po generowaniu
    ↓
[5. Logowanie i audyt]     → Wyniki (scores), decyzje, ślad audytowy RODO
    ↓
Odpowiedź dla użytkownika

Kompletna implementacja

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

# Konfiguracja
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:
    """Kompletna architektura bezpieczeństwa dla aplikacji AI."""

    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}

    # --- Warstwa 1: Walidacja wejścia ---

    def validate_input(self, text: str) -> dict:
        """Szybka walidacja przed jakimkolwiek wywołaniem API."""
        # Maksymalna długość
        if len(text) > 10000:
            return {"valid": False, "reason": "Wiadomość zbyt długa"}

        # Podejrzane znaki (iniekcje Unicode)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Nieprawidłowe znaki"}

        # Oczywiste wzorce jailbreak
        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": "Wykryto wzorzec iniekcji"
                }

        return {"valid": True}

    # --- Warstwa 2: Moderacja wejścia ---

    def moderate_input(self, text: str) -> dict:
        """Moderacja promptu przez 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
        }

    # --- Warstwa 3: Bezpieczne generowanie ---

    def generate(self, messages: list) -> str:
        """Generowanie z guardrails i 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 ""

    # --- Warstwa 4: Moderacja wyjścia ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Moderacja odpowiedzi w kontekście."""
        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
        }

    # --- Warstwa 5: Logowanie ---

    def log_decision(self, decision: Decision, data: dict):
        """Rejestruje decyzję do celów audytowych."""
        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))

    # --- Główny potok (Pipeline) ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Kompletny bezpieczny potok przetwarzania."""

        # Warstwa 1: Walidacja
        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": "Twoja wiadomość nie może zostać przetworzona."
            }

        # Warstwa 2: Moderacja wejścia
        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": "Ta treść narusza naszą politykę."
            }

        # Warstwa 3: Generowanie
        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": "Żądanie zablokowane przez guardrails."
                }
            raise

        # Warstwa 4: Moderacja wyjścia
        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": "Odpowiedź została przefiltrowana."
            }

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

    # --- Narzędzia pomocnicze ---

    def _check_thresholds(self, scores: dict) -> list:
        """Sprawdza wyniki względem progów polityki."""
        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:
        """Generuje raport statystyk."""
        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
            )
        }

Użycie produkcyjne

# Definicja polityki
prod_policy = {
    "name": "Produkcja 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
    }
}

# Instancjonowanie architektury
arch = SecureArchitecture(prod_policy)

# Przetwarzanie żądań
result = arch.process(
    "Wyjaśnij, jak działają transformatory",
    system_prompt="Jesteś instruktorem AI."
)
print(result["status"])   # oczekiwane: "allowed"
print(result["content"])

# Konsultacja statystyk
print(arch.report())

Monitorowanie i alerty

Wystarczą dwie metryki, aby kierować systemem moderacji, i musisz obserwować je w przeciwnych kierunkach. Wskaźnik blokad (block rate) powinien pozostać stabilny: nagły skok sygnalizuje albo atak, albo próg, który jest zbyt rygorystyczny i zaczyna utrudniać działanie legalnym użytkownikom. Rozkład wyników (score distribution) jest równie ważny – jeśli Twoje treści grupują się tuż poniżej progu, oznacza to, że próg jest źle ustawiony, a kolejna zmiana dokonana przez użytkowników go złamie.

def configure_alerts(arch: SecureArchitecture):
    """Konfiguruje alerty do monitorowania."""
    report = arch.report()

    # Alert, jeśli wskaźnik blokad jest nieprawidłowy
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Wysoki wskaźnik blokad: "
            f"{report['block_rate']:.1%}"
        )

    # Alert w przypadku skoków jailbreaków
    # Integracja z Prometheus, Grafana, Datadog itp.

Podsumowanie kursu

Do końca tego kursu opanowałeś:

  • Niestandardowe Guardrails: Blokuj niebezpieczne prompty przed generowaniem, konfiguruj progi dla każdej kategorii, stosuj do agentów
  • API Moderation: Klasyfikuj treści za pomocą Mistral Moderation 2, interpretuj wyniki w 11 kategoriach, podejmuj zautomatyzowane decyzje
  • Bezpieczeństwo produkcyjne: Definiuj polityki treści, wykrywaj iniekcje promptów, zapewnij zgodność z RODO
  • Kompletna architektura: Połącz guardrails + moderację + monitorowanie w solidny potok

Masz teraz cały kod potrzebny do wdrożenia kompletnego systemu moderacji AI z wykorzystaniem API Mistral.

Kluczowe wnioski

  • Architektura bezpieczeństwa obejmuje 5 warstw: walidację, guardrails, generowanie, moderację, logowanie
  • Każda warstwa kompensuje słabości innych – to obrona wielowarstwowa (defense in depth)
  • Monitoruj wskaźnik blokad i wyniki w środowisku produkcyjnym
  • Utrzymuj swoją politykę w aktualności dzięki regularnym przeglądom
  • Kompletny kod z tej lekcji to punkt wyjścia – dostosuj go do swojego kontekstu

Sprawdź swoją wiedzę

Guardrails, moderacja, iniekcja: czy architektura obronna jest jasna?

1. Gdzie interweniują niestandardowe guardrails?

Odpowiedź: Przed modelem: filtrują dane wejściowe zgodnie z Twoimi regułami (zakazane tematy, formaty) – to pierwsza warstwa, która pozwala uniknąć wykonania wywołania, gdy żądanie wykracza poza zakres.

2. Co obejmuje API Mistral Moderation?

Odpowiedź: Jedenaście kategorii ryzykownych treści, z wynikiem dla każdej kategorii: Twoje progi decydują, czy zablokować, oznaczyć flagą, czy zezwolić – zamieniając politykę treści w kod.

3. Jak definiuje się dobrą politykę treści?

Odpowiedź: Przez przypadek użycia: co jest akceptowalne dla aplikacji, progi dla każdej kategorii, powiązane działania (blokowanie, przepisywanie, eskalacja) – udokumentowane i przetestowane, a nie domniemane.

4. Jak wykrywa się próby iniekcji promptów?

Odpowiedź: Traktując wszystkie zewnętrzne treści jako podejrzane: wykrywając wzorce instrukcji w danych, izolując instrukcje od danych, walidując wyjścia – oraz przeprowadzając regularne testy ofensywne.

5. Jak wygląda kompletna architektura bezpieczeństwa?

Odpowiedź: Warstwy: guardrails wejścia, moderacja treści, kontrola wyjścia, zgodność z RODO (minimalizacja, prawa) i możliwość śledzenia (traceability) – żadna pojedyncza warstwa nie jest idealna, ale ich warstwowe stosowanie to kompensuje.

Obrona wielowarstwowa to nie slogan: każda warstwa w tym kursie wyłapuje to, co poprzednia przepuściła.