Ochrana osobních údajů a GDPR
Na této stránce
Ochrana osobních údajů a GDPR
Jako evropský vývojář musíš přesně vědět, jak data proudí skrze API OpenAI a jaké kroky podniknout, abys dodržel nařízení GDPR (Obecné nařízení o ochraně osobních údajů). Tato lekce pokrývá technické aspekty souladu s předpisy. Nenahrazuje rady tvého pověřence pro ochranu osobních údajů (DPO), ale poskytuje ti kodex postupů, které mu umožní vykonávat jeho práci – a které, pokud je zanedbáš již ve fázi návrhu, budou později extrémně nákladné na opravu.
Jak OpenAI zpracovává tvá data
Prostřednictvím API (nikoliv ChatGPT)
Rozlišení mezi využíváním API a používáním spotřebitelské aplikace je výchozím bodem jakékoli diskuse na toto téma. Když použiješ API OpenAI pro svou aplikaci, data nejsou použita k trénování modelů: toto je politika API, která se liší od politiky ChatGPT, a je to argument, který použiješ k vyvrácení nejčastější námitky ve výborech pro bezpečnost. Data jsou však uchovávána po dobu 30 dnů za účelem detekce zneužití a následně smazána. Tuto dobu uchování můžeš zkrátit: můžeš požádat o předčasné smazání prostřednictvím funkce Zero Data Retention (nulové uchovávání dat). Jedna věc zůstává k zdokumentování v posouzení dopadů – data procházejí servery OpenAI, které se nacházejí primárně ve Spojených státech, což představuje přenos mimo Evropskou unii.
# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls
Minimalizace dat
GDPR vyžaduje zpracování pouze striktně nezbytných dat. Aplikuj tento princip na svá volání API: ve velké většině případů model nepotřebuje znát jméno osoby, e-mailovou adresu nebo telefonní číslo, aby shrnul její požadavek nebo klasifikoval jeho předmět.
Reverzibilní pseudonymizace přesně odpovídá této potřebě. Před odesláním je každý údaj osobní povahy nahrazen číslovaným markerem a mapování je uchováno v paměti na tvém serveru. API vidí pouze [EMAIL_1] a [TEL_1]. Po návratu jsou markery v generovaném textu obnoveny a koncový uživatel obdrží úplnou odpověď, aniž by jeho údaje kdy opustily tvůj systém.
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}")
Podívej se pozorně na výstup tohoto příkladu: „Jean Dupont“ je stále přítomen. Počítadlo obsahuje položku pro name, ale žádný regulární výraz ji nevyplňuje – detekce příjmení vyžaduje rozpoznávání pojmenovaných entit (NER), nikoliv vzor znaků. Tuto funkci tedy považuj za základ, na kterém můžeš stavět, nikoliv za kompletní řešení anonymizace.
Pipeline v souladu s GDPR
Samotná minimalizace nestačí: nařízení také vyžaduje, aby každá operace zpracování spočívala na identifikovaném právním základě a byla zaznamenána. Tato pipeline kombinuje oba požadavky ve čtyřech krocích – zaznamenej účel a právní základ, minimalizuj, zavolej API, obnov data. Identifikátor uživatele není nikdy uložen v plain textu, ale hashován, takže registr zůstává použitelný pro počítání operací, aniž by sám o sobě představoval soubor osobních údajů.
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())
Parametr legal_basis si zaslouží pozornost: zpracování žádosti o zrušení spadá pod plnění smlouvy, nikoliv pod souhlas. Výběr špatného právního základu je nejčastější a nejdůslednější chybou, protože určuje práva, která může uživatel vůči danému zpracování uplatnit.
Správa souhlasu
Pokud je zvoleným právním základem souhlas, musí být získán, datován, verzován a především odvolatelný. Níže uvedený správce ukládá souhlasy podle účelu – přijetí pomoci od AI neznamená přijetí analýzy textu – a před každou operací zpracování ověřuje tuto shodu. Metoda pro odvolání nese kritický komentář: smazání záznamu o souhlasu nestačí; musíš také smazat data, která na něm závisela.
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")
Právo na výmaz (článek 17)
Když uživatel požádá o výmaz svých údajů, tvá povinnost sahá beyond databázi aplikace. Musíš projít všechna místa: lokální data, logy obsahující osobní údaje – na které se často zapomíná – a operaci zdokumentovat, abys ji mohl obhájit. Na straně API je akce již pokryta zásadami uchovávání dat: odeslaná data automaticky zmizí po třiceti dnech, nebo okamžitě, pokud je povoleno Zero Data Retention.
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")
Kontrolní seznam GDPR pro vývojáře
- Identifikuj právní základ pro každou operaci zpracování (souhlas, smlouva atd.)
- Minimalizuj data odesílaná do API (anonymizace)
- Veď záznam o činnostech zpracování (článek 30)
- Implementuj právo na přístup a právo na výmaz
- Zdokumentuj přenosy mimo EU (OpenAI = servery v USA)
- Povol Zero Data Retention, pokud je to možné
- Nikdy neloguj osobní údaje v plain textu
Klíčové poznatky
- API OpenAI nepoužívá tvá data k přeškolování svých modelů
- Anonymizuj osobní údaje před každým voláním API
- Veď záznam o činnostech zpracování v souladu s článkem 30
- Implementuj práva dle GDPR: přístup, oprava, výmaz, přenositelnost
- Přenosy dat mimo EU vyžadují záruky (standardní smluvní doložky)
- Zdokumentuj každé rozhodnutí týkající se ochrany údajů