Conformitate și Jurnal de Audit
Pe această pagină
Conformitate și Jurnal de Audit
Pentru aplicațiile AI aflate în producție, trasabilitatea este esențială. Un jurnal de audit complet vă protejează în timpul unei inspecții, al unui litigiu sau al unui incident. Această lecție vă arată cum să implementați un sistem de audit robust, încheind cursul prin reunirea tuturor elementelor construite până acum—jurnalizare, moderare și protecția datelor—într-un cadru unic și defensabil.
De ce un Jurnal de Audit?
Patru nevoi distincte converg către aceeași infrastructură. În primul rând, conformitatea reglementară: GDPR, Legea Europeană privind IA și standardele industriale vă cer toate să demonstrați ce face sistemul dumneavoastră, iar o demonstrație fără jurnale este inutilă. În al doilea rând, trasabilitatea în sens strict—să știți cine a făcut ce, când, cu ce rezultat, chiar și șase luni mai târziu. Depanarea beneficiază zilnic de acest lucru, deoarece înțelegerea comportamentului neașteptat al modelului necesită recuperarea condițiilor exacte ale apelului. În final, responsabilizarea: documentarea deciziilor luate de AI este ceea ce vă va permite, la momentul potrivit, să arătați că o recomandare contestată s-a bazat pe un proces controlat.
Structura unei Înregistrări de Audit
Clasa dataclass de mai jos este tot atât de mult un contract pe cât este o structură de date. Aceasta grupează identificatorii, contextul aplicației, cererea, răspunsul, verdictul de moderare și metadatele tehnice. Două alegeri merită atenția dumneavoastră. Identificatorul utilizatorului apare doar sub formă hash-uită, niciodată în text clar. De asemenea, promptul nu este stocat: doar hash-ul și lungimea sa sunt păstrate. Acest lucru vă păstrează capacitatea de a dovedi că două apeluri au vizat același conținut fără a crea vreodată o arhivă a ceea ce au scris utilizatorii dumneavoastră.
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)
Sistem Complet de Audit
Clientul care utilizează această structură înlănțuie moderarea intrării, apelul API, moderarea ieșirii și scrie în fiecare caz. Cuvântul important este doar adăugare (append-only): fișierul JSONL este deschis în modul de adăugare, niciodată rescris, ceea ce este condiția ca un jurnal să aibă valoare probatorie. Observați calea unei intrări semnalate—înregistrarea este salvată înainte ca excepția să fie aruncată, cu statusul blocked_input. O blocare lasă deci o urmă la fel ca un succes, iar blocul final except garantează că nicio eroare, indiferent de originea sa, nu scapă neobservată.
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)
În acest exemplu, adresa de email transmisă ca user_id nu ajunge niciodată în fișier: aceasta este hash-uită imediat ce înregistrarea este construită. Un fișier JSONL funcționează bine pentru început și pentru o singură instanță; de îndată ce mai multe procese scriu în paralel, direcționați acest flux către o bază de date sau un colector de jurnale.
Interogări de Audit
Un jurnal pe care nu îl puteți interoga servește doar la ocuparea spațiului pe disc. Citirea linie cu linie a formatului JSONL face exploatarea trivială, iar raportul de mai jos rezumă perioada acoperită, distribuția între succese, erori și blocări, consumul de tokeni și latența medie. Numărul de utilizatori unici se bazează pe hash-uri, ceea ce dovedește incidental că un jurnal pseudonimizat rămâne perfect analizabil.
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))
Retenție și Arhivare
Păstrarea datelor la infinit contrazice principiul limitării stocării; ștergerea prea prematură vă privează de dovada de care ați putea avea nevoie. Rotația rezolvă această dilemă: dincolo de o durată pe care o stabiliți—aici nouăzeci de zile—înregistrările părăsesc fișierul activ pentru o arhivă datată, în timp ce jurnalul curent este rescris doar cu cele recente. Programați această funcție ca o sarcină periodică și aliniați retention_days cu politica validată de consilierul dumneavoastră juridic, nu cu o valoare aleasă la întâmplare.
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")
Legea Europeană privind IA: Ce se Schimbă
Legea Europeană privind IA (AI Act) impune obligații bazate pe nivelul de risc al aplicației dumneavoastră. Logica este graduată: cu cât sistemul dumneavoastră cântărește mai mult în viețile oamenilor, cu atât cerințele sunt mai stricte. Un chatbot FAQ, un rezumat sau o traducere intră sub incidența riscului minim și necesită doar transparență de bază. De îndată ce există conversație sau analiză a sentimentelor, treceți la risc limitat, cu obligația de a informa utilizatorul că interacționează cu un AI. Saltul este brusc pentru riscul ridicat—scoring de credit, recrutare, diagnostic medical—unde se adaugă evaluarea conformității, gestionarea riscurilor, documentarea datelor de antrenament, trasabilitatea completă, supravegherea umană și demonstrarea acurateței. Anumite utilizări, cum ar fi scoringul social sau manipularea subliminală, sunt pur și simplu interzise.
# 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"]
}
}
Situați onest proiectul dumneavoastră în această grilă înainte de a scrie prima linie de cod: o aplicație clasificată ca având risc ridicat impune constrângeri arhitecturale—jurnalizare exhaustivă, punct de control uman—care nu pot fi grefate ulterior unui sistem conceput fără ele.
Listă de Verificare pentru Conformitate
- Jurnal de audit doar cu adăugare (append-only) și cu timestamp
- Hash-uirea datelor cu caracter personal în jurnale (niciodată în text clar)
- Moderare sistematică a intrărilor și ieșirilor
- Registrul activităților de prelucrare actualizat conform GDPR
- Politică definită de retenție și arhivare
- Evaluarea nivelului de risc conform AI Act efectuată
- Informarea utilizatorilor că interacționează cu un AI
- Supraveghere umană pentru deciziile cu impact
Puncte cheie
- Un jurnal de audit este obligatoriu pentru conformitatea reglementară
- Jurnalizați în modul doar-adăugare: nu modificați niciodată înregistrările existente
- Hash-uiți toate datele cu caracter personal în jurnalele de audit
- Legea Europeană privind IA clasifică aplicațiile pe niveluri de risc
- Implementați moderare automată ȘI supraveghere umană
- Definiți o politică de retenție și arhivați regulat
Testați-vă Cunoștințele
Douăzeci și două lecții API: validați mecanismele care mențin producția funcțională.
1. De ce să migrați către API-ul Responses în loc să rămâneți la Chat Completions?
Răspuns: Este API-ul modern OpenAI: gestionare integrată a stării conversației, instrumente native și evoluție concentrată pe acesta—Chat Completions rămâne suportat, dar este legacy.
2. Cum alegeți între Sol, Terra și Luna din partea API?
Răspuns: gpt-5.6-sol pentru sarcini exigente, terra pentru echilibrul cost/calitate, luna pentru volume economice—iar nivelul de raționament (none→max) se ajustează apoi per cerere.
3. Ce garantează Structured Output?
Răspuns: Un output conform schemei JSON furnizate—câmpuri, tipuri, structură—exploatabil de un program fără analiză defensivă sau reparare.
4. Ce faceți în fața unei erori 429?
Răspuns: Respectați limitele de rată: reîncercați cu backoff exponențial (și jitter), limitați încercările și planificați un disjunctor (circuit breaker)—niciodată o buclă de reîncercare imediată.
5. Numiți două protecții indispensabile din partea securității aplicației.
Răspuns: Moderarea conținutului incoming/outgoing prin API-ul dedicat și apărarea împotriva injectării de prompturi: izolați instrucțiunile de date, validați ieșirile, limitați capabilitățile expuse.
Producție, securitate, conformitate: ultimele trei blocuri ale cursului fac diferența dintre un prototip și un serviciu—păstrați-le ca listă de verificare.