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

Homokozózás és biztonsági korlátok

11. lecke 20 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Homokozózás és biztonsági korlátok
  2. A homokozó architektúrája
  3. Mi érhető el?
  4. Mi korlátozott?
  5. Adatbiztonság
  6. Végrehajtási hibák kezelése
  7. Legjobb gyakorlatok
  8. Főbb megállapítások

Frissítve: 2026. november 2. az OpenAI dokumentációja alapján: a Code Interpreter eszköz mostantól megköveteli a container paramétert (hozzáadva minden példához). A alapértelmezetten zárt konténerhálózat mostantól megnyitható egy engedélyezett domainek listája (allowlist) számára. A konténer életciklusára vonatkozó szabályok (memória, lejárat, újrafelhasználás) követik a hivatalos útmutatót. Az üzenethez csatolt fájlok feltöltése a user_data célból (purpose) történik, ahogy azt az OpenAI a modell bemeneteknél javasolja. Források: Code Interpreter · Container Network Access · Containers API · Files API.

Homokozózás és biztonsági korlátok

A homokozó (sandbox) korlátai nem hibák, amelyeket meg kell kerülnöd: ezek azok a tulajdonságok, amelyek elfogadhatóvá teszik a generált kód futtatását. Egy hálózatilag izolált környezet, rövid élettartammal és erőforrás-korlátokkal nem képes kiszivárogtatni az adataidat, nem hagy állapotot végtelen ideig magára, és nem fogyaszt korlátlanul erőforrásokat.

Ha előre ismered ezeket a korlátokat, megspórolod a lehetetlen hibakeresést. A három visszatérő kérdésre – miért nem működik a pip install, miért tűnt el a fájlom a hívások között, miért omlik össze a feldolgozás nagy fájloknál – az alábbiakban megtalálod a választ, és egyik sem hiba.

A homokozó architektúrája

A Code Interpreter egy konténerben futtatja a kódot, amely egy izolált virtuális gép, amit az OpenAI üzemeltet, az alábbi tulajdonságokkal:

  • Alapértelmezetten zárt hálózat: nincs kimenő kérés, kivéve egy kifejezetten megnyitott engedélyezett domain-listát (lásd lentebb)
  • Rövid élettartam: a konténer 20 perc inaktivitás után lejár, és minden benne lévő adat törlődik
  • Korlátozott memória: alapértelmezetten 1 GB, vagy kérésre 4, 16, illetve 64 GB (memory_limit), ahol minden szintnek saját árazása van
from openai import OpenAI

client = OpenAI()

# Engedélyezett lista nélkül a letöltés sikertelen: nincs hálózati hozzáférés
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Download the content of https://example.com using requests",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# A modell magyarázni fogja, hogy a hálózati hozzáférés nem elérhető
print(response.output_text)

Mi érhető el?

Előtelepített könyvtárak

Az OpenAI nem tesz közzé hivatalos listát a konténer csomagjairól, és ez idővel változik. Egy fejlesztő által az OpenAI fórumon 2025 novemberében közzétett felmérés 389 csomagot számlált, beleértve az elemzéshez elvárt könyvtárakat: pandas, numpy, scipy és statsmodels az adatokhoz; matplotlib, seaborn és plotly a vizualizációhoz; Pillow a képekhez; sympy a szimbolikus matematikához; openpyxl az Excelhez. Ne feltételezz semmit, inkább kérd meg a modellt, hogy a projekt elején készítse el a leltárt:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="List the installed Python packages with their versions, "
          "then display the Python version.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)

A verziók ugyanolyan fontosak, mint a nevek: ugyanaz a felmérés pandas 1.5.3-at mutatott, ami megelőzi a pandas 2.0-t. Ha a feldolgozásod egy újabb függvénytől függ, ellenőrizd, hogy létezik-e, mielőtt építenél rá.

Fájlrendszer

A kód a konténeren belül olvas és ír fájlokat. A modell által létrehozott fájlok hivatkozva vannak a válaszában, és a 10. leckéből ismert fichiers_generes és telecharger függvényekkel tölthetők le:

# A modell létrehozhat fájlokat a konténeren belül
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Create a CSV file with 100 lines of test data "
          "(name, age, city, salary) and return it.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

for ann in fichiers_generes(response):
    telecharger(client, ann, ann.filename)

Mi korlátozott?

Hálózati hozzáférés

Alapértelmezetten a konténernek nincs kimenő hozzáférése: nincs pip install, nincs API-hívás, nincs letöltés. Ez a legszerkezetibb korlát, és szándékos: a generált kód nem küldhet semmit sehová. Annak, amire a feldolgozásodnak szüksége van, jelen kell lennie a konténerben, vagy neked kell feltöltened – és ha az adat online van, a webes kereső eszköz gyakran megszerzi helyetted.

# Engedélyezett lista nélkül (alapértelmezett eset) lehetetlen:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (nincs letöltés)
# - Hozzáférés külső API-khoz
# - E-mailek küldése

A hozzáférés megnyitása létezik, de ez két szinten dől el. Egy adminisztrátor először meghatározza a szervezet engedélyezett listáját a vezérlőpulton; minden kérés ezután deklarál egy network_policyt, amely ezt csak tovább korlátozhatja – egy olyan kérés, amely egy olyan domaint kér, ami nincs rajta a szervezet listáján, sikertelen lesz.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Update pandas with pip, then display the installed version.",
    tools=[{
        "type": "code_interpreter",
        "container": {
            "type": "auto",
            "network_policy": {
                "type": "allowlist",
                "allowed_domains": ["pypi.org", "files.pythonhosted.org"],
            },
        },
    }],
)

A domainek megnyitásának költsége van, és az OpenAI ezt egyértelműen kimondja: ez egy kapu az adatszivárgás felé prompt injection útján. Csak megbízható domaineket engedélyezz, amelyeket egy támadó nem használhat adatfogadásra – és vigyázz a megosztott tárhelyekkel, ahol bárki felállíthat egy szervert, amely naplózza a kéréseidet.

Perzisztencia a hívások között

A perzisztencia hiánya sokakat meglep a hívások láncolásakor: az első hívásban betöltött DataFrame már nem létezik a másodikban. A pontos szabály az auto módon múlik: ez egy új konténert hoz létre, kivéve, ha a modell kontextusa már tartalmaz egy Code Interpreter hívást, amelynek konténere még aktív – ekkor azt újrahasználja. Két független hívás tehát mindegyike a sajátjában dolgozik, míg egy az előzőhöz láncolt hívás (previous_response_id-vel) megtalálja a sajátját, ha az még nem járt le. Egyetlen híváson belül több kódvégrehajtás ugyanazt a munkamenetet osztja meg.

# Első hívás: létrehoz egy fájlt
response1 = client.responses.create(
    model="gpt-5.6-terra",
    input="Create a variable x = 42 and save it to a file",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Második hívás, függetlenül az elsőtől: új konténer
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Hiba: a fájl nem található

Hogy a hívások között megőrizd az eredményeket anélkül, hogy a kontextustól függenél, dolgozz ugyanabban a konténerben. Hozd létre explicit módon a Containers API-val, és add át az azonosítóját minden híváshoz: az egyik lépésben létrehozott fájlok elérhetők maradnak a következőhöz. Alapértelmezetten 20 perc inaktivitás után lejár, és az adatai véglegesen elvesznek: töltsd le, amit meg szeretnél tartani, majd töröld magad.

def pipeline_avec_persistance(etapes: list[str]) -> list:
    """Végrehajtja a egymást követő lépéseket ugyanabban a konténerben."""
    conteneur = client.containers.create(name="pipeline")
    resultats = []

    for etape in etapes:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=etape,
            tools=[{"type": "code_interpreter", "container": conteneur.id}],
        )
        resultats.append(response.output_text)

    # A hasznos fájlok letöltése után (10. lecke)
    client.containers.delete(conteneur.id)
    return resultats

Ne add vissza a generált fájlokat input_file-ként: az azonosítóik (cfile_…) a konténer fájljaira hivatkoznak, nem a Files API fájljaira.

Memória és nehéz feldolgozás

A dokumentáció nem tesz közzé maximális végrehajtási időt; a konkrét korlát a konténer memóriája, amelyet létrehozáskor választasz ki, és az egész élettartama alatt érvényes. Nagy fájl esetén válassz megfelelő szintet, és kérd meg a munkát darabolásra. Ezen túl – modelltanítás, hatalmas számítások – a saját infrastruktúrádat kell használnod, a konténer pedig az interaktív elemzés eszköze marad.

# Minta a nehéz feldolgozáshoz: több memória, osztott munka
with open("transactions.csv", "rb") as f:
    fichier = client.files.create(file=f, purpose="user_data")

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Process this 500,000-line CSV file in batches of 50,000. "
                "For each batch, calculate statistics and accumulate results."
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto", "memory_limit": "4g"}}],
    instructions="If processing risks being long, split it into steps "
                "and display progress."
)

Adatbiztonság

Érzékeny adatok

A konténerbe másolt adatok törlődnek, amikor az lejár vagy törlődik. Ez nem igaz a Files API-n keresztül feltöltött fájlokra: azok ott maradnak, amíg nem törlöd őket, kivéve, ha beállítasz egy lejárati időt (expires_after, egy óra és harminc nap között). És a megfelelőségi gondolkodás itt nem áll meg: az adataid elhagyták a saját infrastruktúrádat, hogy egy harmadik fél dolgozza fel őket. Az álanevesítés (pseudonymization) a küldés előtt néhány sorba kerül, és csökkenti azt, ami távozik – mert egy ügyfélazonosító, ami soha nem hagyja el a rendszert, nem okozhat problémát.

Egy kulcsos hash (HMAC) stabil álaneveket ad az egyik küldéstől a másikig, amelyeket senki nem tud összekapcsolni az eredeti értékekkel a kulcs nélkül. A GDPR szerint az eredmény továbbra is álanevesített személyes adat marad, nem névtelen: a kulcsnak nálad kell maradnia.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # titok, amit a kódon kívül tartunk


def pseudonyme(valeur) -> str:
    return hmac.new(CLE, str(valeur).encode(), hashlib.sha256).hexdigest()[:16]


def analyser_donnees_sensibles(fichier_path: str, colonnes_a_masquer: list[str]):
    """Álanevesíti az adatokat, mielőtt elküldené a Code Interpreternek."""
    df = pd.read_csv(fichier_path)
    for col in colonnes_a_masquer:
        if col in df.columns:
            df[col] = df[col].map(pseudonyme)

    fichier_pseudo = "/tmp/donnees_pseudonymisees.csv"
    df.to_csv(fichier_pseudo, index=False)

    # Küldés automatikus lejárattal egy óra múlva
    with open(fichier_pseudo, "rb") as f:
        fichier = client.files.create(
            file=f,
            purpose="user_data",
            expires_after={"anchor": "created_at", "seconds": 3600},
        )

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Analyze trends in this data"},
                {"type": "input_file", "file_id": fichier.id}
            ]
        }],
        tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
    )
    client.files.delete(fichier.id)  # a lejáratra várás nélkül
    return response.output_text

Generált kód

Az izoláció megvédi a rendszeredet, de nem garantálja az eredmény helyességét: a kód az OpenAI-nál fut, egy eldobható konténerben, és soha nem érinti a gépeidet. A kockázat arra tolódik át, amit a kimenetekkel csinálsz. Ha lekérdezed a kódot, hogy a saját oldaladon futtasd, tekintsd úgy rá, mint egy harmadik féltől származó kódra. És ha a konténernek van engedélyezett listája, tartsd észben, hogy egy rosszindulatú fájl tartalmazhat olyan utasításokat, amelyek ráveszik a modellt, hogy adatokat küldjön ezekre a domainekre.

Végrehajtási hibák kezelése

A kód meghibásodhat a homokozóban. A modell általában megpróbálja kijavítani:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Calculate the inverse matrix of a singular matrix [[1,2],[2,4]]",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions="If the code produces an error, explain why "
                "and propose an alternative."
)

# A modell végrehajtja a kódot, észleli a LinAlgError-t,
# majd megmagyarázza, hogy a mátrix szinguláris, és javasolja
# a Moore-Penrose pszeudoinverzt

Legjobb gyakorlatok

# 1. Légy specifikus az utasításaidban
# Rossz:
input_vague = "Analyze this data"

# Jó:
input_precis = ("Load this CSV with pandas. "
               "Calculate the mean, median, and standard deviation of the 'amount' column. "
               "Identify values greater than 3 standard deviations. "
               "Generate a boxplot.")

# 2. Kérj kommentezett kódot
instructions = "Comment each step of the code. Display intermediate results."

# 3. Kezeld a nagy fájlokat
instructions_lot = ("If the file exceeds 100,000 lines, "
                   "work on a representative sample of 10,000 lines "
                   "and indicate this in your response.")

Főbb megállapítások

  • A konténer izolált: alapértelmezetten zárt hálózat, korlátozott memória, lejárat 20 perc inaktivitás után
  • Az OpenAI nem teszi közzé a csomaglistát: kérd meg a modellt a leltározásra
  • A domain engedélyezett lista két szinten nyílik meg (szervezet, majd kérés), és kitetté teszi az adatszivárgásnak: csak megbízható domaineket tegyél oda
  • A lépések láncolásához használd újra ugyanazt a konténert (client.containers.create, majd az ID-ja minden hívásnál), és töröld a végén
  • Álanevesítsd az érzékeny adatokat küldés előtt, és töröld a feltöltött fájlokat használat után
  • A modell kezeli a végrehajtási hibákat, és megpróbálja önkorrigálni magát