Privacy dei dati e GDPR
In questa pagina
Privacy dei dati e GDPR
In quanto sviluppatore europeo, devi comprendere come i dati fluiscono attraverso le API di OpenAI e quali misure adottare per conformarti al GDPR (Regolamento Generale sulla Protezione dei Dati). Questa lezione affronta gli aspetti tecnici della conformità. Non sostituisce il parere del tuo Responsabile della Protezione dei Dati (DPO), ma ti fornisce le pratiche di codifica che renderanno possibile il suo lavoro e che, se trascurate in fase di progettazione, diventeranno estremamente costose da correggere in seguito.
Come OpenAI elabora i tuoi dati
Tramite le API (non ChatGPT)
Distinguere l’utilizzo delle API dall’uso consumer è il punto di partenza per qualsiasi discussione su questo argomento. Quando utilizzi le API di OpenAI per la tua applicazione, i dati non vengono utilizzati per addestrare i modelli: questa è la politica delle API, che differisce da quella di ChatGPT, ed è l’argomento che userai per rispondere all’obiezione più comune nei comitati di sicurezza. Tuttavia, i dati vengono conservati per 30 giorni per consentire il rilevamento di abusi, per poi essere eliminati. Puoi abbreviare questo periodo di conservazione: puoi richiedere l’eliminazione anticipata tramite la funzionalità Zero Data Retention. Un punto rimane da documentare nella tua valutazione d’impatto: i dati transitano attraverso i server di OpenAI, situati principalmente negli Stati Uniti, il che costituisce un trasferimento al di fuori dell’Unione Europea.
# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls
Minimizzazione dei dati
Il GDPR richiede di elaborare solo i dati strettamente necessari. Applica questo principio alle tue chiamate API: nella stragrande maggioranza dei casi, il modello non ha bisogno di conoscere il nome, l’indirizzo email o il numero di telefono di una persona per riassumere la sua richiesta o classificarne l’oggetto.
La pseudonimizzazione reversibile risponde esattamente a questa esigenza. Prima dell’invio, ogni dato personale viene sostituito con un marcatore numerato e la mappatura viene mantenuta in memoria sul tuo server. Le API vedono solo [EMAIL_1] e [TEL_1]. Al ritorno, i marcatori vengono ripristinati nel testo generato e l’utente finale riceve una risposta completa senza che le coordinate abbiano mai lasciato il tuo sistema.
import re
def anonymize_before_send(text: str) -> tuple[str, dict]:
"""Anonymizes personal data before sending to the API."""
replacements = {}
counter = {"email": 0, "phone": 0, "name": 0}
# Emails
def replace_email(match):
counter["email"] += 1
key = f"[EMAIL_{counter['email']}]"
replacements[key] = match.group()
return key
text = re.sub(
r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
replace_email, text
)
# French phone numbers
def replace_phone(match):
counter["phone"] += 1
key = f"[TEL_{counter['phone']}]"
replacements[key] = match.group()
return key
text = re.sub(
r'\b(?:0|\+33)\s*[1-9](?:[\s.-]*\d{2}){4}\b',
replace_phone, text
)
return text, replacements
def restore_data(text: str, replacements: dict) -> str:
"""Restores data after API processing."""
for key, value in replacements.items():
text = text.replace(key, value)
return text
# Usage
from openai import OpenAI
client = OpenAI()
original_text = "Contact Jean Dupont at [email protected] or 06 12 34 56 78"
# Anonymize
anonymous_text, mapping = anonymize_before_send(original_text)
print(f"Sent to API: {anonymous_text}")
# Sent to API: Contact Jean Dupont at [EMAIL_1] or [TEL_1]
# API call with anonymized data
response = client.responses.create(
model="gpt-5.6-terra",
input=f"Summarize this message: {anonymous_text}"
)
# Restore
result = restore_data(response.output_text, mapping)
print(f"Final result: {result}")
Osserva attentamente l’output di questo esempio: “Jean Dupont” è ancora presente. Il contatore include una voce per name, ma nessuna espressione regolare la riempie: rilevare un cognome richiede il riconoscimento delle entità nominate, non un modello di caratteri. Considera quindi questa funzione come una base su cui costruire, non come una soluzione completa di anonimizzazione.
Pipeline conforme al GDPR
La minimizzazione da sola non basta: il regolamento richiede anche che ogni operazione di elaborazione si basi su una base giuridica identificata e venga registrata. Questa pipeline combina entrambi i requisiti in quattro passaggi: registrare lo scopo e la base giuridica, minimizzare, chiamare, ripristinare. L’identificativo dell’utente non viene mai memorizzato in chiaro ma sottoposto a hashing, così il registro rimane utilizzabile per le operazioni di conteggio senza costituire esso stesso un file di dati personali.
from datetime import datetime
import json
import hashlib
class GDPRCompliantPipeline:
"""GDPR-compliant processing pipeline."""
def __init__(self):
self.client = OpenAI()
self.processing_logs = []
def process(self, text: str, purpose: str,
legal_basis: str, user_id: str) -> str:
"""Processes text in compliance with GDPR."""
# 1. Record the legal basis of processing
processing = {
"timestamp": datetime.now().isoformat(),
"user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
"purpose": purpose,
"legal_basis": legal_basis, # consent, legitimate_interest, contract
}
# 2. Minimize data
anonymous_text, mapping = anonymize_before_send(text)
# 3. API call
response = self.client.responses.create(
model="gpt-5.6-terra",
input=anonymous_text,
# Store for the shortest time possible
)
processing["tokens_used"] = response.usage.total_tokens
self.processing_logs.append(processing)
# 4. Restore and return
return restore_data(response.output_text, mapping)
def export_register(self) -> str:
"""Exports the record of processing activities (Article 30 GDPR)."""
return json.dumps(self.processing_logs, indent=2, ensure_ascii=False)
# Usage
pipeline = GDPRCompliantPipeline()
result = pipeline.process(
text="Customer Pierre Martin wishes to cancel his subscription.",
purpose="Cancellation request processing",
legal_basis="contract",
user_id="user-456"
)
print(result)
print(pipeline.export_register())
Il parametro legal_basis merita attenzione: l’elaborazione di una richiesta di cancellazione rientra nell’esecuzione del contratto, non nel consenso. Scegliere la base giuridica errata è l’errore più frequente e consequenziale, poiché determina i diritti che un utente può esercitare su tale elaborazione.
Gestione del consenso
Quando la base giuridica scelta è il consenso, questo deve essere raccolto, datato, versionato e, soprattutto, revocabile. Il gestore sottostante memorizza il consenso per scopo: accettare l’assistenza AI non implica l’accettazione dell’analisi del testo, e verifica questa corrispondenza prima di ogni operazione di elaborazione. Il metodo di revoca contiene un commento critico: eliminare il record del consenso non basta; devi anche eliminare i dati che da esso dipendevano.
class ConsentManager:
"""Manages user consent for AI processing."""
def __init__(self):
self.consents: dict[str, dict] = {}
def record_consent(self, user_id: str, purposes: list[str]):
"""Records user consent."""
self.consents[user_id] = {
"purposes": purposes,
"date": datetime.now().isoformat(),
"version": "v1.0"
}
def verify_consent(self, user_id: str, purpose: str) -> bool:
"""Checks if the user has consented to a purpose."""
consent = self.consents.get(user_id)
if not consent:
return False
return purpose in consent["purposes"]
def withdraw_consent(self, user_id: str):
"""Withdraws consent (right to withdraw)."""
if user_id in self.consents:
del self.consents[user_id]
# Here: also delete associated data
# Usage
consent = ConsentManager()
# User consents to AI processing
consent.record_consent("user-123", ["ai_assistance", "text_analysis"])
# Verify before every processing operation
if consent.verify_consent("user-123", "ai_assistance"):
# Proceed with processing
response = client.responses.create(
model="gpt-5.6-terra",
input="User question"
)
else:
print("Consent required for this processing")
Diritto alla cancellazione (Articolo 17)
Quando un utente richiede la cancellazione dei propri dati, il tuo obbligo si estende oltre il database dell’applicazione. Devi spazzare via tutte le posizioni: dati locali, log contenenti informazioni personali (spesso dimenticati) e documentare l’operazione per giustificarla. Sul lato API, l’azione è già coperta dalla politica di conservazione: i dati inviati scompaiono automaticamente dopo trenta giorni, o immediatamente se Zero Data Retention è abilitato.
def exercise_right_to_erasure(user_id: str):
"""Implements the GDPR right to erasure."""
# 1. Delete local data
# delete_user_data(user_id)
# 2. Data sent to the OpenAI API is deleted
# automatically after 30 days (or immediately
# with Zero Data Retention enabled)
# 3. Delete logs containing personal data
# delete_user_logs(user_id)
# 4. Document the deletion
log = {
"action": "right_to_erasure",
"user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
"date": datetime.now().isoformat(),
"data_deleted": [
"conversation_history",
"user_profile",
"activity_logs"
]
}
print(json.dumps(log, indent=2, ensure_ascii=False))
exercise_right_to_erasure("user-123")
Checklist GDPR per gli sviluppatori
- Identifica la base giuridica per ogni operazione di elaborazione (consenso, contratto, ecc.)
- Minimizza i dati inviati alle API (anonimizzazione)
- Mantieni un registro delle attività di elaborazione (Articolo 30)
- Implementa il diritto di accesso e il diritto alla cancellazione
- Documenta i trasferimenti al di fuori dell’UE (OpenAI = server negli USA)
- Abilita Zero Data Retention se possibile
- Non registrare mai dati personali in chiaro
Punti chiave
- Le API di OpenAI NON riaddestrano i loro modelli con i tuoi dati
- Anonimizza i dati personali prima di ogni chiamata API
- Mantieni un registro delle attività di elaborazione conforme all’Articolo 30
- Implementa i diritti GDPR: accesso, rettifica, cancellazione, portabilità
- I trasferimenti di dati al di fuori dell’UE richiedono garanzie (clausole contrattuali standard)
- Documenta ogni decisione riguardante la protezione dei dati