Megfelelés és naplózás
Ezen az oldalon
Megfelelés és naplózás
Éles környezetben futó AI-alkalmazások esetén a nyomon követhetőség elengedhetetlen. A teljes körű auditálási napló (audit trail) megvéd téged egy ellenőrzés, egy jogvita vagy egy incidens során. Ez a lecke bemutatja, hogyan építs fel egy robusztus naplózási rendszert, lezárva ezzel a tanfolyamot: itt kapcsolódik össze minden, amit eddig felépítettél – a naplózás, a moderálás és az adatvédelem – egyetlen, jól védhető keretrendszerbe.
Miért van szükség auditálási naplóra?
Négy különböző igény fut össze ugyanazon az infrastruktúrán. Először is: szabályozói megfelelés. A GDPR, az európai AI-törvény (AI Act) és az iparági szabványok mind megkövetelik, hogy bizonyítani tudd, mit csinál a rendszered; bizonyíték naplók nélkül pedig értéktelen. Másodszor: nyomon követhetőség szigorú értelemben – tudnod kell, ki, mikor, mit csinált, milyen eredménnyel, akár hat hónappal később is. A hibakeresés nap mint nap profitál ebből, hiszen a váratlan modellviselkedés megértéséhez vissza kell tudnod állítani a hívás pontos körülményeit. Végül: elszámoltathatóság. Az AI által hozott döntések dokumentálása teszi lehetővé, hogy szükség esetén igazolni tudd: egy vitatott ajánlás ellenőrzött folyamaton alapul.
Egy audit-bejegyzés felépítése
Az alábbi dataclass egyszerre szerződés és adatszerkezet. Csoportosítja az azonosítókat, az alkalmazáskontextust, a kérést, a választ, a moderálási döntést és a technikai metaadatokat. Két választás kiemelt figyelmet érdemel. A felhasználói azonosító csak hashelt formában jelenik meg, soha nem olvasható szövegként. A promptot pedig nem tároljuk: csak a hash-ét és a hosszát rögzítjük. Így bizonyítható marad, hogy két hívás ugyanarra a tartalomra vonatkozott, anélkül, hogy archívumot hoznál létre a felhasználóid által írtakból.
from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib
@dataclass
class AuditRecord:
"""Audit record for an API call."""
# Identifiers
audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
timestamp: str = field(
default_factory=lambda: datetime.now().isoformat()
)
# Context
user_id_hash: str = "" # Never the plain ID
session_id: str = ""
application: str = ""
# Request (no sensitive data)
model: str = ""
prompt_hash: str = "" # Hash of the prompt, not the prompt itself
prompt_length: int = 0
# Response
response_id: str = ""
output_length: int = 0
input_tokens: int = 0
output_tokens: int = 0
# Moderation
input_flagged: bool = False
output_flagged: bool = False
# Metadata
duration_ms: int = 0
status: str = "success"
error: Optional[str] = None
def to_json(self) -> str:
return json.dumps(asdict(self), ensure_ascii=False)
Teljes auditáló rendszer
Az ezt a struktúrát használó kliens láncolja össze a bemeneti moderálást, az API-hívást, a kimeneti moderálást, és minden esetben ír a naplóba. A kulcsszó: csak hozzáfűzés (append-only). A JSONL-fájlt hozzáfűző módban nyitjuk meg, soha nem írjuk felül; ez a feltétele annak, hogy a naplónak bizonyító ereje legyen. Figyeld meg a megjelölt bejegyzés útját: a rekordot mielőtt kivételt dobnánk, elmentjük, blocked_input állapottal. Egy blokkolás tehát ugyanúgy nyomot hagy, mint egy siker, a végső except blokk pedig garantálja, hogy semmilyen hiba – bármilyen eredetű is – ne csússzon észrevétlenül.
import time
from openai import OpenAI
class AuditedClient:
"""OpenAI client with integrated audit trail."""
def __init__(self, application: str, audit_store: str = "audit.jsonl"):
self.client = OpenAI()
self.application = application
self.audit_store = audit_store
def _hash(self, text: str) -> str:
"""Truncated SHA-256 hash for auditing."""
return hashlib.sha256(text.encode()).hexdigest()[:16]
def _save_audit(self, record: AuditRecord):
"""Saves an audit record (append-only)."""
with open(self.audit_store, "a", encoding="utf-8") as f:
f.write(record.to_json() + "\n")
def create(self, user_id: str, session_id: str,
model: str, input: str, **kwargs) -> object:
"""API call with automatic auditing."""
record = AuditRecord(
user_id_hash=self._hash(user_id),
session_id=session_id,
application=self.application,
model=model,
prompt_hash=self._hash(input),
prompt_length=len(input),
)
start = time.monotonic()
try:
# Input moderation
mod = self.client.moderations.create(
model="omni-moderation-latest",
input=input
)
record.input_flagged = mod.results[0].flagged
if record.input_flagged:
record.status = "blocked_input"
self._save_audit(record)
raise ValueError("Inappropriate input content")
# API call
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
# Output moderation
mod_out = self.client.moderations.create(
model="omni-moderation-latest",
input=response.output_text
)
record.output_flagged = mod_out.results[0].flagged
# Fill metrics
record.response_id = response.id
record.output_length = len(response.output_text)
record.input_tokens = response.usage.input_tokens
record.output_tokens = response.usage.output_tokens
record.duration_ms = round((time.monotonic() - start) * 1000)
record.status = "success"
self._save_audit(record)
return response
except Exception as e:
record.duration_ms = round((time.monotonic() - start) * 1000)
record.status = "error"
record.error = type(e).__name__
self._save_audit(record)
raise
# Usage
audited = AuditedClient(application="support-chatbot")
response = audited.create(
user_id="[email protected]",
session_id="sess-abc123",
model="gpt-5.6-terra",
input="How do I return a product?"
)
print(response.output_text)
Ebben a példában a user_id-ként átadott e-mail-cím soha nem kerül a fájlba: a rekord létrehozásakor azonnal hasheljük. Egy JSONL-fájl tökéletesen megfelel a kezdéshez és egyetlen példány esetén; amint több folyamat ír párhuzamosan, irányítsd ezt a folyamot adatbázisba vagy naplógyűjtőbe.
Lekérdezések az audit-naplón
Egy napló, amit nem tudsz lekérdezni, csak a lemezterületet foglalja. A JSONL-formátum soronkénti olvasása triviálissá teszi a feldolgozást; az alábbi jelentés összefoglalja a lefedett időszakot, a sikerek, hibák és blokkolások eloszlását, a tokenfogyasztást és az átlagos késleltetést. Az egyedi felhasználók száma hasheken alapul, ami mellesleg bizonyítja: egy álanevesített napló is tökéletesen elemezhető.
import json
def read_audit(file: str = "audit.jsonl") -> list[dict]:
"""Reads all audit records."""
records = []
try:
with open(file, "r", encoding="utf-8") as f:
for line in f:
if line.strip():
records.append(json.loads(line))
except FileNotFoundError:
pass
return records
def audit_report(file: str = "audit.jsonl") -> dict:
"""Generates an audit report."""
records = read_audit(file)
if not records:
return {"message": "No records"}
total = len(records)
errors = sum(1 for r in records if r["status"] == "error")
blocked = sum(1 for r in records if r["status"] == "blocked_input")
tokens_total = sum(
r.get("input_tokens", 0) + r.get("output_tokens", 0)
for r in records
)
durations = [r["duration_ms"] for r in records if r["duration_ms"] > 0]
return {
"period": {
"start": records[0]["timestamp"],
"end": records[-1]["timestamp"],
},
"total_calls": total,
"successes": total - errors - blocked,
"errors": errors,
"moderation_blocks": blocked,
"tokens_consumed": tokens_total,
"avg_latency_ms": round(sum(durations) / max(len(durations), 1)),
"unique_users": len(set(r["user_id_hash"] for r in records)),
}
print(json.dumps(audit_report(), indent=2, ensure_ascii=False))
Megőrzés és archiválás
Az adatok végtelen ideig tartó tárolása ellentmond a tárolás korlátozásának elvével; a túl korai törlés viszont megfoszt a szükséges bizonyítéktól. A rotáció oldja fel ezt a dilemmát: egy általad meghatározott időtartamon túl – itt 90 nap – a rekordok kikerülnek az aktív fájlból egy dátumozott archívumba, míg az aktuális napló csak a legfrissebbekkel marad meg. Ütemezd ezt a függvényt periodikus feladatként, és a retention_days értékét igazítsd a jogi tanácsadóid által jóváhagyott szabályzathoz, ne egy véletlenszerűen választott számhoz.
from datetime import datetime, timedelta
import shutil
import os
def archive_audit(file: str = "audit.jsonl",
retention_days: int = 90):
"""Archives and purges old records."""
records = read_audit(file)
limit = datetime.now() - timedelta(days=retention_days)
recent = []
archives = []
for record in records:
date_record = datetime.fromisoformat(record["timestamp"])
if date_record > limit:
recent.append(record)
else:
archives.append(record)
if archives:
# Archive old ones
archive_name = f"audit_archive_{datetime.now().strftime('%Y%m%d')}.jsonl"
with open(archive_name, "w", encoding="utf-8") as f:
for record in archives:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
# Rewrite main file with recent ones
with open(file, "w", encoding="utf-8") as f:
for record in recent:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
print(f"Archived {len(archives)} records to {archive_name}")
print(f"Kept {len(recent)} recent records")
Európai AI-törvény (AI Act): mi változik
Az európai AI-törvény (AI Act) az alkalmazásod kockázati szintje alapján ró ki kötelezettségeket. A logika fokozatos: minél nagyobb súllyal hat rendszered az emberek életére, annál szigorúbbak a követelmények. Egy GYIK-chatbot, egy összefoglaló vagy egy fordítás minimális kockázatúnak minősül, és csupán alapvető átláthatóságot igényel. Amint beszélgetés vagy érzelemelemzés lép képbe, már a korlátozott kockázatú kategóriába kerülsz, ahol kötelező tájékoztatni a felhasználót, hogy AI-val lép kapcsolatba. A ugrás drasztikus a magas kockázatú eseteknél – hitelminősítés, toborzás, orvosi diagnózis –, ahol hozzáadódik a megfelelőségértékelés, a kockázatkezelés, a tanító adatok dokumentálása, a teljes körű nyomon követhetőség, az emberi felügyelet és a pontosság igazolása. Bizonyos felhasználási módok, mint a közösségi pontozás vagy a szubliminális manipuláció, kifejezetten tiltottak.
# Assess the risk level of your application
RISK_LEVELS = {
"minimal": {
"examples": ["FAQ chatbot", "text summary", "translation"],
"obligations": ["Basic transparency"]
},
"limited": {
"examples": ["customer service chatbot", "sentiment analysis"],
"obligations": ["Inform the user they are interacting with an AI"]
},
"high": {
"examples": ["credit scoring", "recruitment", "medical diagnosis"],
"obligations": [
"Conformity assessment",
"Risk management system",
"Documented training data",
"Logging and complete traceability",
"Mandatory human supervision",
"Demonstrated accuracy and robustness"
]
},
"unacceptable": {
"examples": ["social scoring", "subliminal manipulation"],
"obligations": ["PROHIBITED"]
}
}
Őszintén helyezd el a projektedet ebben a mátrixban, még az első sor kód megírása előtt: egy magas kockázatú alkalmazás olyan architektúrális kényszereket szab – kimerítő naplózás, emberi ellenőrzési pontok –, amelyeket utólag nem lehet ráoltani egy olyan rendszerre, amelyet ezek nélkül terveztek.
Megfelelési ellenőrzőlista
- Csak hozzáfűthető (append-only) audit-napló időbélyeggel
- Személyes adatok hashelése a naplókban (soha nem olvasható szövegként)
- A bemenetek és kimenetek szisztematikus moderálása
- Naprakész GDPR-adatkezelési nyilvántartás
- Meghatározott megőrzési és archiválási szabályzat
- Elvégzett AI Act kockázatszint-felmérés
- A felhasználók tájékoztatása, hogy AI-val lépnek kapcsolatba
- Emberi felügyelet jelentős hatású döntések esetén
Főbb megállapítások
- Az auditálási napló kötelező a szabályozói megfeleléshez
- Naplózz csak hozzáfűző módban: soha ne módosíts meglévő bejegyzéseket
- Hashelj minden személyes adatot az audit-naplókban
- Az európai AI-törvény kockázati szintek szerint osztályozza az alkalmazásokat
- Valósíts meg automatikus moderálást ÉS emberi felügyeletet
- Határozz meg megőrzési szabályzatot, és rendszeresen archiválj
Teszteld a tudásod!
Huszonkét API-lecke: validáld azokat a mechanizmusokat, amelyek az éles rendszert összetartják.
1. Miért érdemes áttérni a Responses API-ra, ahelyett, hogy a Chat Completionsön maradnál?
Válasz: Ez az OpenAI modern API-ja: integrált beszélgetésállapot-kezelés, natív eszközök, és a fejlesztés fókusza is ezen van – a Chat Completions továbbra is támogatott, de örökölt.
2. Hogyan választasz Sol, Terra és Luna között az API oldalán?
Válasz: A gpt-5.6-sol igényes feladatokhoz, a terra a költség/minőség egyensúlyhoz, a luna pedig gazdaságos nagy volumenhez – a következtetési szintet (none→max) ezután kérésenként állítod.
3. Mit garantál a Structured Output?
Válasz: A megadott JSON-sémának megfelelő kimenetet – mezők, típusok, struktúra –, amelyet program közvetlenül felhasználhat védekező elemzés vagy javítás nélkül.
4. Mit teszel egy 429-es hiba esetén?
Válasz: Tiszteletben tartod a sebességkorlátokat: exponenciális visszalépéssel (és jitterrel) próbálkozol újra, korlátozod a kísérletek számát, és tervezel áramkörmegszakítót – soha nem indítasz azonnali újrapróbálkozási ciklust.
5. Nevezz meg két nélkülözhetetlen védelmi intézkedést az alkalmazásbiztonság oldalán.
Válasz: A bejövő és kimenő tartalom moderálása a dedikált API-n keresztül, valamint a prompt-injekció elleni védelem: válaszd el az utasításokat az adatoktól, validáld a kimeneteket, és korlátozd a kitett képességeket.
Élesítés, biztonság, megfelelés: a tanfolyam utolsó három blokkja teszi a különbséget prototípus és szolgáltatás között – tartsd meg őket ellenőrzőlistaként.