Salt la conținutul principal
Română— Alege o limbă
Meniu

Sandboxing și limite de securitate

Lecția 11 din 20 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Sandboxing și limite de securitate
  2. Arhitectura Sandbox-ului
  3. Ce este disponibil
  4. Ce este limitat
  5. Securitatea datelor
  6. Gestionarea erorilor de execuție
  7. Cele mai bune practici
  8. Puncte cheie

Actualizat la 2 noiembrie 2026 pe baza documentației OpenAI: instrumentul Code Interpreter necesită acum un parametru container (adăugat în toate exemplele). Rețeaua containerului, închisă implicit, poate fi deschisă acum către o listă de domenii permise (allowlist). Reguli de ciclu de viață al containerului (memorie, expirare, reutilizare) urmează ghidul oficial. Fișierele atașate unui mesaj sunt încărcate cu scopul user_data, așa cum recomandă OpenAI pentru intrările modelului. Surse: Code Interpreter · Container Network Access · Containers API · Files API.

Sandboxing și limite de securitate

Limitele sandbox-ului nu sunt erori de ocolit: ele sunt proprietățile care fac acceptabilă executarea codului generat. Un mediu izolat de rețea, cu o durată de viață scurtă și limite de resurse, nu poate exfiltra datele dumneavoastră, nu lasă stări persistente la infinit și nu consumă resurse fără limită.

Cunoașterea acestor limite din start vă scutește de depanarea imposibilului. Cele trei întrebări recurente—de ce eșuează pip install, de ce a dispărut fișierul meu între apeluri, de ce se blochează procesarea unui fișier mare—au toate răspuns mai jos, și niciuna nu reprezintă un bug.

Arhitectura Sandbox-ului

Code Interpreter rulează codul într-un container, o mașină virtuală izolată găzduită de OpenAI, cu următoarele proprietăți:

  • Rețea închisă implicit: nicio cerere outbound, cu excepția unei liste explicite de domenii permise (vezi mai jos)
  • Durată de viață scurtă: containerul expiră după 20 de minute de inactivitate, iar tot ce se află în interior este șters
  • Memorie limitată: 1 GB implicit, sau 4, 16 ori 64 GB la cerere (memory_limit), fiecare nivel având propria sa tarifare
from openai import OpenAI

client = OpenAI()

# Fără o listă de domenii permise, descărcarea va eșua: fără acces la rețea
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"}}]
)

# Modelul va explica faptul că accesul la rețea nu este disponibil
print(response.output_text)

Ce este disponibil

Biblioteci preinstalate

OpenAI nu publică o listă oficială a pachetelor din container, iar aceasta se schimbă în timp. Un sondaj publicat de un dezvoltator pe forumul OpenAI în noiembrie 2025 număra 389 de pachete, inclusiv bibliotecile așteptate pentru analiză: pandas, numpy, scipy și statsmodels pentru date; matplotlib, seaborn și plotly pentru vizualizare; Pillow pentru imagini; sympy pentru matematică simbolică; openpyxl pentru Excel. În loc să presupuneți, cereți modelului să le inventarieze la începutul unui proiect:

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)

Versiunile contează la fel de mult ca numele: același sondaj arăta pandas 1.5.3, care precede pandas 2.0. Dacă procesarea dumneavoastră depinde de o funcție recentă, verificați existența acesteia înainte de a construi pe ea.

Sistemul de fișiere

Codul citește și scrie fișiere în interiorul containerului. Fișierele create de model sunt citate în răspunsul său și descărcate folosind funcțiile fichiers_generes și telecharger din Lecția 10:

# Modelul poate crea fișiere în interiorul containerului
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)

Ce este limitat

Accesul la rețea

Implicit, containerul nu are acces outbound: nici pip install, nici apeluri API, nici descărcări. Aceasta este cea mai structurală limită și este intenționată: codul generat nu poate trimite nimic nicăieri. Ceea ce are nevoie procesarea dumneavoastră trebuie să fie prezent în container sau încărcat de dumneavoastră—iar dacă datele sunt online, instrumentul de căutare web le va prelua adesea în schimb.

# Fără o listă de domenii permise (cazul implicit), imposibil:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (fără descărcări)
# - Acces la API-uri externe
# - Trimiterea de e-mailuri

Deschiderea accesului există, dar se decide la două niveluri. Un administrator definește mai întâi lista de domenii permise a organizației în dashboard; fiecare cerere declară apoi o network_policy care o poate doar restricționa further—o cerere care solicită un domeniu absent din lista organizației eșuează.

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"],
            },
        },
    }],
)

Deschiderea domeniilor are un cost, iar OpenAI o spune clar: este o ușă pentru exfiltrarea datelor prin injectare de prompturi. Autorizați doar domenii de încredere pe care un atacant nu le poate folosi pentru a primi date—și feriți-vă de găzduirea partajată, unde oricine poate ridica un server care vă va înregistra cererile.

Persistența între apeluri

Lipsa persistenței îi surprinde pe cei mai mulți atunci când înlănțuie apeluri: DataFrame-ul încărcat în primul apel nu mai există în al doilea. Regula exactă depinde de modul auto: acesta creează un container nou, cu excepția cazului în care contextul modelului conține deja un apel Code Interpreter al cărui container este încă activ—atunci îl reutilizează. Două apeluri independente lucrează deci fiecare în al său, în timp ce un apel înlănțuit cu cel precedent (cu previous_response_id) îl găsește pe al său dacă nu a expirat. În cadrul unui singur apel, multiple execuții de cod partajează aceeași sesiune.

# Primul apel: creează un fișier
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"}}]
)

# Al doilea apel, independent de primul: container nou
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Eroare: fișierul nu a fost găsit

Pentru a păstra rezultatele între apeluri fără a depinde de context, faceți-le să lucreze în același container. Creați-l explicit cu API-ul Containers și transmiteți ID-ul său fiecărui apel: fișierele produse de un pas rămân disponibile pentru următorul. Implicit, acesta expiră după 20 de minute de inactivitate, iar datele sale se pierd definitiv: descărcați ceea ce doriți să păstrați, apoi ștergeți-l dumneavoastră.

def pipeline_avec_persistance(etapes: list[str]) -> list:
    """Execută pași succesivi în același 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)

    # După descărcarea fișierelor utile (Lecția 10)
    client.containers.delete(conteneur.id)
    return resultats

Nu returnați fișierele generate ca input_file: ID-urile lor (cfile_…) se referă la fișiere din container, nu la fișiere din API-ul Files.

Memorie și procesare intensă

Documentația nu publică o durată maximă de execuție; limita concretă este memoria containerului, aleasă la creare și valabilă pe întreaga sa durată de viață. Pentru un fișier mare, alegeți un nivel adecvat și faceți ca munca să fie divizată. Dincolo de aceasta—antrenarea modelelor, calcul masiv—trebuie să vă folosiți propria infrastructură, containerul rămânând instrumentul pentru analiza interactivă.

# Model pentru procesare intensă: mai multă memorie, muncă divizată
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."
)

Securitatea datelor

Date sensibile

Datele copiate în container sunt șterse când acesta expiră sau este șters. Acest lucru nu este valabil pentru un fișier încărcat prin API-ul Files: acesta rămâne acolo până îl ștergeți dumneavoastră, cu excepția cazului în care setați o expirare (expires_after, între o oră și treizeci de zile). Iar raționamentul de conformitate nu se oprește aici: datele dumneavoastră au părăsit infrastructura pentru a fi procesate de o terță parte. Pseudonimizarea înainte de trimitere costă câteva linii și reduce ceea ce iese—deoarece un ID de client care nu iese niciodată nu poate pune nicio problemă.

Un hash cu cheie (HMAC) oferă pseudonime stabile de la o trimitere la alta, pe care nimeni nu le poate lega de valorile originale fără cheie. Conform GDPR, rezultatul rămâne date personale pseudonimizate, nu anonime: cheia trebuie să rămână la dumneavoastră.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # secret păstrat în afara codului


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]):
    """Pseudonimizează datele înainte de trimiterea către 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)

    # Trimitere cu expirare automată după o oră
    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)  # fără a aștepta expirarea
    return response.output_text

Cod generat

Izolarea vă protejează sistemul, nu corectitudinea rezultatului: codul rulează la OpenAI, într-un container efemer, și nu atinge niciodată mașinile dumneavoastră. Riscul se mută asupra a ceea ce faceți cu ieșirile sale. Dacă preluați codul pentru a-l rula la dumneavoastră, revizuiți-l ca pe un cod terț. Iar dacă containerul are o listă de domenii permise, țineți cont că un fișier malițios poate conține instrucțiuni care împing modelul să trimită date către acele domenii.

Gestionarea erorilor de execuție

Codul poate eșua în sandbox. Modelul încearcă în general să se corecteze:

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."
)

# Modelul execută codul, detectează LinAlgError,
# apoi explică faptul că matricea este singulară și propune
# pseudoinversa Moore-Penrose

Cele mai bune practici

# 1. Fiți specifici în instrucțiuni
# Rău:
input_vague = "Analyze this data"

# Bun:
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. Solicitați cod comentat
instructions = "Comment each step of the code. Display intermediate results."

# 3. Gestionați fișierele mari
instructions_lot = ("If the file exceeds 100,000 lines, "
                   "work on a representative sample of 10,000 lines "
                   "and indicate this in your response.")

Puncte cheie

  • Containerul este izolat: rețea închisă implicit, memorie limitată, expirare după 20 de minute de inactivitate
  • OpenAI nu publică lista de pachete: cereți modelului să o inventarieze
  • O listă de domenii permise se deschide la două niveluri (organizație, apoi cerere) și expune la exfiltrare: puneți acolo doar domenii de încredere
  • Pentru a înlănțui pași, reutilizați același container (client.containers.create, apoi ID-ul său la fiecare apel) și ștergeți-l la final
  • Pseudonimizați datele sensibile înainte de trimitere și ștergeți fișierele încărcate după utilizare
  • Modelul gestionează erorile de execuție și încearcă să se autocorecteze