Compliance und Prüfpfad
Auf dieser Seite
Compliance und Prüfpfad
Für KI-Anwendungen in der Produktion ist Rückverfolgbarkeit unerlässlich. Ein vollständiger Prüfpfad schützt Sie bei einer Inspektion, einem Streitfall oder einem Vorfall. Diese Lektion zeigt Ihnen, wie Sie ein robustes Audit-System implementieren, indem Sie am Ende des Kurses alles, was Sie bisher aufgebaut haben – Protokollierung, Moderation und Datenschutz – in einem einzigen, verteidigbaren Rahmen zusammenführen.
Warum ein Prüfpfad?
Vier unterschiedliche Bedürfnisse treffen auf dieselbe Infrastruktur. Erstens regulatorische Compliance: Die DSGVO, der europäische KI-Gesetzgeber (AI Act) und branchenspezifische Standards verlangen von Ihnen, nachzuweisen, was Ihr System tut. Eine Demonstration ohne Protokolle ist wertlos. Zweitens Rückverfolgbarkeit im strengen Sinne – zu wissen, wer was wann getan hat und mit welchem Ergebnis, selbst sechs Monate später. Das Debugging profitiert täglich davon, da das Verständnis unerwarteten Modellverhaltens die Wiederherstellung der exakten Bedingungen des Aufrufs erfordert. Schließlich Verantwortlichkeit: Die Dokumentation von Entscheidungen, die von der KI getroffen wurden, ermöglicht es Ihnen, wenn der Zeitpunkt kommt, nachzuweisen, dass eine angefochtene Empfehlung auf einem kontrollierten Prozess beruhte.
Struktur einer Audit-Eintragung
Der folgende dataclass ist sowohl ein Vertrag als auch eine Datenstruktur. Er gruppiert Identifikatoren, Anwendungskontext, die Anfrage, die Antwort, das Moderationsergebnis und technische Metadaten. Zwei Entscheidungen verdienen Ihre Aufmerksamkeit. Die Benutzer-ID erscheint nur in gehashter Form, niemals im Klartext. Und der Prompt wird nicht gespeichert: nur sein Hash und seine Länge. Dies bewahrt Ihre Fähigkeit, nachzuweisen, dass zwei Aufrufe denselben Inhalt betrafen, ohne jemals ein Archiv dessen zu erstellen, was Ihre Benutzer geschrieben haben.
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)
Komplettes Audit-System
Der Client, der diese Struktur nutzt, verknüpft Eingangsmoderation, API-Aufruf, Ausgangsmoderation und schreibt in jedem Fall. Das wichtige Wort ist append-only: Die JSONL-Datei wird im Anhängemodus geöffnet, niemals neu geschrieben, was die Bedingung ist, damit ein Protokoll Beweiskraft besitzt. Beachten Sie den Pfad einer markierten Eintragung – die Eintragung wird vor dem Werfen der Ausnahme gespeichert, mit dem Status blocked_input. Ein Block hinterlässt also eine Spur genau wie ein Erfolg, und der finale except-Block garantiert, dass kein Fehler, unabhängig von seinem Ursprung, unter dem Radar bleibt.
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)
In diesem Beispiel erreicht die als user_id übergebene E-Mail-Adresse niemals die Datei: Sie wird gehasht, sobald die Eintragung erstellt wird. Eine JSONL-Datei funktioniert gut, um zu beginnen und für eine einzelne Instanz; sobald mehrere Prozesse parallel schreiben, leiten Sie diesen Stream an eine Datenbank oder einen Protokollsammler weiter.
Abfragen des Audits
Ein Protokoll, das nicht abgefragt werden kann, dient nur dazu, Festplattenspeicher zu belegen. Die Zeile-für-Zeile-Lesung des JSONL-Formats macht die Auswertung trivial, und der folgende Bericht fasst den abgedeckten Zeitraum, die Verteilung zwischen Erfolgen, Fehlern und Blockaden, den Tokenverbrauch und die durchschnittliche Latenz zusammen. Die Anzahl der eindeutigen Benutzer stützt sich auf Hashes, was beiläufig beweist, dass ein pseudonymisiertes Protokoll vollständig analysierbar bleibt.
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))
Aufbewahrung und Archivierung
Die unendliche Aufbewahrung von Daten widerspricht dem Prinzip der Speicherbegrenzung; ein zu frühes Löschen beraubt Sie des Beweises, den Sie möglicherweise benötigen. Rotation löst dieses Dilemma: Jenseits einer von Ihnen festgelegten Dauer – hier 90 Tage – verlassen Einträge die aktive Datei für ein datiertes Archiv, während das aktuelle Protokoll nur mit den jüngsten neu geschrieben wird. Planen Sie diese Funktion als periodische Aufgabe und richten Sie retention_days auf die von Ihrem Rechtsberater genehmigte Richtlinie aus, nicht auf einen zufälligen Wert.
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")
Europäischer AI Act: Was ändert sich
Der Europäische AI Act (AI Act) verhängt Verpflichtungen basierend auf dem Risikostufe Ihrer Anwendung. Die Logik ist gestuft: Je stärker Ihr System auf das Leben der Menschen einwirkt, desto strenger sind die Anforderungen. Ein FAQ-Chatbot, eine Zusammenfassung oder eine Übersetzung fällt unter minimales Risiko und erfordert nur grundlegende Transparenz. Sobald es um Konversation oder Sentiment-Analyse geht, wechseln Sie zum begrenzten Risiko, mit der Verpflichtung, den Benutzer zu informieren, dass er mit einer KI interagiert. Der Sprung ist abrupt für hohes Risiko – Bonitätsprüfung, Recruiting, medizinische Diagnose – wo Konformitätsbewertung, Risikomanagement, Dokumentation der Trainingsdaten, vollständige Rückverfolgbarkeit, menschliche Aufsicht und Nachweis der Genauigkeit hinzukommen. Bestimmte Anwendungen, wie soziale Bewertung oder subliminale Manipulation, sind rein verboten.
# 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"]
}
}
Situieren Sie Ihr Projekt ehrlich in diesem Raster, bevor Sie die erste Zeile Code schreiben: Eine als hohes Risiko eingestufte Anwendung verhängt architektonische Zwänge – erschöpfende Protokollierung, menschliche Kontrollpunkte –, die nicht nachträglich an ein System angefügt werden können, das ohne sie entworfen wurde.
Compliance-Checkliste
- Append-only-Prüfpfad mit Zeitstempel
- Hash von personenbezogenen Daten in Protokollen (niemals im Klartext)
- Systematische Moderation von Eingängen und Ausgängen
- Auf dem neuesten Stand befindliches Verzeichnis der Verarbeitungstätigkeiten gemäß DSGVO
- Definierte Aufbewahrungs- und Archivrichtlinie
- Bewertung der Risikostufe gemäß AI Act durchgeführt
- Benutzer informiert, dass sie mit einer KI interagieren
- Menschliche Aufsicht für einschneidende Entscheidungen
Kernaussagen
- Ein Prüfpfad ist verpflichtend für die regulatorische Compliance
- Protokollieren Sie im append-only-Modus: Modifizieren Sie niemals bestehende Einträge
- Hashen Sie alle personenbezogenen Daten in Audit-Protokollen
- Der Europäische AI Act stuft Anwendungen nach Risikostufe ein
- Implementieren Sie automatische Moderation UND menschliche Aufsicht
- Definieren Sie eine Aufbewahrungsrichtlinie und archivieren Sie regelmäßig
Wissen testen
Zwölf API-Lektionen: Validieren Sie die Mechanismen, die die Produktion zusammenhalten.
1. Warum migrieren Sie zur Responses API statt bei Chat Completions zu bleiben?
Antwort: Es ist die moderne API von OpenAI: integrierte Verwaltung des Gesprächszustands, native Tools und eine Evolution, die sich darauf konzentriert – Chat Completions bleibt unterstützt, ist aber veraltet.
2. Wie entscheiden Sie auf der API-Seite zwischen Sol, Terra und Luna?
Antwort: gpt-5.6-sol für anspruchsvolle Aufgaben, terra für das Gleichgewicht aus Kosten und Qualität, luna für wirtschaftliche Volumen – und das Reasoning-Level (none→max) wird dann pro Anfrage angepasst.
3. Was garantiert Strukturierte Ausgabe?
Antwort: Ausgabe, die dem bereitgestellten JSON-Schema entspricht – Felder, Typen, Struktur – die von einem Programm ohne defensives Parsen oder Reparatur ausgenutzt werden kann.
4. Was tun Sie angesichts eines 429-Fehlers?
Antwort: Respektieren Sie Rate Limits: Wiederholen Sie mit exponentiellem Backoff (und Jitter), begrenzen Sie die Versuche und planen Sie einen Circuit Breaker ein – niemals einen sofortigen Wiederholungsloop.
5. Nennen Sie zwei unverzichtbare Schutzmaßnahmen auf der Anwendungssicherheitsebene.
Antwort: Moderation von eingehendem und ausgehendem Inhalt über die dedizierte API und Verteidigung gegen Prompt-Injection: Trennen Sie Anweisungen von Daten, validieren Sie Ausgaben und begrenzen Sie exponierte Fähigkeiten.
Produktion, Sicherheit, Compliance: Die letzten drei Blöcke des Kurses machen den Unterschied zwischen einem Prototyp und einem Service – halten Sie sie als Checkliste.