Adatvédelem és GDPR
Ezen az oldalon
Adatvédelem és GDPR
Európai fejlesztőként tisztában kell lenned azzal, hogyan áramlik az adat az OpenAI API-n keresztül, és milyen lépéseket kell tenned a GDPR (Általános Adatvédelmi Rendelet) betartásához. Ez a lecke a megfelelőség technikai aspektusait tárgyalja. Nem helyettesíti az adatvédelmi tisztviselődtől (DPO) kapott tanácsokat, de olyan kódolási gyakorlatokat ad a kezedbe, amelyek lehetővé teszik a számára a munkavégzést – és amelyeket, ha a tervezés során elhanyagolsz, később rendkívül költséges lesz kijavítani.
Hogyan dolgozza fel az adataidat az OpenAI
Az API-n keresztül (nem a ChatGPT-n)
A témával kapcsolatos bármilyen vita kiindulópontja az API-használat és a fogyasztói használat megkülönböztetése. Amikor az OpenAI API-t használod az alkalmazásodhoz, az adatokat nem használják fel modellek tanítására: ez az API irányelve, amely eltér a ChatGPT-étől, és ez az érv, amit a biztonsági bizottságok leggyakoribb kifogásának kezelésére használni fogsz. Az adatokat azonban 30 napig megőrzik a visszaélések észlelésének lehetővé tétele érdekében, majd törlődnek. Lerövidítheted ezt a megőrzési időt: kérheted az azonnali törlést a Zero Data Retention (Nulla Adatmegőrzés) funkció segítségével. Egy pontot még mindig dokumentálnod kell a hatásvizsgálatodban – az adatok az OpenAI szerverein haladnak át, amelyek elsősorban az Egyesült Államokban találhatók, ami az Európai Unión kívüli adatátvitelt jelent.
# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls
Adatminimalizálás
A GDPR megköveteli, hogy csak szigorúan szükséges adatokat dolgozz fel. Alkalmazd ezt az elvet az API-hívásaidra: az esetek túlnyomó többségében a modellnek nincs szüksége arra, hogy ismerje egy személy nevét, e-mail címét vagy telefonszámát ahhoz, hogy összefoglalja a kérését vagy osztályozza a tárgyát.
A visszafordítható álanevesítés pontosan ezt az igényt elégíti ki. Küldés előtt minden személyes adatot egy számozott jelölővel helyettesítesz, és a leképezést a szervereden tartod memóriában. Az API csak a [EMAIL_1] és [TEL_1] értékeket látja. Visszatéréskor a jelölőket visszaállítod a generált szövegbe, és a végfelhasználó egy teljes választ kap anélkül, hogy a koordináták valaha elhagynák a rendszeredet.
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}")
Figyeld meg alaposan ennek a példának a kimenetét: a „Jean Dupont“ név még mindig ott van. A számláló tartalmaz egy bejegyzést a name kulcsra, de egyetlen reguláris kifejezés sem tölti fel azt – egy vezetéknév észlelése neveket felismerő entitásfelismerést (NER) igényel, nem pedig karaktermintákat. Ezért tekints erre a függvényre alapként, amelyre építhetsz, nem pedig teljes körű anonimizálási megoldásként.
GDPR-kompatibilis folyamat
A minimalizálás önmagában nem elég: a rendelet azt is megköveteli, hogy minden adatfeldolgozási művelet azonosított jogalapon nyugodjon, és rögzítve legyen. Ez a folyamat mindkét követelményt egyesíti négy lépésben – rögzítsd a célt és a jogalapot, minimalizálj, hívj, állítsd vissza. A felhasználó azonosítója soha nem kerül tárolásra olvasható formátumban, hanem hashelve van, így a nyilvántartás használható marad a műveletek számlálására anélkül, hogy önmagában személyes adatokat tartalmazó állományt képezne.
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())
A legal_basis paraméter külön figyelmet érdemel: egy lemondási kérelem feldolgozása a szerződés teljesítése alá tartozik, nem pedig a hozzájárulás alá. A helytelen jogalap kiválasztása a leggyakoribb és legsúlyosabb hiba, mivel ez határozza meg azokat a jogokat, amelyeket a felhasználó az adott feldolgozással szemben gyakorolhat.
Hozzájárulás-kezelés
Amikor a választott jogalap a hozzájárulás, azt be kell gyűjteni, dátumozni kell, verziókezelni kell, és mindenekelőtt visszavonhatónak kell lennie. Az alábbi kezelő cél szerinti bontásban tárolja a hozzájárulásokat – az AI-segítség elfogadása nem vonja maga után a szövegelemzés elfogadását –, és minden feldolgozási művelet előtt ellenőrzi ezt az egyezést. A visszavonási módszer egy kritikus megjegyzést tartalmaz: a hozzájárulási rekord törlése nem elég; törölnöd kell az attól függő adatokat is.
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")
A törléshez való jog (17. cikk)
Amikor egy felhasználó kéri adatai törlését, a kötelezettséged túlmutat az alkalmazás adatbázisán. Minden helyiséget át kell vizsgálnod: a helyi adatokat, a személyes információt tartalmazó naplókat – amelyeket gyakran elfelejtenek –, és dokumentálnod kell a műveletet annak igazolására. Az API oldalán a műveletet már lefedi a megőrzési irányelv: a küldött adatok harminc nap után automatikusan eltűnnek, vagy azonnal, ha a Zero Data Retention engedélyezve van.
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")
Fejlesztőknek szóló GDPR ellenőrzőlista
- Azonosítsd minden egyes feldolgozási művelet jogalapját (hozzájárulás, szerződés stb.)
- Minimalizáld az API-nak küldött adatokat (álnevesítés)
- Vezess adatfeldolgozási tevékenységek nyilvántartását (30. cikk)
- Implementáld a hozzáférési jogot és a törléshez való jogot
- Dokumentáld az EU-n kívüli adatátvitelt (OpenAI = US szerverek)
- Engedélyezd a Zero Data Retention funkciót, ha lehetséges
- Soha ne naplózz személyes adatokat olvasható formátumban
Főbb megállapítások
- Az OpenAI API NEM használja fel az adataidat modelljeinek újratanítására
- Álanevesítsd a személyes adatokat minden API-hívás előtt
- Vezess a 30. cikkel összhangban lévő adatfeldolgozási tevékenységek nyilvántartását
- Implementáld a GDPR szerinti jogokat: hozzáférés, helyesbítés, törlés, adathordozhatóság
- Az EU-n kívüli adatátvitel garanciákat igényel (standard szerződési kikötések)
- Dokumentálj minden adatvédelemmel kapcsolatos döntést