Conformité réglementaire : GDPR et SOC2
Minimisation des données, suivi des consentements et contrôle des accès pour des agents conformes.
Conformité réglementaire : GDPR et SOC2 est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.
Pourquoi les réglementations s'appliquent-elles aux agents d'IA ?
Les agents d'IA traitent des données utilisateur, prennent des décisions et effectuent des actions. Ils relèvent donc directement des réglementations sur la protection des données (GDPR) et des référentiels de sécurité (SOC 2).
La conformité n'est pas facultative — les violations peuvent entraîner des amendes allant jusqu'à 4 % du chiffre d'affaires annuel mondial en vertu du GDPR.
GDPR : minimisation des données
Le principe de minimisation des données du GDPR exige de ne recueillir que les données personnelles strictement nécessaires à la finalité déclarée. Un agent ne devrait pas conserver les transcriptions complètes des conversations si seul le résultat (résolu/non résolu) est nécessaire à des fins d'analyse.
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 : suivi du consentement
Avant que l'agent ne traite des données personnelles, vous devez disposer d'une base juridique — généralement le consentement de l'utilisateur. Suivez la date à laquelle le consentement a été donné, ce qu'il couvre et respectez les retraits.
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 : droit à l'effacement (droit à l'oubli)
Lorsqu'un utilisateur demande la suppression de ses données, l'agent doit effacer toutes les données personnelles qui lui sont associées — notamment les journaux de l'agent, l'historique des conversations et les profils mis en cache. Cette opération doit avoir lieu dans les 30 jours suivant la demande.
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é des données
Les utilisateurs ont le droit de recevoir leurs données dans un format lisible par machine (par exemple, JSON ou CSV). Créez une fonction d'exportation qui rassemble toutes les données stockées au sujet d'un utilisateur dans les différents systèmes de l'agent.
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 : contrôle des accès
Le référentiel SOC 2 Type II exige de démontrer que l'accès aux systèmes et aux données est limité aux personnes autorisées. Pour un agent, cela signifie : un accès fondé sur les rôles aux outils de l'agent, MFA pour l'accès administrateur et des examens réguliers des accès.
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 : chiffrement des données au repos et en transit
SOC 2 exige le chiffrement des données au repos (chiffrement de la base de données, disques chiffrés) et en transit (TLS 1.2 ou version ultérieure). Pour les agents, cela signifie : stockage chiffré des conversations, TLS pour tous les appels d’API et aucun secret en clair dans les journaux.
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 : journaux d’audit des événements de sécurité
Les auditeurs de SOC 2 veulent consulter les journaux des événements de sécurité : tentatives de connexion, accès aux données sensibles, modifications de configuration et violations des politiques. Ces journaux doivent être stockés de manière sécurisée et conservés pendant au moins un an.
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'})
Suivi des PII dans les sorties des agents
Les agents ne doivent pas inclure de PII dans les sorties qui sont journalisées ou envoyées à des services tiers (analyse, supervision). Analysez le contenu sortant à la recherche de motifs correspondant à des PII avant sa transmission.
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)Élaboration d’une liste de contrôle de conformité
Avant de déployer un agent qui traite des données personnelles, vérifiez que ces contrôles sont en place.
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}')Automatisation de la conservation des données
GDPR exige que les données soient supprimées lorsqu’elles ne sont plus nécessaires à leur finalité initiale. Automatisez cette opération avec une tâche appliquant une politique de conservation qui purge les anciens enregistrements selon des durées de conservation configurables.
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}')
Quel est le principe de minimisation des données du GDPR ?
La minimisation des données est l’un des principes fondamentaux du GDPR et influence directement la manière dont les systèmes d’agents doivent être conçus dès le départ.
Récapitulatif de la conformité au GDPR et à SOC 2
La conformité au GDPR exige : le suivi du consentement, la minimisation des données, la mise en œuvre du droit à l’effacement, les exportations permettant la portabilité et la suppression des PII dans les journaux.
SOC 2 exige : un contrôle d’accès fondé sur les rôles, le chiffrement des données au repos et en transit, la journalisation des événements de sécurité et des revues des accès. Automatisez les politiques de conservation pour purger les données expirées.
Apprends AI Agents avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 60
- Leçons
- 239
Questions Fréquemment Posées
La leçon « Conformité réglementaire : GDPR et SOC2 » est-elle gratuite ?
Oui — le texte complet de « Conformité réglementaire : GDPR et SOC2 » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Conformité réglementaire : GDPR et SOC2 » ?
Minimisation des données, suivi des consentements et contrôle des accès pour des agents conformes. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Agents ?
Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Conformité réglementaire : GDPR et SOC2 » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?
Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Journalisation immuable des actions des agents
- Application des politiques aux actions des agents
- Conformité réglementaire : GDPR et SOC2
- Portes d’approbation avec intervention humaine