Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Zasebnost podatkov in GDPR

Lekcija 21 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Zasebnost podatkov in GDPR
  2. Kako OpenAI obdeluje tvoje podatke
  3. Minimalizacija podatkov
  4. Skladna cevovodna obdelava z GDPR
  5. Upravljanje privolitev
  6. Pravica do izbrisa (17. člen)
  7. Kontrolni seznam GDPR za razvijalce
  8. Ključne ugotovitve

Zasebnost podatkov in GDPR

Kot evropski razvijalec moraš razumeti, kako podatki potujejo skozi API OpenAI, in katere korake moraš izvesti za skladnost s splošno uredbo o varstvu podatkov (GDPR). Ta lekcija pokriva tehnične vidike skladnosti. Ne nadomešča nasvetov tvoje pooblaščene osebe za varstvo podatkov (DPO), vendar ti ponuja programske prakse, ki bodo njihovo delo omogočile – in ki postanejo, če jih med načrtovanjem zanemarimo, izjemno drage za popravilo kasneje.

Kako OpenAI obdeluje tvoje podatke

Prek API-ja (ne ChatGPT)

Razlikovanje med uporabo API-ja in potrošniško uporabo je izhodišče vsake razprave na to temo. Ko uporabljaš API OpenAI za svojo aplikacijo, se podatki ne uporabljajo za usposabljanje modelov: to je politika API-ja, ki se razlikuje od politike ChatGPT, in to je argument, ki ga boš uporabil za obravnavo najpogostejšega ugovora v odborih za varnost. Vendar se podatki hranijo 30 dni, da se omogoči zaznavanje zlorab, nato pa se izbrišejo. To obdobje hrambe lahko skrajšaš: prek funkcije „ničelno hramba podatkov” (Zero Data Retention) lahko zahtevaš predčasen izbris. Eno točko je treba še dokumentirati v tvoji oceni učinka – podatki potujejo prek strežnikov OpenAI, ki so večinoma locirani v Združenih državah Amerike, kar predstavlja prenos zunaj Evropske unije.

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

Minimalizacija podatkov

GDPR zahteva obdelavo le strogo potrebnih podatkov. To načelo uporabi pri svojih klicih API-ja: v veliki večini primerov model ne potrebuje imena osebe, e-poštnega naslova ali telefonske številke, da bi povzel njeno zahtevo ali razvrstil njeno temo.

Povratna psevdonimizacija natančno odgovarja na to potrebo. Pred pošiljanjem se vsak del osebnih podatkov nadomesti z oštevilčenim označevalcem, preslikava pa se hrani v pomnilniku na tvojem strežniku. API vidi le [EMAIL_1] in [TEL_1]. Ob vrnitvi se označevalci obnovijo v ustvarjenem besedilu, končni uporabnik pa prejme popoln odgovor, ne da bi koordinatne točke kdaj zapustile tvoj sistem.

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

Pozorno si oglej izhod tega primera: „Jean Dupont” je še vedno prisoten. Števec vključuje vnos za name, vendar ga noben regularni izraz ne izpolni – zaznavanje priimka zahteva prepoznavanje poimenovanih entitet, ne vzorca znakov. Zato to funkcijo obravnavaj kot temelj za nadgradnjo, ne kot popolno rešitev za anonimizacijo.

Skladna cevovodna obdelava z GDPR

Sama minimalizacija ni dovolj: uredba zahteva tudi, da vsaka obdelava temelji na opredeljeni pravni podlagi in je zabeležena. Ta cevovod združuje obe zahtevi v štirih korakih – zabeleži namen in pravno podlago, minimiziraj, pokliči, obnovi. Uporabniški identifikator nikoli ni shranjen v navadni obliki, temveč je razpršen (hashed), tako da register ostane uporaben za štetje operacij, ne da bi sam predstavljal zbirko osebnih podatkov.

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

Parameter legal_basis si zasluži pozornost: obdelava zahteve za preklic spada pod izvajanje pogodbe, ne pod privolitev. Izbira napačne pravne podlage je najpogostejša in najbolj posledična napaka, saj določa pravice, ki jih lahko uporabnik uveljavlja glede te obdelave.

Upravljanje privolitev

Ko je izbrana pravna podlaga privolitev, jo je treba zbrati, datirati, različiti in predvsem mora biti preklicljiva. Spodnji upravitelj shranjuje privolitve po namenu – sprejetje pomoči z umetno inteligenco ne pomeni sprejetja analize besedila – in pred vsako obdelavo preveri to ujemanje. Metoda za umik nosi kritičen komentar: brisanje zapisa o privolitvi ni dovolj; izbrisati moraš tudi podatke, ki so od nje odvisni.

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

Pravica do izbrisa (17. člen)

Ko uporabnik zahteva izbris svojih podatkov, se tvoja obveznost ne konča pri zbirki podatkov aplikacije. Prečesati moraš vse lokacije: lokalne podatke, dnevnike, ki vsebujejo osebne podatke – kar se pogosto pozabi – in dokumentirati operacijo, da jo lahko utemeljiš. Na strani API-ja je dejanje že zajeto s politiko hrambe: poslani podatki samodejno izginejo po tridesetih dneh ali takoj, če je omogočena ničelna hramba podatkov.

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

Kontrolni seznam GDPR za razvijalce

  • Opredeli pravno podlago za vsako operacijo obdelave (privolitev, pogodba itd.)
  • Minimiziraj podatke, poslane API-ju (anonimizacija)
  • Vodi register dejavnosti obdelave (30. člen)
  • Vzpostavi pravico do dostopa in pravico do izbrisa
  • Dokumentiraj prenose zunaj EU (OpenAI = strežniki v ZDA)
  • Omogoči ničelno hrambo podatkov, če je mogoče
  • Nikoli ne beleži osebnih podatkov v navadni obliki

Ključne ugotovitve

  • API OpenAI NE ponovno usposablja svojih modelov s tvojimi podatki
  • Anonimiziraj osebne podatke pred vsakim klicem API-ja
  • Vodi register dejavnosti obdelave, skladen z 30. členom
  • Vzpostavi pravice iz GDPR: dostop, popravek, izbris, prenosljivost
  • Prenosi podatkov zunaj EU zahtevajo zaščitne ukrepe (standardne pogodbene določbe)
  • Dokumentiraj vsako odločitev glede varstva podatkov