Salt la conținutul principal
Română— Alege o limbă
Meniu

Confidențialitatea datelor și GDPR

Lecția 21 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Confidențialitatea datelor și GDPR
  2. Cum procesează OpenAI datele dumneavoastră
  3. Minimizarea datelor
  4. Flux de lucru conform RGPD
  5. Gestionarea consimțământului
  6. Dreptul la ștergere (Articolul 17)
  7. Listă de verificare RGPD pentru dezvoltatori
  8. Puncte cheie

Confidențialitatea datelor și GDPR

În calitate de dezvoltator european, trebuie să înțelegeți cum circulă datele prin intermediul API-ului OpenAI și ce măsuri trebuie să luați pentru a respecta RGPD (Regulamentul General privind Protecția Datelor). Această lecție acoperă aspectele tehnice ale conformității. Ea nu înlocuiește sfaturile Responsabilului dumneavoastră cu Protecția Datelor (DPO), dar vă oferă practicile de codare care le vor permite acestora să își facă treaba – și care, dacă sunt neglijate în faza de proiectare, devin extrem de costisitor de remediat ulterior.

Cum procesează OpenAI datele dumneavoastră

Prin API (nu ChatGPT)

Distingerea utilizării API-ului de utilizarea consumer este punctul de plecare pentru orice discuție pe această temă. Când utilizați API-ul OpenAI pentru aplicația dumneavoastră, datele nu sunt folosite pentru antrenarea modelelor: aceasta este politica API-ului, care diferă de cea a ChatGPT, și este argumentul pe care îl veți folosi pentru a răspunde la cea mai frecventă obiecție din comitetele de securitate. Cu toate acestea, datele sunt păstrate timp de 30 de zile pentru a permite detectarea abuzurilor, apoi sunt șterse. Puteți scurta această perioadă de retenție: puteți solicita ștergerea anticipată prin funcționalitatea Zero Data Retention. Un aspect rămâne de documentat în evaluarea impactului – datele tranzitează serverele OpenAI, situate în principal în Statele Unite, ceea ce constituie un transfer în afara Uniunii Europene.

# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls

Minimizarea datelor

RGPD impune prelucrarea doar a datelor strict necesare. Aplicați acest principiu apelurilor dumneavoastră către API: în marea majoritate a cazurilor, modelul nu are nevoie să cunoască numele unei persoane, adresa de e-mail sau numărul de telefon pentru a rezuma cererea acesteia sau pentru a-i clasifica subiectul.

Pseudonimizarea reversibilă răspunde exact acestei nevoi. Înainte de trimitere, fiecare element de date cu caracter personal este înlocuit cu un marker numerotat, iar corespondența este păstrată în memoria serverului dumneavoastră. API-ul vede doar [EMAIL_1] și [TEL_1]. La returnare, markerii sunt restabiliți în textul generat, iar utilizatorul final primește un răspuns complet fără ca datele de identificare să părăsească vreodată sistemul dumneavoastră.

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}")

Analizați cu atenție rezultatul acestui exemplu: „Jean Dupont“ este încă acolo. Contorul include o intrare pentru name, dar nicio expresie regulată nu o completează – detectarea unui nume de familie necesită recunoașterea entităților numite, nu un model de caractere. Prin urmare, considerați această funcție o fundație pe care să construiți, nu o soluție completă de anonimizare.

Flux de lucru conform RGPD

Minimizarea singură nu este suficientă: reglementarea cere, de asemenea, ca fiecare operațiune de prelucrare să se bazeze pe un temei juridic identificat și să fie înregistrată. Acest flux combină ambele cerințe în patru pași – înregistrați scopul și temeiul juridic, minimizați, apelați, restaurați. Identificatorul utilizatorului nu este stocat niciodată în text clar, ci este hashat, astfel încât registrul rămâne utilizabil pentru numărarea operațiunilor fără a constitui el însuși un fișier de date cu caracter personal.

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())

Parametrul legal_basis merită atenție: prelucrarea unei cereri de reziliere intră sub incidența executării contractului, nu a consimțământului. Alegerea unui temei juridic greșit este cea mai frecventă și mai gravă eroare, deoarece determină drepturile pe care un utilizator le poate exercita asupra acelei prelucrări.

Gestionarea consimțământului

Atunci când temeiul juridic ales este consimțământul, acesta trebuie colectat, datat, versionat și, mai presus de toate, trebuie să fie revocabil. Managerul de mai jos stochează consimțământul pe scopuri – acceptarea asistenței AI nu implică acceptarea analizei textului – și verifică această corespondență înainte de fiecare operațiune de prelucrare. Metoda de retragere conține un comentariu critic: ștergerea înregistrării consimțământului nu este suficientă; trebuie, de asemenea, să ștergeți datele care au depins de acesta.

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")

Dreptul la ștergere (Articolul 17)

Când un utilizator solicită ștergerea datelor sale, obligația dumneavoastră se extinde dincolo de baza de date a aplicației. Trebuie să verificați toate locațiile: datele locale, jurnalele care conțin informații personale – adesea uitate – și să documentați operațiunea pentru a o justifica. Din partea API-ului, acțiunea este deja acoperită de politica de retenție: datele trimise dispar automat după treizeci de zile sau imediat dacă este activată opțiunea 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")

Listă de verificare RGPD pentru dezvoltatori

  • Identificați temeiul juridic pentru fiecare operațiune de prelucrare (consimțământ, contract etc.)
  • Minimizați datele trimise către API (anonimizare)
  • Mențineți un registru al activităților de prelucrare (Articolul 30)
  • Implementați dreptul de acces și dreptul la ștergere
  • Documentați transferurile în afara UE (OpenAI = servere în SUA)
  • Activați Zero Data Retention dacă este posibil
  • Nu înregistrați niciodată date cu caracter personal în text clar

Puncte cheie

  • API-ul OpenAI NU își reantrenează modelele cu datele dumneavoastră
  • Anonimizați datele cu caracter personal înainte de fiecare apel către API
  • Mențineți un registru al activităților de prelucrare conform Articolului 30
  • Implementați drepturile RGPD: acces, rectificare, ștergere, portabilitate
  • Transferurile de date în afara UE necesită garanții (clauze contractuale standard)
  • Documentați fiecare decizie privind protecția datelor