Sandboxing in varnostne omejitve
Na tej strani
Posodobljeno 2. novembra 2026 na podlagi dokumentacije OpenAI: orodje Code Interpreter zdaj zahteva parameter
container(dodan vsem primerom). Omrežje zabojnika, ki je privzeto zaprto, se lahko zdaj odpre za seznam dovoljenih domen. Pravila življenjskega cikla zabojnika (pomnilnik, potek veljavnosti, ponovna uporaba) sledijo uradnemu vodniku. Datoteke, priložene sporočilu, so naložene z namenomuser_data, kot priporoča OpenAI za vhode modela. Viri: Code Interpreter · Dostop do omrežja zabojnika · API za zabojnike · API za datoteke.
Sandboxing in varnostne omejitve
Omejitve sandboxa niso hrošči, ki bi jih bilo treba obiti: to so lastnosti, zaradi katerih je izvajanje generirane kode sprejemljivo. Omrežno izolirano okolje s kratko življenjsko dobo in omejitvami virov ne more izvoziti vaših podatkov, pustiti stanja nedoločen čas ali neomejeno porabljati virov.
Če te omejitve poznate vnaprej, se izognete iskanju napak v nemogočem. Na tri ponavljajoča se vprašanja – zakaj pip install ne uspe, zakaj je moja datoteka izginila med klici, zakaj moja obdelava odpove pri veliki datoteki – najdete odgovore spodaj in noben od njih ni hrošč.
Arhitektura sandboxa
Code Interpreter izvaja kodo v zabojniku, izoliranem virtualnem stroju, ki ga gosti OpenAI, z naslednjimi lastnostmi:
- Omrežje je privzeto zaprto: ni odhodnih zahtev, razen za izrecno odprt seznam dovoljenih domen (glej spodaj)
- Kratka življenjska doba: zabojnik poteče po 20 minutah nedejavnosti in vse, kar je v njem, je nato izbrisano
- Omejen pomnilnik: privzeto 1 GB, ali 4, 16 oziroma 64 GB na zahtevo (
memory_limit), pri čemer ima vsaka stopnja svojo ceno
from openai import OpenAI
client = OpenAI()
# Brez seznama dovoljenih domen prenos ne bo uspel: ni dostopa do omrežja
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"}}]
)
# Model bo pojasnil, da dostop do omrežja ni na voljo
print(response.output_text)
Kaj je na voljo
Prednameščene knjižnice
OpenAI ne objavlja uradnega seznama paketov v zabojniku in ta se s časom spreminja. Raziskava, ki jo je novembra 2025 objavil razvijalec na forumu OpenAI, je naštela 389 paketov, vključno s pričakovanimi knjižnicami za analizo: pandas, numpy, scipy in statsmodels za podatke; matplotlib, seaborn in plotly za vizualizacijo; Pillow za slike; sympy za simbolno matematiko; openpyxl za Excel. Namesto da bi ugibali, naj model na začetku projekta naredi popis:
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)
Različice so prav tako pomembne kot imena: ista raziskava je pokazala pandas 1.5.3, kar je pred različico pandas 2.0. Če vaša obdelava temelji na nedavni funkciji, pred gradnjo preverite, ali obstaja.
Datotečni sistem
Koda bere in piše datoteke znotraj zabojnika. Datoteke, ki jih ustvari model, so navedene v njegovem odgovoru in jih prenesete z uporabo funkcij fichiers_generes in telecharger iz lekcije 10:
# Model lahko ustvari datoteke znotraj zabojnika
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)
Kaj je omejeno
Dostop do omrežja
Zabojnik privzeto nima odhodnega dostopa: ni pip install, ni klicev API-ja, ni prenosov. To je najbolj strukturna omejitev in je namerna: generirana koda ne more ničesar poslati nikamor. Kar vaša obdelava potrebuje, mora biti prisotno v zabojniku ali pa to naložite vi – in če so podatki na spletu, jih bo orodje za spletno iskanje pogosto pridobilo namesto vas.
# Brez seznama dovoljenih domen (privzeti primer) je nemogoče:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (ni prenosov)
# - Dostop do zunanjih API-jev
# - Pošiljanje e-pošte
Odpiranje dostopa obstaja, vendar se odloča na dveh ravneh. Skrbnik najprej v nadzorni plošči določi seznam dovoljenih domen za organizacijo; vsaka zahteva nato razglasi network_policy, ki ga lahko le še dodatno omeji – zahteva, ki zahteva domeno, ki ni na seznamu organizacije, ne uspe.
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"],
},
},
}],
)
Odpiranje domen ima svojo ceno in OpenAI to jasno navaja: to so vrata za izvoz podatkov prek vbrizgavanja pozivov (prompt injection). Pooblastite le zaupanja vredne domene, ki jih napadalec ne more uporabiti za prejemanje podatkov – in pazite na skupno gostovanje, kjer lahko kdor koli postavi strežnik, ki bo beležil vaše zahteve.
Trajnost med klici
Pomanjkanje trajnosti preseneti večino pri zaporednih klicih: DataFrame, naložen v prvem klicu, v drugem ne obstaja več. Točno pravilo je odvisno od načina auto: ustvari nov zabojnik, razen če kontekst modela že vsebuje klic Code Interpreter, katerega zabojnik je še aktiven – v tem primeru ga ponovno uporabi. Dva neodvisna klica torej delujeta vsak v svojem, medtem ko klic, povezan s prejšnjim (z previous_response_id), najde svojega, če ta ni potekel. Znotraj enega samega klica si več izvršitev kode deli isto sejo.
# Prvi klic: ustvari datoteko
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"}}]
)
# Drugi klic, neodvisen od prvega: nov zabojnik
response2 = client.responses.create(
model="gpt-5.6-terra",
input="Read the file created previously",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Napaka: datoteka ni najdena
Če želite rezultate ohraniti med klici, ne da bi bili odvisni od konteksta, poskrbite, da delujejo v istem zabojniku. Ustvarite ga izrecno z API-jem za zabojnike in njegov ID posredujte vsakemu klicu: datoteke, ki jih ustvari en korak, ostanejo na voljo za naslednjega. Privzeto poteče po 20 minutah nedejavnosti in njegovi podatki so nato trajno izgubljeni: prenesite, kar želite obdržati, in ga nato sami izbrišite.
def pipeline_avec_persistance(etapes: list[str]) -> list:
"""Executes successive steps in the same container."""
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)
# After downloading useful files (Lesson 10)
client.containers.delete(conteneur.id)
return resultats
Ustvarjenih datotek ne vračajte kot input_file: njihovi ID-ji (cfile_…) se nanašajo na datoteke v zabojniku, ne na datoteke API-ja Files.
Pomnilnik in zahtevna obdelava
Dokumentacija ne objavlja največjega časa izvajanja; konkretna omejitev je pomnilnik zabojnika, izbran ob ustvarjanju in veljaven za celotno njegovo življenje. Za veliko datoteko izberite ustrezno stopnjo in poskrbite za razdelitev dela. Poleg tega – treniranje modelov, obsežni izračuni – morate uporabiti svojo infrastrukturo, zabojnik pa ostaja orodje za interaktivno analizo.
# Vzorec za zahtevno obdelavo: več pomnilnika, razdeljeno delo
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."
)
Varnost podatkov
Občutljivi podatki
Podatki, kopirani v zabojnik, so izbrisani, ko ta poteče ali je izbrisan. To ne velja za datoteko, naloženo prek API-ja Files: ta ostane tam, dokler je ne izbrišete, razen če nastavite potek veljavnosti (expires_after, med eno uro in tridesetimi dnevi). In razmislek o skladnosti se tu ne konča: vaši podatki so zapustili vašo infrastrukturo, da jih obdela tretja stran. Psevdonimizacija pred pošiljanjem stane nekaj vrstic in zmanjša količino podatkov, ki zapustijo sistem – saj identifikator stranke, ki nikoli ne zapusti vašega sistema, ne more predstavljati težave.
Ključirani hash (HMAC) zagotavlja stabilne psevdonime od ene pošiljatve do druge, ki jih brez ključa nihče ne more povezati z izvirnimi vrednostmi. Po splošni uredbi o varstvu podatkov (GDPR) rezultat ostaja psevdonimizirani osebni podatek, ne anonimen: ključ mora ostati pri vas.
import hashlib
import hmac
import os
import pandas as pd
CLE = os.environ["CLE_PSEUDONYMISATION"].encode() # skrivni ključ, shranjen zunaj kode
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]):
"""Pseudonymizes data before sending to Code Interpreter."""
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)
# Pošlji z samodejnim potekom veljavnosti po eni uri
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) # brez čakanja na potek veljavnosti
return response.output_text
Generirana koda
Izolacija ščiti vaš sistem, ne pa tudi pravilnosti rezultata: koda se izvaja pri OpenAI, v zabojniku za enkratno uporabo, in se nikoli ne dotakne vaših strojev. Tveganje se premakne na to, kaj storite z njenimi izhodi. Če kodo pridobite, da bi jo zagnali na svoji strani, jo pregledajte kot kodo tretje strani. In če ima zabojnik seznam dovoljenih domen, imejte v mislih, da lahko zlonamerna datoteka vsebuje navodila, ki model spodbudijo k pošiljanju podatkov na te domene.
Obravnava napak pri izvajanju
Koda lahko v sandboxu odpove. Model se običajno poskusi popraviti:
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."
)
# Model izvede kodo, zazna LinAlgError,
# nato pojasni, da je matrika singularna, in predlaga
# Moore-Penrosovo pseudoinverzno matriko
Najboljše prakse
# 1. Bodite specifični v svojih navodilih
# Slabo:
input_vague = "Analyze this data"
# Dobro:
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. Zahtevajte komentirano kodo
instructions = "Comment each step of the code. Display intermediate results."
# 3. Obravnava velikih datotek
instructions_lot = ("If the file exceeds 100,000 lines, "
"work on a representative sample of 10,000 lines "
"and indicate this in your response.")
Ključne ugotovitve
- Zabojnik je izoliran: omrežje je privzeto zaprto, pomnilnik omejen, potek veljavnosti po 20 minutah nedejavnosti
- OpenAI ne objavlja seznama paketov: naj model naredi popis
- Seznam dovoljenih domen se odpre na dveh ravneh (organizacija, nato zahteva) in izpostavlja tveganju izvoza podatkov: vanj vključite le zaupanja vredne domene
- Za zaporedne korake ponovno uporabite isti zabojnik (
client.containers.create, nato njegov ID pri vsakem klicu) in ga na koncu izbrišite - Pred pošiljanjem psevdonimizirajte občutljive podatke in po uporabi izbrišite naložene datoteke
- Model obravnava napake pri izvajanju in se poskuša sam popraviti