Homokozózás és biztonsági korlátok
Ezen az oldalon
Frissítve: 2026. november 2. az OpenAI dokumentációja alapján: a Code Interpreter eszköz mostantól megköveteli a
containerparamé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 auser_datacé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