Przejdź do głównej treści
Polski— Wybierz język
Menu

Prywatność danych i RODO

Lekcja 21 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Prywatność danych i RODO
  2. Jak OpenAI przetwarza Twoje dane
  3. Minimalizacja danych
  4. Potok zgodny z RODO
  5. Zarządzanie zgodą
  6. Prawo do usunięcia (art. 17)
  7. Lista kontrolna RODO dla programistów
  8. Kluczowe wnioski

Prywatność danych i RODO

Jako programista z Europy musisz rozumieć, jak dane przepływają przez API OpenAI i jakie kroki podjąć, aby spełnić wymogi RODO (Ogólnego Rozporządzenia o Ochronie Danych). Ta lekcja omawia techniczne aspekty zgodności. Nie zastępuje ona porad Twojego Inspektora Ochrony Danych (IOD), ale dostarcza praktyk programistycznych, które umożliwią mu pracę – a które, jeśli zostaną zaniedbane na etapie projektowania, staną się później niezwykle kosztowne do naprawienia.

Jak OpenAI przetwarza Twoje dane

Poprzez API (nie ChatGPT)

Rozróżnienie użycia API od korzystania z wersji konsumenckiej to punkt wyjścia każdej dyskusji na ten temat. Gdy używasz API OpenAI w swojej aplikacji, dane nie są wykorzystywane do trenowania modeli: taka jest polityka API, która różni się od polityki ChatGPT, i jest to argument, którego użyjesz, aby odpowiedzieć na najczęstszy zarzut w komitetach ds. bezpieczeństwa. Dane są jednak przechowywane przez 30 dni w celu wykrywania nadużyć, a następnie usuwane. Możesz skrócić ten okres przechowywania: możesz zażądać wczesnego usunięcia dzięki funkcji Zero Data Retention. Pozostaje jeden punkt do udokumentowania w ocenie skutków – dane przemieszczają się przez serwery OpenAI, zlokalizowane głównie w Stanach Zjednoczonych, co stanowi transfer poza Unię Europejską.

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

Minimalizacja danych

RODO wymaga przetwarzania wyłącznie danych ściśle niezbędnych. Zastosuj tę zasadę do wywołań API: w zdecydowanej większości przypadków model nie potrzebuje znać imienia i nazwiska, adresu e-mail ani numeru telefonu osoby, aby podsumować jej żądanie lub sklasyfikować temat wiadomości.

Odwracalna pseudonimizacja dokładnie odpowiada na tę potrzebę. Przed wysłaniem każda część danych osobowych jest zastępowana numerowanym znacznikiem, a mapa odwzorowań jest przechowywana w pamięci na Twoim serwerze. API widzi tylko [EMAIL_1] i [TEL_1]. Po otrzymaniu odpowiedzi znaczniki są przywracane w wygenerowanym tekście, a użytkownik końcowy otrzymuje kompletną odpowiedź, przy czym dane kontaktowe nigdy nie opuszczają Twojego systemu.

import re

def anonymize_before_send(text: str) -> tuple[str, dict]:
    """Anonimizuje dane osobowe przed wysłaniem do API."""
    replacements = {}
    counter = {"email": 0, "phone": 0, "name": 0}

    # Adresy e-mail
    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
    )

    # Francuskie numery telefonów
    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:
    """Przywraca dane po przetworzeniu przez API."""
    for key, value in replacements.items():
        text = text.replace(key, value)
    return text

# Użycie
from openai import OpenAI
client = OpenAI()

original_text = "Skontaktuj się z Jeanem Dupontem pod adresem [email protected] lub 06 12 34 56 78"

# Anonimizacja
anonymous_text, mapping = anonymize_before_send(original_text)
print(f"Wysłano do API: {anonymous_text}")
# Wysłano do API: Skontaktuj się z Jeanem Dupontem pod adresem [EMAIL_1] lub [TEL_1]

# Wywołanie API z danymi zanonimizowanymi
response = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Podsumuj tę wiadomość: {anonymous_text}"
)

# Przywrócenie
result = restore_data(response.output_text, mapping)
print(f"Ostateczny wynik: {result}")

Przyjrzyj się uważnie wynikowi tego przykładu: „Jean Dupont“ nadal tam jest. Licznik zawiera wpis dla name, ale żadne wyrażenie regularne go nie wypełnia – wykrycie nazwiska wymaga rozpoznawania encji nazwanych (NER), a nie wzorca znaków. Dlatego traktuj tę funkcję jako fundament do rozbudowy, a nie jako kompletne rozwiązanie anonimizacji.

Potok zgodny z RODO

Sama minimalizacja nie wystarczy: rozporządzenie wymaga również, aby każda operacja przetwarzania opierała się na zidentyfikowanej podstawie prawnej i była rejestrowana. Ten potok łączy oba wymagania w czterech krokach: zarejestruj cel i podstawę prawną, zminimalizuj dane, wywołaj API, przywróć dane. Identyfikator użytkownika nigdy nie jest przechowywany w postaci jawnej, lecz haszowany, dzięki czemu rejestr pozostaje użyteczny do liczenia operacji, nie stanowiąc sam w sobie zbioru danych osobowych.

from datetime import datetime
import json
import hashlib

class GDPRCompliantPipeline:
    """Potok przetwarzania zgodny z RODO."""

    def __init__(self):
        self.client = OpenAI()
        self.processing_logs = []

    def process(self, text: str, purpose: str,
                legal_basis: str, user_id: str) -> str:
        """Przetwarza tekst zgodnie z wymogami RODO."""

        # 1. Zarejestruj podstawę prawną przetwarzania
        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. Minimalizacja danych
        anonymous_text, mapping = anonymize_before_send(text)

        # 3. Wywołanie API
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=anonymous_text,
            # Przechowuj przez jak najkrótszy możliwy czas
        )

        processing["tokens_used"] = response.usage.total_tokens
        self.processing_logs.append(processing)

        # 4. Przywróć i zwróć wynik
        return restore_data(response.output_text, mapping)

    def export_register(self) -> str:
        """Eksportuje rejestr czynności przetwarzania (art. 30 RODO)."""
        return json.dumps(self.processing_logs, indent=2, ensure_ascii=False)

# Użycie
pipeline = GDPRCompliantPipeline()

result = pipeline.process(
    text="Klient Pierre Martin chce anulować swoją subskrypcję.",
    purpose="Przetwarzanie wniosku o anulowanie",
    legal_basis="contract",
    user_id="user-456"
)
print(result)
print(pipeline.export_register())

Parametr legal_basis zasługuje na szczególną uwagę: przetwarzanie wniosku o anulowanie podlega wykonaniu umowy, a nie zgodzie. Wybór niewłaściwej podstawy prawnej to najczęstszy i najbardziej dotkliwy błąd, ponieważ determinuje on prawa, jakie użytkownik może wykonywać wobec tego przetwarzania.

Zarządzanie zgodą

Gdy wybraną podstawą prawną jest zgoda, musi ona zostać zebrana, datowana, wersjonowana i, co najważniejsze, możliwa do cofnięcia. Poniższy menedżer przechowuje zgodę w podziale na cele – zaakceptowanie pomocy AI nie implikuje akceptacji analizy tekstu – i weryfikuje to dopasowanie przed każdą operacją przetwarzania. Metoda cofnięcia zawiera krytyczny komentarz: samo usunięcie rekordu zgody nie wystarczy; musisz również usunąć dane, które od niej zależały.

class ConsentManager:
    """Zarządza zgodą użytkownika na przetwarzanie AI."""

    def __init__(self):
        self.consents: dict[str, dict] = {}

    def record_consent(self, user_id: str, purposes: list[str]):
        """Rejestruje zgodę użytkownika."""
        self.consents[user_id] = {
            "purposes": purposes,
            "date": datetime.now().isoformat(),
            "version": "v1.0"
        }

    def verify_consent(self, user_id: str, purpose: str) -> bool:
        """Sprawdza, czy użytkownik wyraził zgodę na dany cel."""
        consent = self.consents.get(user_id)
        if not consent:
            return False
        return purpose in consent["purposes"]

    def withdraw_consent(self, user_id: str):
        """Cofa zgodę (prawo do cofnięcia)."""
        if user_id in self.consents:
            del self.consents[user_id]
            # Tutaj: usuń również powiązane dane

# Użycie
consent = ConsentManager()

# Użytkownik wyraża zgodę na przetwarzanie AI
consent.record_consent("user-123", ["ai_assistance", "text_analysis"])

# Weryfikuj przed każdą operacją przetwarzania
if consent.verify_consent("user-123", "ai_assistance"):
    # Kontynuuj przetwarzanie
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="Pytanie użytkownika"
    )
else:
    print("Wymagana zgoda na to przetwarzanie")

Prawo do usunięcia (art. 17)

Gdy użytkownik żąda usunięcia swoich danych, Twój obowiązek wykracza poza bazę danych aplikacji. Musisz przeszukać wszystkie lokalizacje: dane lokalne, logi zawierające informacje osobowe – często o nich zapominane – i udokumentować operację, aby ją uzasadnić. Po stronie API działanie to jest już objęte polityką przechowywania: wysłane dane znikają automatycznie po trzydziestu dniach lub natychmiast, jeśli włączono funkcję Zero Data Retention.

def exercise_right_to_erasure(user_id: str):
    """Wdraża prawo do usunięcia zgodnie z RODO."""

    # 1. Usuń dane lokalne
    # delete_user_data(user_id)

    # 2. Dane wysłane do API OpenAI są usuwane
    # automatycznie po 30 dniach (lub natychmiast
    # po włączeniu Zero Data Retention)

    # 3. Usuń logi zawierające dane osobowe
    # delete_user_logs(user_id)

    # 4. Udokumentuj usunięcie
    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")

Lista kontrolna RODO dla programistów

  • Zidentyfikuj podstawę prawną dla każdej operacji przetwarzania (zgoda, umowa itp.)
  • Zminimalizuj dane wysyłane do API (anonimizacja)
  • Prowadź rejestr czynności przetwarzania (art. 30)
  • Wdróż prawo dostępu i prawo do usunięcia
  • Udokumentuj transfery poza UE (OpenAI = serwery w USA)
  • Włącz Zero Data Retention, jeśli to możliwe
  • Nigdy nie loguj danych osobowych w postaci jawnej

Kluczowe wnioski

  • API OpenAI NIE wykorzystuje Twoich danych do ponownego trenowania swoich modeli
  • Anonimizuj dane osobowe przed każdym wywołaniem API
  • Prowadź rejestr czynności przetwarzania zgodny z art. 30
  • Wdróż prawa wynikające z RODO: dostęp, sprostowanie, usunięcie, przenoszenie
  • Transfery danych poza UE wymagają zabezpieczeń (standardowe klauzule umowne)
  • Dokumentuj każdą decyzję dotyczącą ochrony danych