Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Sandboxing en beveiligingslimieten

Les 11 van 20 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Sandboxing en beveiligingslimieten
  2. Sandbox-architectuur
  3. Wat beschikbaar is
  4. Wat beperkt is
  5. Databeveiliging
  6. Uitvoeringsfouten afhandelen
  7. Best practices
  8. Belangrijkste punten

Bijgewerkt op 2 november 2026 op basis van OpenAI-documentatie: de Code Interpreter-tool vereist nu een container-parameter (toegevoegd aan alle voorbeelden). Het containernetwerk, standaard gesloten, kan nu worden geopend voor een lijst met toegestane domeinen. Regels voor de levenscyclus van containers (geheugen, verloop, hergebruik) volgen de officiële handleiding. Bestanden die aan een bericht zijn gekoppeld, worden geüpload met het doel user_data, zoals aanbevolen door OpenAI voor modelinvoer. Bronnen: Code Interpreter · Container Network Access · Containers API · Files API.

Sandboxing en beveiligingslimieten

Sandbox-limieten zijn geen bugs om mee te werken: het zijn de eigenschappen die het uitvoeren van gegenereerde code acceptabel maken. Een netwerkgelisoleerde omgeving met een korte levensduur en resource-limieten kan uw gegevens niet exfiltreren, geen staat oneindig laten rondslingeren of resources zonder limiet verbruiken.

Als u deze limieten vooraf kent, bespaart u uzelf het debuggen van het onmogelijke. De drie terugkerende vragen—waarom pip install mislukt, waarom mijn bestand tussen oproepen verdwijnt, waarom mijn verwerking crasht bij een groot bestand—hebben hieronder allemaal een antwoord, en geen ervan zijn bugs.

Sandbox-architectuur

Code Interpreter voert code uit in een container, een geïsoleerde virtuele machine gehost door OpenAI, met de volgende eigenschappen:

  • Netwerk standaard gesloten: geen uitgaande verzoeken, behalve voor een expliciet geopende lijst met toegestane domeinen (zie hieronder)
  • Korte levensduur: de container verloopt na 20 minuten inactiviteit, en alles erin wordt vervolgens gewist
  • Beperkt geheugen: standaard 1 GB, of 4, 16 of 64 GB op verzoek (memory_limit), waarbij elke tier zijn eigen prijsstelling heeft
from openai import OpenAI

client = OpenAI()

# Zonder allowlist zal de download mislukken: geen netwerktoegang
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"}}]
)

# Het model zal uitleggen dat netwerktoegang niet beschikbaar is
print(response.output_text)

Wat beschikbaar is

Vooraf geïnstalleerde bibliotheken

OpenAI publiceert geen officiële lijst van containerpakketten, en deze verandert in de loop der tijd. Een enquête gepubliceerd door een ontwikkelaar op het OpenAI-forum in november 2025 telde 389 pakketten, inclusief de verwachte bibliotheken voor analyse: pandas, numpy, scipy en statsmodels voor data; matplotlib, seaborn en plotly voor visualisatie; Pillow voor afbeeldingen; sympy voor symbolische wiskunde; openpyxl voor Excel. Ga er niet van uit dat iets aanwezig is; laat het model ze inventariseren aan het begin van een project:

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)

Versies zijn net zo belangrijk als namen: dezelfde enquête toonde pandas 1.5.3, wat dateert van vóór pandas 2.0. Als uw verwerking afhankelijk is van een recente functie, verifieer dan dat deze bestaat voordat u erop voortbouwt.

Bestandssysteem

Code leest en schrijft bestanden binnen de container. Bestanden die het model maakt, worden geciteerd in zijn reactie en gedownload met behulp van de functies fichiers_generes en telecharger uit Les 10:

# Het model kan bestanden maken binnen de container
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)

Wat beperkt is

Netwerktoegang

Standaard heeft de container geen uitgaande toegang: geen pip install, geen API-oproepen, geen downloads. Dit is de meest structurele limiet, en het is opzettelijk: gegenereerde code kan niets naar ergens verzenden. Wat uw verwerking nodig heeft, moet aanwezig zijn in de container of door u worden geüpload—en als de data online staat, haalt de web search-tool deze vaak op in plaats daarvan.

# Zonder allowlist (standaardgeval), onmogelijk:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (geen downloads)
# - Toegang tot externe API's
# - E-mails verzenden

Toegang openen bestaat, maar wordt op twee niveaus beslist. Een beheerder definieert eerst de allowlist van de organisatie in het dashboard; elk verzoek declareert vervolgens een network_policy die deze alleen verder kan beperken—een verzoek dat vraagt om een domein dat afwezig is op de lijst van de organisatie, mislukt.

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

Het openen van domeinen heeft een kostprijs, en OpenAI stelt het duidelijk: het is een deur voor data-exfiltratie via prompt-injectie. Autoriseer alleen vertrouwde domeinen die een aanvaller niet kan gebruiken om gegevens te ontvangen—en pas op voor shared hosting, waar iedereen een server kan opzetten die uw verzoeken logt.

Persistentie tussen oproepen

Het gebrek aan persistentie verrast de meesten bij het ketenen van oproepen: de DataFrame geladen in de eerste oproep bestaat niet meer in de tweede. De exacte regel hangt af van de auto-modus: deze maakt een nieuwe container, tenzij de modelcontext al een Code Interpreter-oproep bevat waarvan de container nog actief is—die wordt dan hergebruikt. Twee onafhankelijke oproepen werken daarom elk in hun eigen omgeving, terwijl een oproep die geketend is aan de vorige (met previous_response_id) zijn eigen container vindt als deze niet is verlopen. Binnen één enkele oproep delen meerdere code-uitvoeringen wel dezelfde sessie.

# Eerste oproep: maakt een bestand aan
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"}}]
)

# Tweede oproep, onafhankelijk van de eerste: nieuwe container
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Fout: bestand niet gevonden

Om resultaten tussen oproepen te behouden zonder afhankelijk te zijn van context, laat u ze werken in dezelfde container. Maak deze expliciet aan met de Containers API en geef de ID door aan elke oproep: bestanden geproduceerd door één stap blijven beschikbaar voor de volgende. Standaard verloopt deze na 20 minuten inactiviteit en gaan de gegevens permanent verloren: download wat u wilt bewaren en verwijder het vervolgens zelf.

def pipeline_avec_persistance(etapes: list[str]) -> list:
    """Voert opeenvolgende stappen uit in dezelfde 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)

    # Na het downloaden van nuttige bestanden (Les 10)
    client.containers.delete(conteneur.id)
    return resultats

Geef gegenereerde bestanden niet terug als input_file: hun ID’s (cfile_…) verwijzen naar containerbestanden, niet naar Files API-bestanden.

Geheugen en zware verwerking

De documentatie publiceert geen maximale uitvoeringsduur; de concrete limiet is het geheugen van de container, gekozen bij creatie en geldig voor de hele levensduur. Kies voor een groot bestand een passende tier en laat het werk opsplitsen. Daarbovenop—modeltraining, massale berekeningen—moet u uw eigen infrastructuur gebruiken, waarbij de container het hulpmiddel blijft voor interactieve analyse.

# Patroon voor zware verwerking: meer geheugen, werk opsplitsen
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."
)

Databeveiliging

Gevoelige gegevens

Gegevens die in de container worden gekopieerd, worden gewist wanneer deze verloopt of wordt verwijderd. Dit geldt niet voor een bestand dat via de Files API is geüpload: dat blijft staan totdat u het verwijdert, tenzij u een verloop instelt (expires_after, tussen één uur en dertig dagen). En de compliance-redenering stopt daar niet: uw gegevens hebben uw infrastructuur verlaten om door een derde te worden verwerkt. Pseudonimiseren voordat verzenden kost een paar regels code en vermindert wat er de deur uit gaat—want een klant-ID die nooit vertrekt, kan geen probleem vormen.

Een keyed hash (HMAC) geeft stabiele pseudoniemen van de ene verzending naar de volgende, die niemand kan linken aan originele waarden zonder de sleutel. Onder de AVG blijft het resultaat gepseudonimiseerde persoonsgegevens, niet anoniem: de sleutel moet bij u blijven.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # geheim buiten code bewaard


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]):
    """Pseudonimiseert gegevens voordat ze naar Code Interpreter worden verzonden."""
    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)

    # Verzenden met automatische verloop na één uur
    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)  # zonder te wachten op verloop
    return response.output_text

Gegenereerde code

Isolatie beschermt uw systeem, niet de juistheid van het resultaat: de code draait bij OpenAI, in een wegwerpcontainer, en raakt nooit uw machines. Het risico verschuift naar wat u met de uitvoer doet. Als u de code ophaalt om deze aan uw kant uit te voeren, bekijk deze dan als code van derden. En als de container een allowlist heeft, houd er dan rekening mee dat een kwaadaardig bestand instructies kan bevatten die het model ertoe aanzetten gegevens naar die domeinen te sturen.

Uitvoeringsfouten afhandelen

Code kan mislukken in de sandbox. Het model probeert dit doorgaans te corrigeren:

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

# Het model voert de code uit, detecteert de LinAlgError,
# legt vervolgens uit dat de matrix singulier is en stelt
# de Moore-Penrose pseudoinverse voor

Best practices

# 1. Wees specifiek in uw instructies
# Slecht:
input_vague = "Analyze this data"

# Goed:
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. Vraag om becommentarieerde code
instructions = "Comment each step of the code. Display intermediate results."

# 3. Handel grote bestanden af
instructions_lot = ("If the file exceeds 100,000 lines, "
                   "work on a representative sample of 10,000 lines "
                   "and indicate this in your response.")

Belangrijkste punten

  • De container is geïsoleerd: netwerk standaard gesloten, geheugen beperkt, verloop na 20 minuten inactiviteit
  • OpenAI publiceert de pakketlijst niet: laat het model deze inventariseren
  • Een domein-allowlist opent op twee niveaus (organisatie, vervolgens verzoek) en stelt bloot aan exfiltratie: zet daar alleen vertrouwde domeinen op
  • Om stappen te ketenen, hergebruikt u dezelfde container (client.containers.create, vervolgens de ID bij elke oproep) en verwijdert u deze aan het einde
  • Pseudonimiseer gevoelige gegevens voordat verzenden en verwijder geüploade bestanden na gebruik
  • Het model handelt uitvoeringsfouten af en probeert zichzelf te corrigeren