Conformità normativa: GDPR e SOC2
Minimizzazione dei dati, tracciamento del consenso e controllo degli accessi per agenti conformi alle normative.
Conformità normativa: GDPR e SOC2 è una lezione AI Agents gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Agents, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Agents include 4 lezioni in totale.
Perché le normative si applicano agli agenti AI
Gli agenti AI trattano dati degli utenti, prendono decisioni ed eseguono azioni. Rientrano quindi direttamente nell'ambito delle normative sulla protezione dei dati (GDPR) e dei framework di sicurezza (SOC 2).
La conformità non è facoltativa: le violazioni possono comportare sanzioni fino al 4% del fatturato annuo globale ai sensi del GDPR.
GDPR: minimizzazione dei dati
Il principio di minimizzazione dei dati del GDPR richiede di raccogliere esclusivamente i dati personali strettamente necessari per lo scopo dichiarato. Un agente non dovrebbe conservare trascrizioni complete delle conversazioni se per l'analisi è sufficiente solo l'esito (risolto/non risolto).
def minimized_log_entry(conversation: list[dict], user_id: str) -> dict:
'''Store only what is needed — not the full transcript.'''
return {
'user_id': user_id,
'timestamp': conversation[-1].get('timestamp'),
'turns': len(conversation),
'resolved': conversation[-1].get('resolved', False),
'intent': conversation[-1].get('intent'),
'satisfaction': conversation[-1].get('csat_score'),
# NOT stored: full message text, PII mentioned in conversation
}
# WRONG — stores raw messages which may contain PII
# {'messages': conversation, 'user_id': user_id}
if __name__ == '__main__':
conversation = [
{'timestamp': 1717000000, 'resolved': True, 'intent': 'reset_password', 'csat_score': 5}
]
print('Minimized log entry:', minimized_log_entry(conversation, user_id='u42'))
GDPR: registrazione del consenso
Prima che l'agente tratti dati personali, è necessario disporre di una base giuridica, solitamente il consenso dell'utente. Registrare quando è stato prestato il consenso, che cosa comprende e rispettare le revoche.
from datetime import datetime, timezone
consent_store: dict[str, dict] = {} # user_id -> consent record
def record_consent(user_id: str, purpose: str, version: str = '1.0'):
if user_id not in consent_store:
consent_store[user_id] = {'purposes': {}}
consent_store[user_id]['purposes'][purpose] = {
'granted': True,
'timestamp': datetime.now(timezone.utc).isoformat(),
'version': version
}
def withdraw_consent(user_id: str, purpose: str):
if user_id in consent_store:
consent_store[user_id]['purposes'].pop(purpose, None)
def has_consent(user_id: str, purpose: str) -> bool:
return bool(
consent_store.get(user_id, {}).get('purposes', {}).get(purpose, {}).get('granted')
)
if __name__ == '__main__':
record_consent('u42', 'marketing_emails')
print('Has consent:', has_consent('u42', 'marketing_emails'))
withdraw_consent('u42', 'marketing_emails')
print('Has consent after withdrawal:', has_consent('u42', 'marketing_emails'))
GDPR: diritto alla cancellazione (diritto all'oblio)
Quando un utente richiede la cancellazione, l'agente deve eliminare tutti i dati personali che lo riguardano, inclusi i log dell'agente, la cronologia delle conversazioni e i profili memorizzati nella cache. Questa operazione deve avvenire entro 30 giorni dalla richiesta.
import os
def erase_user_data(user_id: str, conn) -> dict:
'''Delete all personal data for a user across all storage systems.'''
deleted = {}
# 1. Delete from audit log (if not using WORM storage)
with conn.cursor() as cur:
cur.execute('DELETE FROM agent_audit_log WHERE user_id = %s', (user_id,))
deleted['audit_log_rows'] = cur.rowcount
# 2. Delete conversation history
with conn.cursor() as cur:
cur.execute('DELETE FROM conversation_history WHERE user_id = %s', (user_id,))
deleted['conversations'] = cur.rowcount
# 3. Remove consent record
consent_store.pop(user_id, None)
deleted['consent_record'] = 1
# 4. Clear cached profile
profile_cache = {} # reference to your cache
profile_cache.pop(user_id, None)
deleted['profile_cache'] = 1
conn.commit()
return {'user_id': user_id, 'erased': deleted}GDPR: portabilità dei dati
Gli utenti hanno il diritto di ricevere i propri dati in un formato leggibile meccanicamente, ad esempio JSON o CSV. Creare una funzione di esportazione che raccolga tutti i dati memorizzati sull'utente nei vari sistemi dell'agente.
import json
def export_user_data(user_id: str, conn) -> str:
export = {'user_id': user_id, 'data': {}}
with conn.cursor() as cur:
cur.execute(
'SELECT timestamp, action_type, result FROM agent_audit_log '
'WHERE user_id = %s ORDER BY timestamp',
(user_id,)
)
rows = cur.fetchall()
export['data']['audit_log'] = [
{'timestamp': r[0], 'action': r[1], 'result': r[2]}
for r in rows
]
export['data']['consent'] = consent_store.get(user_id, {})
return json.dumps(export, indent=2)SOC 2: controllo degli accessi
SOC 2 Type II richiede di dimostrare che l'accesso ai sistemi e ai dati sia limitato alle persone autorizzate. Per un agente, ciò significa: controllo degli accessi basato sui ruoli agli strumenti dell'agente, MFA per l'accesso amministrativo e verifiche periodiche degli accessi.
ROLE_PERMISSIONS = {
'agent_basic': {'web_search', 'read_file', 'query_database'},
'agent_email': {'web_search', 'read_file', 'query_database', 'send_email'},
'agent_admin': {'web_search', 'read_file', 'write_file', 'query_database',
'send_email', 'create_ticket', 'execute_python_sandbox'},
'human_admin': {'*'} # all permissions
}
def get_permitted_actions(role: str) -> set:
perms = ROLE_PERMISSIONS.get(role, set())
if '*' in perms:
return ALLOWED_ACTIONS # reference to full allowlist
return perms
def check_role_permission(role: str, action: str) -> bool:
return action in get_permitted_actions(role)SOC 2: Crittografia dei dati a riposo e in transito
SOC 2 richiede la crittografia dei dati sensibili a riposo (crittografia del database, dischi crittografati) e in transito (TLS 1.2 o versioni successive). Per gli agenti, ciò significa: archiviazione crittografata delle conversazioni, TLS per tutte le chiamate API e nessun segreto in chiaro nei log.
from cryptography.fernet import Fernet
import os
# Key stored in environment variable, never in code
ENCRYPTION_KEY = os.environ.get('LOG_ENCRYPTION_KEY', Fernet.generate_key())
cipher = Fernet(ENCRYPTION_KEY)
def encrypt_sensitive_field(value: str) -> str:
return cipher.encrypt(value.encode()).decode()
def decrypt_sensitive_field(encrypted: str) -> str:
return cipher.decrypt(encrypted.encode()).decode()
# Usage: encrypt PII before storing in audit log
encrypted_email = encrypt_sensitive_field('user@example.com')
print(encrypted_email[:30], '...') # starts with gAAAA...SOC 2: Log di audit per gli eventi di sicurezza
Gli auditor SOC 2 vogliono visualizzare i log degli eventi di sicurezza: tentativi di accesso, accessi ai dati sensibili, modifiche alla configurazione e violazioni delle policy. Questi log devono essere archiviati in modo sicuro e conservati per almeno 1 anno.
import logging, json, time
security_logger = logging.getLogger('agent.security')
SECURITY_EVENTS = {
'auth_success', 'auth_failure', 'policy_violation',
'data_access_pii', 'admin_action', 'config_change'
}
def log_security_event(event_type: str, agent_id: str,
user_id: str, details: dict):
assert event_type in SECURITY_EVENTS, f'Unknown security event: {event_type}'
entry = {
'timestamp': time.time(),
'event_type': event_type,
'agent_id': agent_id,
'user_id': user_id,
'details': details
}
security_logger.warning(json.dumps(entry))
if __name__ == '__main__':
import sys
security_logger.addHandler(logging.StreamHandler(sys.stdout))
log_security_event('auth_failure', 'agent-1', 'user-42', {'reason': 'bad_token'})
Monitoraggio dei dati personali negli output degli agenti
Gli agenti non dovrebbero includere dati personali negli output che vengono registrati o inviati a servizi di terze parti (analisi, monitoraggio). Prima della trasmissione, esegua una scansione dei contenuti in uscita alla ricerca di pattern di dati personali.
import re
PII_PATTERNS = [
(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', 'email'),
(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', 'phone'),
(r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b', 'credit_card'),
(r'\b\d{3}-\d{2}-\d{4}\b', 'ssn')
]
def redact_pii(text: str) -> tuple[str, list[str]]:
redacted = text
found_types = []
for pattern, pii_type in PII_PATTERNS:
if re.search(pattern, redacted):
found_types.append(pii_type)
redacted = re.sub(pattern, f'[{pii_type.upper()}_REDACTED]', redacted)
return redacted, found_types
text, types = redact_pii('Contact john@example.com or call 555-867-5309')
print(text)
print('PII found:', types)Creazione di una checklist di conformità
Prima di distribuire un agente che gestisce dati personali, verifichi che questi controlli siano in essere.
COMPLIANCE_CHECKLIST = [
('GDPR', 'Consent captured before processing personal data'),
('GDPR', 'Data minimization: only necessary data is collected'),
('GDPR', 'Right-to-erasure endpoint implemented and tested'),
('GDPR', 'Data portability export available'),
('GDPR', 'Data retention policy enforced (auto-delete after N days)'),
('SOC2', 'Role-based access control implemented for all agent tools'),
('SOC2', 'All data encrypted at rest and in transit (TLS 1.2+)'),
('SOC2', 'Security events logged and retained for 12+ months'),
('SOC2', 'Access reviews scheduled quarterly'),
('SOC2', 'Incident response plan documented'),
('BOTH', 'PII redaction applied to logs and analytics exports'),
('BOTH', 'Vendor DPAs signed for all third-party APIs used'),
]
for framework, control in COMPLIANCE_CHECKLIST:
print(f'[ ] [{framework}] {control}')Automazione della conservazione dei dati
Il GDPR richiede che i dati vengano eliminati quando non sono più necessari per la finalità originaria. Automatizzi questo processo con un job per le policy di conservazione che elimini i record meno recenti in base a periodi di conservazione configurabili.
from datetime import datetime, timedelta, timezone
RETENTION_POLICIES = {
'conversation_history': 90, # days
'agent_audit_log': 365,
'cached_profiles': 1,
'session_data': 30
}
def purge_expired_data(conn):
purged = {}
for table, retention_days in RETENTION_POLICIES.items():
cutoff = datetime.now(timezone.utc) - timedelta(days=retention_days)
try:
with conn.cursor() as cur:
cur.execute(
f'DELETE FROM {table} WHERE timestamp < %s',
(cutoff.timestamp(),)
)
purged[table] = cur.rowcount
except Exception as e:
purged[table] = f'Error: {e}'
conn.commit()
return purged
if __name__ == '__main__':
class FakeCursor:
def __enter__(self):
return self
def __exit__(self, *exc):
return False
def execute(self, sql, params):
self.rowcount = 3
class FakeConn:
def cursor(self):
return FakeCursor()
def commit(self):
pass
result = purge_expired_data(FakeConn())
print('Rows purged per table:')
for table, count in result.items():
print(f' {table}: {count}')
Che cos'è il principio di minimizzazione dei dati del GDPR?
La minimizzazione dei dati è uno dei principi fondamentali del GDPR e influisce direttamente sul modo in cui i sistemi basati su agenti devono essere progettati fin dall'inizio.
Riepilogo della conformità a GDPR e SOC 2
La conformità al GDPR richiede: monitoraggio del consenso, minimizzazione dei dati, implementazione del diritto alla cancellazione, esportazioni per la portabilità e oscuramento dei dati personali nei log.
SOC 2 richiede: controllo degli accessi basato sui ruoli, crittografia dei dati a riposo e in transito, registrazione degli eventi di sicurezza e revisioni degli accessi. Automatizzi le policy di conservazione per eliminare i dati scaduti.
Domande Frequenti
La lezione «Conformità normativa: GDPR e SOC2» è gratuita?
Sì — il testo completo di «Conformità normativa: GDPR e SOC2» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Agents, passa a CoddyKit PRO. Il corso AI Agents include 4 lezioni in totale.
Cosa imparerò in «Conformità normativa: GDPR e SOC2»?
Minimizzazione dei dati, tracciamento del consenso e controllo degli accessi per agenti conformi alle normative. Eserciti AI Agents con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Agents?
Non è richiesta alcuna esperienza precedente. AI Agents su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Conformità normativa: GDPR e SOC2»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Agents?
Sì. Ogni lezione AI Agents include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Registrazione immutabile delle azioni degli agenti
- Applicazione delle policy alle azioni degli agenti
- Conformità normativa: GDPR e SOC2
- Gate di approvazione con supervisione umana