Andmete privaatsus ja GDPR
Sellel lehel
Andmete privaatsus ja GDPR
Euroopa arendajana pead mõistma, kuidas andmed OpenAI API kaudu liiguvad ja milliseid samme astuda, et tagada vastavus GDPR-ile (üldine andmekaitsemäärus). See tund käsitleb vastavuse tehnilisi aspekte. See ei asenda sinu andmekaitsevoliniku (DPO) nõuandeid, kuid annab sulle kodeerimistavad, mis teevad tema töö võimalikuks – ja mida, kui need disainietapis tähelepanuta jätta, on hiljem äärmiselt kallis parandada.
Kuidas OpenAI sinu andmeid töötleb
API kaudu (mitte ChatGPT)
API kasutamise eristamine tarbijakasutusest on selle teema arutelude lähtepunkt. Kui kasutad oma rakenduses OpenAI API-d, siis andmeid ei kasutata mudelite treenimiseks: see on API poliitika, mis erineb ChatGPT omast, ja see on argument, mida kasutad turvakomiteede kõige levinuma vastuväite lahendamiseks. Siiski säilitatakse andmeid 30 päeva, et võimaldada kuritarvituste tuvastamist, seejärel need kustutatakse. Saad seda säilitusperioodi lühendada: saad taotleda varajast kustutamist funktsiooni Zero Data Retention kaudu. Üks punkt tuleb mõjuhindamises siiski dokumenteerida – andmed liiguvad läbi OpenAI serverite, mis asuvad peamiselt Ameerika Ühendriikides, mis kujutab endast ülekannet väljaspool Euroopa Liitu.
# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls
Andmete minimeerimine
GDPR nõuab ainult rangelt vajalike andmete töötlemist. Rakenda seda põhimõtet oma API päringutes: valdaval enamikul juhtudel ei vaja mudel inimese nime, e-posti aadressi ega telefoninumbrit, et tema päringut kokku võtta või selle teemat klassifitseerida.
Pööratav pseudonümiseerimine vastab sellele vajadusele täpselt. Enne saatmist asendatakse iga isikuandmete tükk nummerdatud markeriga ja vastendus hoitakse mälus sinu serveris. API näeb ainult [EMAIL_1] ja [TEL_1]. Tagastamisel taastatakse markerid genereeritud tekstis ja lõppkasutaja saab täieliku vastuse, ilma et kontaktandmed kunagi sinu süsteemist lahkuksid.
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}")
Vaata tähelepanelikult selle näite väljundit: „Jean Dupont“ on endiselt alles. Loendur sisaldab kirjet name, kuid ükski regulaaravaldis seda ei täida – perekonnanime tuvastamine nõuab nimede tuvastamist (NER), mitte märgimustrit. Seega pea seda funktsiooni pigem aluseks, millele edasi ehitada, mitte täielikuks anonüümimislahenduseks.
GDPR-ile vastav torustik
Minimeerimisest üksi ei piisa: määrus nõuab ka, et iga töötlemistoiming põhineks tuvastatud õiguslikul alusel ja oleks registreeritud. See torustik ühendab mõlemad nõuded neljas sammus – registreeri eesmärk ja õiguslik alus, minimeeri, kutsu API-d, taasta. Kasutaja identifikaatorit ei salvestata kunagi selgesõnaliselt, vaid räsitakse, nii et register jääb kasutatavaks toimingute lugemiseks, olemata ise isikuandmete fail.
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())
Parameeter legal_basis väärib tähelepanu: tühistamistaotluse töötlemine kuulub lepingu täitmise, mitte nõusoleku alla. Vale õigusliku aluse valimine on kõige sagedasem ja tagajärjerikkaim viga, kuna see määrab õigused, mida kasutaja saab selle töötlemise osas teostada.
Nõusoleku haldamine
Kui valitud õiguslik alus on nõusolek, tuleb see koguda, dateerida, versioonida ja ennekõike peab see olema tagasivõetav. Allpool olev haldur salvestab nõusoleku eesmärgipõhiselt – tehisintellekti abi aktsepteerimine ei tähenda tekstianalüüsi aktsepteerimist – ja kontrollib seda vastavust enne iga töötlemistoimingut. Tagasivõtmismeetodil on kriitiline kommentaar: nõusoleku kirje kustutamisest ei piisa; pead kustutama ka andmed, mis sellest sõltusid.
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")
Kustutamisõigus (artikkel 17)
Kui kasutaja taotleb oma andmete kustutamist, ulatub sinu kohustus kaugemale rakenduse andmebaasist. Pead läbi puhastama kõik asukohad: kohalikud andmed, logid, mis sisaldavad isikuandmeid – mida sageli unustatakse – ja dokumenteerima toimingu selle põhjendamiseks. API poolel on tegevus juba hõlmatud säilituspoliitikaga: saadetud andmed kaovad automaatselt kolmekümne päeva pärast või kohe, kui Zero Data Retention on lubatud.
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")
GDPR-i kontrollnimekiri arendajatele
- Tuvasta iga töötlemistoimingu õiguslik alus (nõusolek, leping jne)
- Minimeeri API-le saadetavaid andmeid (anonüümimine)
- Pea töötlemistoimingute registrit (artikkel 30)
- Rakenda juurdepääsuõigus ja kustutamisõigus
- Dokumenteeri ülekanded väljaspool EL-i (OpenAI = USA serverid)
- Luba Zero Data Retention, kui võimalik
- Ära kunagi logi isikuandmeid selgesõnaliselt
Peamised punktid
- OpenAI API EI treeni oma mudeleid sinu andmetega
- Anonüümista isikuandmed enne iga API väljakutset
- Pea artiklile 30 vastavat töötlemistoimingute registrit
- Rakenda GDPR-i õigusi: juurdepääs, parandamine, kustutamine, ülekantavus
- Andmeülekanded väljaspool EL-i nõuavad kaitsemeetmeid (tüüplepingutingimused)
- Dokumenteeri iga andmekaitsega seotud otsus