Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

GDPR ja tietosuoja OpenAI:n kanssa

Oppitunti 13 / 14 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Tekoäly ja GDPR: Neuvottelematon viitekehys
  2. Seitsemän periaatetta sovellettuna LLM-järjestelmään
  3. Minimointi: Toimenpide, joka ratkaisee useimmat ongelmat
  4. Palvelun konfigurointi ja suostumuksen kerääminen
  5. Rekisteröityjen oikeuksien huomioon ottaminen
  6. Vaikutusten arvioinnin formalisointi
  7. Keskeiset asiat

Tekoäly ja GDPR: Neuvottelematon viitekehys

Yleinen tietosuoja-asetus (GDPR) koskee kaikkia sovelluksia, jotka käsittelevät Euroopan asukkaiden henkilötietoja – mukaan lukien suurten kielimallien (LLM) pohjalta rakennetut sovellukset. Tekoälylle ei ole olemassa poikkeuksia. Tämä hämmentää usein teknisiä tiimejä: he etsivät tekoälykohtaisia määräyksiä, vaikka sovellettava lainsäädäntö on ollut voimassa vuosia eikä ole muuttunut. Vuonna 2026 valvontatoimet kohdistuvat yhä useammin tekoälyjärjestelmiin. OpenAI:n APIen käyttö tässä kontekstissa tarkoittaa vähemmän uusien lakien opettelua ja enemmän tunnettujen oikeudellisten vaatimusten kääntämistä uudenlaiseen arkkitehtuuriin.

Seitsemän periaatetta sovellettuna LLM-järjestelmään

GDPR perustuu seitsemään ydinperiaatteeseen, joista jokainen saa erityisen merkityksen, kun kielimalli astuu mukaan tietojenkäsittelyketjuun.

Periaate Sovellus tekoälyssä
Laillisuus Oikeusperuste tietojen lähettämiseen APIin (suostumus, oikeutettu etu, sopimus)
Tietojen minimointi Lähetä vain mallille ehdottoman välttämättömät tiedot
Käyttötarkoituksen rajoittaminen Lähetettyjen tietojen on palveltava vain ilmoitettua tarkoitusta
Tietojen paikkansapitävyys Mallin tuotokset voivat olla virheellisiä – ilmoita asiasta käyttäjälle
Säilytyksen rajoittaminen Tarkista OpenAI:n säilytyskäytäntö ja poista tiedot asiakaspuolella
Tietoturva Salauksen käyttö siirron aikana, pääsynvalvonta, lokien auditointi
Vastuullisuus Dokumentoi valinnat ja pysty osoittamaan vaatimustenmukaisuus

Kaksi periaatetta yllättävät tiimit usein. Ensinnäkin tietojen paikkansapitävyys: tämä muuttaa hallusinaatiot laatuongelmasta sääntelyongelmaksi. Kun malli tuottaa väärää tietoa tunnistetusta henkilöstä, kyseisellä henkilöllä on oikeus oikaisuun. Toiseksi vastuullisuus: vaatimusten noudattaminen ei riitä – sinun on pystyttävä todistamaan se. Tämä muuttaa dokumentoinnin parhaasta käytännöstä lakisääteisen velvoitteen.

Minimointi: Toimenpide, joka ratkaisee useimmat ongelmat

Kaikista käytettävissä olevista toimenpiteistä pseudonymisointi ennen tietojen lähettämistä tarjoaa parhaan tasapainon vaivan ja riskien vähentämisen välillä. Logiikka on yksinkertainen: se, mikä ei koskaan poistu järjestelmästäsi, ei voi vuotaa alihankkijalle, ei herätä kysymyksiä EU:n ulkopuolisiin siirtoihin liittyen eikä vaikeuta poistopyyntöjä.

Alla oleva mekanismi korvaa jokaisen tunnistetiedon vakaalla tokenilla, pitää mappings-tiedot paikallisessa muistissa ja palauttaa alkuperäiset arvot vastauksessa. Loppukäyttäjä näkee “Herra Dupont’n”, malli näkee vain “[PERSON_1]“:n, ja palvelufunktio pysyy täysin toimintakykyisenä – avustaja voi silti laatia vastauksensa, koska se ei tarvinnut todellista sukunimeä.

Kommentti nimistä ei ole koristeellinen: kaappausmalli tunnistaa vain etuliitteellä varustetut muodot. Pelkkä nimi lipsahtaa läpi. Tuotantoympäristössä nimettyjen entiteettien tunnistus (NER) -malli hoitaa tämän työn, ja tämän varoituksen eksplisiittinen sisällyttäminen koodiin on parempi ratkaisu kuin väärä luottamus.

import re

class DataMinimizer:
    """Anonymizes personal data before sending to the API."""

    def __init__(self):
        self.mappings: dict[str, str] = {}
        self.counter = 0

    def anonymize(self, text: str) -> str:
        """Replaces personal data with placeholders."""
        # Emails
        text = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._replace(m.group(), "EMAIL"),
            text,
        )
        # French phone numbers
        text = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._replace(m.group(), "PHONE"),
            text,
        )
        # Names (simplified pattern—use NER in production)
        text = re.sub(
            r"\b(Mr\.|Ms\.|Dr\.)\s+[A-Z][a-zéèêë]+\s+[A-Z][a-zéèêë]+\b",
            lambda m: self._replace(m.group(), "PERSON"),
            text,
        )
        # IBAN
        text = re.sub(
            r"\b[A-Z]{2}\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{0,4}\b",
            lambda m: self._replace(m.group(), "IBAN"),
            text,
        )
        return text

    def _replace(self, value: str, type_: str) -> str:
        if value not in self.mappings:
            self.counter += 1
            self.mappings[value] = f"[{type_}_{self.counter}]"
        return self.mappings[value]

    def deanonymize(self, text: str) -> str:
        """Restores original data in the response."""
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            text = text.replace(placeholder, original)
        return text

# Usage
minimizer = DataMinimizer()

original_message = "Mr. Dupont ([email protected], 06 12 34 56 78) requests a refund."
anonymized_message = minimizer.anonymize(original_message)
print(f"Sent to API: {anonymized_message}")
# "[PERSON_1] ([EMAIL_1], [PHONE_1]) requests a refund."

# After model response
model_response = "The file for [PERSON_1] has been processed. An email was sent to [EMAIL_1]."
final_response = minimizer.deanonymize(model_response)
print(f"Final response: {final_response}")

Palvelun konfigurointi ja suostumuksen kerääminen

Tarjoajan puolella pätee seuraava sääntö: API:n kautta lähetettyjä tietoja ei oletusarvoisesti käytetä koulutukseen, toisin kuin monet olettavat kuluttajakäyttöliittymien perusteella. Tämä ei vapauta sinua tarkistamasta organisaatiosi asetuksia alustalla ja dokumentoimasta tätä tarkistusta.

from openai import OpenAI

# With the API, your data is NOT used for training by default
# But verify your organization settings on platform.openai.com

client = OpenAI()

# The Responses API endpoint respects the retention policy
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello"}],
    # store=False disables storage on OpenAI's side if available
)

Käyttäjän puolella suostumus hallitaan käyttötarkoituskohtaisesti, ei globaalisti, mikä selittää tässä esitetyn rakenteen: käyttäjä voi hyväksyä keskusteluavun, mutta kieltäytyä vaihtojensa käytöstä palvelun parantamiseen. Käytäntöversio tallennetaan suostumuksen yhteyteen – kriittinen yksityiskohta sinä päivänä, kun päivität kyseistä käytäntöä. Ilman tätä jälkeä et tiedä, kuka on suostunut mihinkin. Lopuksi suostumuksen peruuttaminen käynnistää välittömän poiston, koska tietojen säilyttäminen peruuttamisen jälkeen on juuri se skenaario, joka muuttaa rutiinitarkastuksen valvontatoimeksi.

class ConsentManager:
    """Manages user consent for AI processing."""

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

    def record_consent(self, user_id: str, purposes: list[str]):
        """Records explicit user consent."""
        from datetime import datetime
        self.consent_records[user_id] = {
            "purposes": purposes,
            "date": datetime.now().isoformat(),
            "policy_version": "v2.1",
            "method": "explicit_checkbox",
        }

    def verify_consent(self, user_id: str, purpose: str) -> bool:
        """Checks if the user has consented to a specific purpose."""
        if user_id not in self.consent_records:
            return False
        return purpose in self.consent_records[user_id]["purposes"]

    def withdraw_consent(self, user_id: str):
        """Withdraws consent and triggers data deletion."""
        if user_id in self.consent_records:
            del self.consent_records[user_id]
            self._delete_data(user_id)

    def _delete_data(self, user_id: str):
        """Deletes all data associated with the user."""
        # Delete conversation history
        # Delete logs containing personal data
        # Notify subprocessors (OpenAI) if applicable
        print(f"Data deleted for {user_id}")

Rekisteröityjen oikeuksien huomioon ottaminen

Oikeudet saada pääsy tietoihin, tulla unohdetuksi ja siirtää tiedot on toteutettava ennen ensimmäisen pyynnön saapumista, sillä kuukauden määräaika vastata katoaa nopeasti, jos joudut vielä kirjoittamaan koodia. Pääsyoikeus vaatii enemmän kuin raakadataa: sinun on toimitettava käyttötarkoitukset, luettelo alihankkijoista ja säilytysajat – tiedot, jotka on parempi konsolidoida etukäteen.

Oikeus tulla unohdetuksi vaatii huolellista koodin tarkastelua. Vastauksessa erotetaan eksplisiittisesti paikalliset tiedot, jotka poistetaan välittömästi, ja APIin lähetetyt tiedot, jotka kuuluvat tarjoajan säilytyskäytännön piiriin. Tämä rehellisyys on pakollista: täydellisen ja välittömän poiston lupaaminen samalla, kun kopio jää alihankkijalle, altistaa sinut enemmän kuin molempien järjestelmien selkeä dokumentointi.

class DataSubjectRights:
    """Implements GDPR rights for users."""

    def right_of_access(self, user_id: str) -> dict:
        """Returns all data held on the user."""
        return {
            "personal_data": self._collect_data(user_id),
            "processing_purposes": ["customer_support", "service_improvement"],
            "subprocessors": ["OpenAI (LLM API)", "PostgreSQL (storage)"],
            "retention_period": "12 months after last activity",
            "source": "Direct user input",
        }

    def right_to_erasure(self, user_id: str) -> dict:
        """Deletes all user data."""
        # Delete from local database
        deleted_local = self._delete_local(user_id)
        # Data sent to OpenAI API is subject
        # to their retention policy (max 30 days via API)
        return {
            "status": "deleted",
            "local_data": "deleted",
            "openai_data": "subject to 30-day retention",
            "date": datetime.now().isoformat(),
        }

    def right_to_portability(self, user_id: str) -> dict:
        """Exports data in a structured format."""
        data = self._collect_data(user_id)
        return {
            "format": "JSON",
            "data": data,
            "export_date": datetime.now().isoformat(),
        }

    def _collect_data(self, user_id: str) -> dict:
        return {"user_id": user_id, "conversations": [], "profile": {}}

    def _delete_local(self, user_id: str) -> int:
        return 0

Vaikutusten arvioinnin formalisointi

Kaikille tekoälysovelluksille, jotka käsittelevät henkilötietoja laajassa mittakaavassa, tietosuojavaikutusten arviointi (DPIA) on pakollinen. Alla oleva rakenne esittää odotetut osiot, ja esimerkki havainnollistaa, miltä valmis DPIA näyttää asiakaspalvelu-chatbotille.

Kaksi kenttää kiinnittävät valvontaviranomaisen huomion erityisesti. Ensinnäkin siirrot EU:n ulkopuolelle: aina kun käsittely kulkee yhdysvaltalaisen tarjoajan kautta, sinun on nimettävä vastaanottaja, maa ja käytetty suojauskeino – tässä tapauksessa vakiosopimuslausekkeet (SCC), joita täydentää OpenAI:n tietojenkäsittelysopimus. Toiseksi riskianalyysi, jonka on oltava erityinen kuvatulle järjestelmälle. Esimerkissä valittu riski on henkilötietojen vuotaminen kehoteinjektion (prompt injection) kautta, ja lieventävinä toimenpiteinä ovat tietojen kalastelun estävät suojaukset ja moderointi: kaikki, mitä rakensit edellisissä luvuissa, saa tässä sääntelyllisen vastineensa.

@dataclass
class ImpactAssessment:
    """Structure of a DPIA for an AI system."""
    processing_name: str
    description: str
    legal_basis: str
    data_processed: list[str]
    recipients: list[str]
    transfers_outside_eu: list[dict]
    security_measures: list[str]
    risks: list[dict]
    dpo_opinion: str = ""

dpia_chatbot = ImpactAssessment(
    processing_name="Customer Service Chatbot with AI",
    description="Conversational assistant using GPT-5.6 Sol via OpenAI API",
    legal_basis="Legitimate interest (customer support)",
    data_processed=["first_name", "email", "order_history", "chat_messages"],
    recipients=["Support team", "OpenAI (API subprocessor)"],
    transfers_outside_eu=[{
        "recipient": "OpenAI Inc.",
        "country": "United States",
        "safeguard": "Standard Contractual Clauses (SCCs) + OpenAI DPA",
    }],
    security_measures=[
        "Anonymization before sending to API",
        "TLS encryption in transit",
        "Access logs with 90-day retention",
        "Right to erasure implemented",
    ],
    risks=[{
        "description": "Personal data leakage via prompt injection",
        "likelihood": "medium",
        "severity": "high",
        "mitigation": "Anti-exfiltration guardrails + moderation",
    }],
)

Keskeiset asiat

  • GDPR koskee heti, kun tekoälyjärjestelmä käsittelee Euroopan asukkaiden tietoja
  • Tietojen minimointi (anonymisointi ennen APIin lähettämistä) on ensimmäinen refleksi
  • Rekisteröityjen oikeudet (pääsy, poisto, siirrettävyys) on toteutettava
  • DPIA on pakollinen laajamittaisessa tekoälyn käsittelyssä
  • EU:n ulkopuoliset siirrot dokumentoidaan OpenAI:n DPA:n ja eksplisiittisten suojakeinojen (SCC, siirron vaikutusten arviointi) kautta