Visiška saugumo architektūra
Šiame puslapyje
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_v2formatą ir vienuolika raktų išmistral-moderation-2603. Balai, kurie SDK yra neprivalomi, nuskaityti su atsargine verte. Kodas patikrintas pagalmistralaiSDK 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.