Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Ochrana osobních údajů a GDPR

Lekce 21 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Ochrana osobních údajů a GDPR
  2. Jak OpenAI zpracovává tvá data
  3. Minimalizace dat
  4. Pipeline v souladu s GDPR
  5. Správa souhlasu
  6. Právo na výmaz (článek 17)
  7. Kontrolní seznam GDPR pro vývojáře
  8. Klíčové poznatky

Ochrana osobních údajů a GDPR

Jako evropský vývojář musíš přesně vědět, jak data proudí skrze API OpenAI a jaké kroky podniknout, abys dodržel nařízení GDPR (Obecné nařízení o ochraně osobních údajů). Tato lekce pokrývá technické aspekty souladu s předpisy. Nenahrazuje rady tvého pověřence pro ochranu osobních údajů (DPO), ale poskytuje ti kodex postupů, které mu umožní vykonávat jeho práci – a které, pokud je zanedbáš již ve fázi návrhu, budou později extrémně nákladné na opravu.

Jak OpenAI zpracovává tvá data

Prostřednictvím API (nikoliv ChatGPT)

Rozlišení mezi využíváním API a používáním spotřebitelské aplikace je výchozím bodem jakékoli diskuse na toto téma. Když použiješ API OpenAI pro svou aplikaci, data nejsou použita k trénování modelů: toto je politika API, která se liší od politiky ChatGPT, a je to argument, který použiješ k vyvrácení nejčastější námitky ve výborech pro bezpečnost. Data jsou však uchovávána po dobu 30 dnů za účelem detekce zneužití a následně smazána. Tuto dobu uchování můžeš zkrátit: můžeš požádat o předčasné smazání prostřednictvím funkce Zero Data Retention (nulové uchovávání dat). Jedna věc zůstává k zdokumentování v posouzení dopadů – data procházejí servery OpenAI, které se nacházejí primárně ve Spojených státech, což představuje přenos mimo Evropskou unii.

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

Minimalizace dat

GDPR vyžaduje zpracování pouze striktně nezbytných dat. Aplikuj tento princip na svá volání API: ve velké většině případů model nepotřebuje znát jméno osoby, e-mailovou adresu nebo telefonní číslo, aby shrnul její požadavek nebo klasifikoval jeho předmět.

Reverzibilní pseudonymizace přesně odpovídá této potřebě. Před odesláním je každý údaj osobní povahy nahrazen číslovaným markerem a mapování je uchováno v paměti na tvém serveru. API vidí pouze [EMAIL_1] a [TEL_1]. Po návratu jsou markery v generovaném textu obnoveny a koncový uživatel obdrží úplnou odpověď, aniž by jeho údaje kdy opustily tvůj systém.

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

Podívej se pozorně na výstup tohoto příkladu: „Jean Dupont“ je stále přítomen. Počítadlo obsahuje položku pro name, ale žádný regulární výraz ji nevyplňuje – detekce příjmení vyžaduje rozpoznávání pojmenovaných entit (NER), nikoliv vzor znaků. Tuto funkci tedy považuj za základ, na kterém můžeš stavět, nikoliv za kompletní řešení anonymizace.

Pipeline v souladu s GDPR

Samotná minimalizace nestačí: nařízení také vyžaduje, aby každá operace zpracování spočívala na identifikovaném právním základě a byla zaznamenána. Tato pipeline kombinuje oba požadavky ve čtyřech krocích – zaznamenej účel a právní základ, minimalizuj, zavolej API, obnov data. Identifikátor uživatele není nikdy uložen v plain textu, ale hashován, takže registr zůstává použitelný pro počítání operací, aniž by sám o sobě představoval soubor osobních údajů.

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

Parametr legal_basis si zaslouží pozornost: zpracování žádosti o zrušení spadá pod plnění smlouvy, nikoliv pod souhlas. Výběr špatného právního základu je nejčastější a nejdůslednější chybou, protože určuje práva, která může uživatel vůči danému zpracování uplatnit.

Správa souhlasu

Pokud je zvoleným právním základem souhlas, musí být získán, datován, verzován a především odvolatelný. Níže uvedený správce ukládá souhlasy podle účelu – přijetí pomoci od AI neznamená přijetí analýzy textu – a před každou operací zpracování ověřuje tuto shodu. Metoda pro odvolání nese kritický komentář: smazání záznamu o souhlasu nestačí; musíš také smazat data, která na něm závisela.

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

Právo na výmaz (článek 17)

Když uživatel požádá o výmaz svých údajů, tvá povinnost sahá beyond databázi aplikace. Musíš projít všechna místa: lokální data, logy obsahující osobní údaje – na které se často zapomíná – a operaci zdokumentovat, abys ji mohl obhájit. Na straně API je akce již pokryta zásadami uchovávání dat: odeslaná data automaticky zmizí po třiceti dnech, nebo okamžitě, pokud je povoleno 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")

Kontrolní seznam GDPR pro vývojáře

  • Identifikuj právní základ pro každou operaci zpracování (souhlas, smlouva atd.)
  • Minimalizuj data odesílaná do API (anonymizace)
  • Veď záznam o činnostech zpracování (článek 30)
  • Implementuj právo na přístup a právo na výmaz
  • Zdokumentuj přenosy mimo EU (OpenAI = servery v USA)
  • Povol Zero Data Retention, pokud je to možné
  • Nikdy neloguj osobní údaje v plain textu

Klíčové poznatky

  • API OpenAI nepoužívá tvá data k přeškolování svých modelů
  • Anonymizuj osobní údaje před každým voláním API
  • Veď záznam o činnostech zpracování v souladu s článkem 30
  • Implementuj práva dle GDPR: přístup, oprava, výmaz, přenositelnost
  • Přenosy dat mimo EU vyžadují záruky (standardní smluvní doložky)
  • Zdokumentuj každé rozhodnutí týkající se ochrany údajů