Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Adatvédelem és GDPR

21. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Adatvédelem és GDPR
  2. Hogyan dolgozza fel az adataidat az OpenAI
  3. Adatminimalizálás
  4. GDPR-kompatibilis folyamat
  5. Hozzájárulás-kezelés
  6. A törléshez való jog (17. cikk)
  7. Fejlesztőknek szóló GDPR ellenőrzőlista
  8. Főbb megállapítások

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