Salt la conținutul principal
Română— Alege o limbă
Meniu

Conformitate și Jurnal de Audit

Lecția 22 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Conformitate și Jurnal de Audit
  2. De ce un Jurnal de Audit?
  3. Structura unei Înregistrări de Audit
  4. Sistem Complet de Audit
  5. Interogări de Audit
  6. Retenție și Arhivare
  7. Legea Europeană privind IA: Ce se Schimbă
  8. Listă de Verificare pentru Conformitate
  9. Puncte cheie
  10. Testați-vă Cunoștințele

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.