Konfidencialitāte un GDPR
Šajā lapā
Konfidencialitāte un GDPR
Kā Eiropas izstrādātājam tev ir jāsaprot, kā dati plūst caur OpenAI API, un kādi soļi jāveic, lai ievērotu GDPR (Vispārīgo datu aizsardzības regulu). Šī nodarbība aptver tehniskos atbilstības aspektus. Tā neaizstāj tava datu aizsardzības speciālista (DPO) sniegtos padomus, taču tā nodrošina kodēšanas praksi, kas ļaus viņam veikt savu darbu – un kuras neievērošana projektēšanas posmā vēlāk izmaksās ārkārtīgi dārgi.
Kā OpenAI apstrādā tavus datus
Izmantojot API (nevis ChatGPT)
Atšķirība starp API izmantošanu un patērētāju lietojumu ir sākumpunkts jebkurai diskusijai par šo tēmu. Kad izmanto OpenAI API savai lietotnei, dati netiek izmantoti modeļu apmācībai: tāda ir API politika, kas atšķiras no ChatGPT politikas, un tas ir arguments, ko izmantosi, lai atbildētu uz visbiežāk sastopamo iebildumu drošības komitejās. Tomēr dati tiek glabāti 30 dienas, lai nodrošinātu ļaunprātīgas izmantošanas noteikšanu, un pēc tam dzēsti. Tu vari saīsināt šo glabāšanas periodu: vari pieprasīt agrīnu dzēšanu, izmantojot funkciju „Zero Data Retention”. Vēl viens punkts, kas jādokumentē ietekmes novērtējumā – dati tiek pārsūtīti caur OpenAI serveriem, kas galvenokārt atrodas Amerikas Savienotajās Valstīs, kas nozīmē datu pārsūtīšanu ārpus Eiropas Savienības.
# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls
Datu minimizēšana
GDPR pieprasa apstrādāt tikai stingri nepieciešamos datus. Piemēro šo principu saviem API izsaukumiem: lielākajā daļā gadījumu modelim nav vajadzības zināt personas vārdu, e-pasta adresi vai tālruņa numuru, lai apkopotu tās pieprasījumu vai klasificētu tā tēmu.
Apgriežama pseidonimizācija precīzi atbilst šai vajadzībai. Pirms nosūtīšanas katrs personas datu elements tiek aizstāts ar numurētu marķieri, un kartēšana tiek glabāta atmiņā tavā serverī. API redz tikai [EMAIL_1] un [TEL_1]. Pēc atgriešanās marķieri tiek atjaunoti ģenerētajā tekstā, un gala lietotājs saņem pilnīgu atbildi, nekad neatstājot koordinātas ārpus tavas sistēmas.
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}")
Pievērs uzmanību šī piemēra izvadei: „Jean Dupont” joprojām ir klāt. Skaitītājā ir ieraksts priekš name, taču neviena regulārā izteiksme to neaizpilda – uzvārda noteikšanai ir nepieciešama nosaukto entīšu atpazīšana, nevis rakstzīmju šablons. Tāpēc uzskati šo funkciju par pamatu, uz kura būvēt tālāk, nevis par pilnīgu anonimizācijas risinājumu.
GDPR atbilstoša darbplūsma
Minimizēšana vien nav pietiekama: regula arī pieprasa, lai katra apstrādes darbība balstītos uz identificētu juridisko pamatu un tiktu reģistrēta. Šī darbplūsma apvieno abas prasības četros soļos – reģistrē mērķi un juridisko pamatu, minimizē, izsauc, atjauno. Lietotāja identifikators nekad netiek glabāts skaidrā tekstā, bet gan hashēts, tāpēc reģistrs paliek lietojams darbību skaitīšanai, pats par sevi neveidojot personas datu failu.
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())
Parametrs legal_basis ir pelnījis uzmanību: atteikuma pieprasījuma apstrāde ietilpst līguma izpildē, nevis piekrišanā. Nepareiza juridiskā pamata izvēle ir visbiežāk sastopamā un nozīmīgākā kļūda, jo tā nosaka tiesības, ko lietotājs var īstenot attiecībā uz šo apstrādi.
Piekrišanas pārvaldība
Kad izvēlētais juridiskais pamats ir piekrišana, tā ir jāsavāc, jādatē, jāversijē un, pats galvenais, jābūt atsakāmai. Zemāk esošais pārvaldnieks glabā piekrišanu pa mērķiem – AI palīdzības pieņemšana nenozīmē teksta analīzes pieņemšanu – un pārbauda šo atbilstību pirms katras apstrādes darbības. Atsaukšanas metodei ir kritisks komentārs: nepietiek tikai dzēst piekrišanas ierakstu; tev ir jādzēš arī dati, kas bija atkarīgi no tās.
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")
Tiesības uz dzēšanu (17. pants)
Kad lietotājs pieprasa savu datu dzēšanu, tavs pienākums attiecas ne tikai uz lietotnes datubāzi. Tev ir jāpārlauka visas vietas: lokālie dati, žurnāli, kas satur personas informāciju – bieži vien aizmirsti – un jādokumentē darbība, lai to attaisnotu. API pusē darbība jau ir segta ar glabāšanas politiku: nosūtītie dati pazūd automātiski pēc trīsdesmit dienām vai uzreiz, ja ir iespējota „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")
GDPR kontrolsaraksts izstrādātājiem
- Identificē juridisko pamatu katrai apstrādes darbībai (piekrišana, līgums u.c.)
- Minimizē datus, kas tiek nosūtīti uz API (anonimizācija)
- Uzturi apstrādes darbību reģistru (30. pants)
- Ievies tiesības uz piekļuvi un tiesības uz dzēšanu
- Dokumentē pārsūtīšanu ārpus ES (OpenAI = ASV serveri)
- Iespējo Zero Data Retention, ja tas ir iespējams
- Nekad nežurnalē personas datus skaidrā tekstā
Galvenās atziņas
- OpenAI API NEAPMĀCA savus modeļus ar taviem datiem
- Anonimizē personas datus pirms katra API izsaukuma
- Uzturi apstrādes darbību reģistru, kas atbilst 30. pantam
- Ievies GDPR tiesības: piekļuve, labošana, dzēšana, pārnesamība
- Datu pārsūtīšana ārpus ES prasa aizsardzības pasākumus (standarta līguma noteikumi)
- Dokumentē katru lēmumu attiecībā uz datu aizsardzību