Sandboxing und Sicherheitsgrenzen

Aktualisiert am 2. November 2026 basierend auf der OpenAI-Dokumentation: Das Tool Code Interpreter erfordert nun einen container-Parameter (in allen Beispielen hinzugefügt). Das standardmäßig geschlossene Netzwerk des Containers kann nun auf eine erlaubte Liste von Domains geöffnet werden. Die Regeln für den Lebenszyklus von Containern (Speicher, Ablaufzeit, Wiederverwendung) folgen dem offiziellen Leitfaden. Dateien, die einer Nachricht angehängt werden, werden mit dem Zweck user_data hochgeladen, wie von OpenAI für Modell-Eingaben empfohlen. Quellen: Code Interpreter · Container Network Access · Containers API · Files API.

Sandboxing und Sicherheitsgrenzen

Sandbox-Grenzen sind keine Fehler, die man umgehen muss: Sie sind die Eigenschaften, die den Betrieb generierten Codes akzeptabel machen. Eine netzwerkisolierte Umgebung mit kurzer Lebensdauer und Ressourcenbegrenzungen kann Ihre Daten nicht ausspähen, Zustände nicht unbegrenzt liegen lassen oder Ressourcen ohne Limit verbrauchen.

Das Wissen um diese Grenzen im Voraus spart Ihnen das Debuggen des Unmöglichen. Die drei wiederkehrenden Fragen – warum pip install fehlschlägt, warum meine Datei zwischen Aufrufen verschwunden ist und warum meine Verarbeitung bei großen Dateien abstürzt – haben unten Antworten, und es handelt sich bei keiner davon um einen Fehler.

Sandbox-Architektur

Code Interpreter führt Code in einem Container aus, einer isolierten virtuellen Maschine, die von OpenAI gehostet wird, mit folgenden Eigenschaften:

• Netzwerk standardmäßig geschlossen: keine ausgehenden Anfragen, außer auf einer explizit geöffneten erlaubten Liste von Domains (siehe unten)
• Kurze Lebensdauer: Der Container läuft nach 20 Minuten Inaktivität ab, und alles darin wird dann gelöscht
• Begrenzter Speicher: Standardmäßig 1 GB, oder 4, 16 oder 64 GB auf Anfrage (memory_limit), wobei jede Stufe eine eigene Preisgestaltung hat

from openai import OpenAI

client = OpenAI()

# Ohne eine erlaubte Liste wird der Download fehlschlagen: kein Netzwerkzugriff
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"}}]
)

# Das Modell wird erklären, dass Netzwerkzugriff nicht verfügbar ist
print(response.output_text)

Was verfügbar ist

Vorinstallierte Bibliotheken

OpenAI veröffentlicht keine offizielle Liste der Container-Pakete, und diese ändert sich im Laufe der Zeit. Eine von einem Entwickler auf dem OpenAI-Forum veröffentlichte Umfrage im November 2025 zählte 389 Pakete, einschließlich der erwarteten Bibliotheken für Analysen: pandas, numpy, scipy und statsmodels für Daten; matplotlib, seaborn und plotly für Visualisierung; Pillow für Bilder; sympy für symbolische Mathematik; openpyxl für Excel. Statt Annahmen zu treffen, lassen Sie das Modell die Pakete am Anfang eines Projekts inventarisieren:

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)

Versionen sind so wichtig wie Namen: Die gleiche Umfrage zeigte pandas 1.5.3, was vor pandas 2.0 liegt. Wenn Ihre Verarbeitung von einer neuen Funktion abhängt, überprüfen Sie, ob diese existiert, bevor Sie darauf aufbauen.

Dateisystem

Code liest und schreibt Dateien innerhalb des Containers. Dateien, die das Modell erstellt, werden in seiner Antwort zitiert und heruntergeladen, indem die Funktionen fichiers_generes und telecharger aus Lektion 10 verwendet werden:

# Das Modell kann Dateien innerhalb des Containers erstellen
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)

Was begrenzt ist

Netzwerkzugriff

Standardmäßig hat der Container keinen ausgehenden Zugriff: kein pip install, keine API-Aufrufe, keine Downloads. Dies ist die strukturellste Grenze, und sie ist beabsichtigt: generierter Code kann nichts irgendwohin senden. Was Ihre Verarbeitung benötigt, muss im Container vorhanden sein oder von Ihnen hochgeladen werden – und wenn die Daten online sind, wird das Web-Such-Tool oft diese stattdessen abrufen.

# Ohne eine erlaubte Liste (Standardfall): unmöglich:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (keine Downloads)
# - Zugriff auf externe APIs
# - Absenden von E-Mails

Das Öffnen des Zugriffs existiert, wird aber auf zwei Ebenen entschieden. Ein Administrator definiert zunächst die erlaubte Liste der Organisation im Dashboard; jede Anfrage erklärt dann eine network_policy, die diese nur weiter einschränken kann – eine Anfrage, die nach einer Domäne fragt, die nicht in der Liste der Organisation steht, schlägt fehl.

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

Das Öffnen von Domains hat einen Preis, und OpenAI stellt dies klar: Es ist eine Tür für Datenexfiltration durch Prompt-Injection. Autorisieren Sie nur vertrauenswürdige Domains, die ein Angreifer nicht nutzen kann, um Daten zu empfangen – und achten Sie auf Shared Hosting, wo jeder einen Server aufstellen kann, der Ihre Anfragen protokolliert.

Persistenz zwischen Aufrufen

Das Fehlen von Persistenz überrascht die meisten, wenn Aufrufe verkettet werden: der DataFrame, der im ersten Aufruf geladen wurde, existiert im zweiten nicht mehr. Die genaue Regel hängt vom auto-Modus ab: Es erstellt einen neuen Container, es sei denn, der Modell-Kontext enthält bereits einen Code-Interpreter-Aufruf, dessen Container noch aktiv ist – dann wird dieser wiederverwendet. Zwei unabhängige Aufrufe arbeiten daher jeweils in ihrem eigenen, während ein Aufruf, der an den vorherigen angehängt ist (mit previous_response_id), seinen eigenen findet, wenn dieser nicht abgelaufen ist. Innerhalb eines einzelnen Aufrufs teilen sich mehrere Code-Ausführungen dieselbe Sitzung.

# Erster Aufruf: erstellt eine Datei
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"}}]
)

# Zweiter Aufruf, unabhängig vom ersten: neuer Container
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Fehler: Datei nicht gefunden

Um Ergebnisse zwischen Aufrufen zu behalten, ohne vom Kontext abhängig zu sein, lassen Sie sie in demselben Container arbeiten. Erstellen Sie diesen explizit mit der Containers API und übergeben Sie seine ID an jeden Aufruf: Dateien, die von einem Schritt produziert werden, bleiben für den nächsten verfügbar. Standardmäßig läuft er nach 20 Minuten Inaktivität ab, und seine Daten werden dann endgültig gelöscht: Laden Sie das herunter, was Sie behalten möchten, und löschen Sie es selbst.

def pipeline_avec_persistance(etapes: list[str]) -> list:
    """Führt aufeinanderfolgende Schritte im selben Container aus."""
    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)

    # Nach dem Herunterladen nützlicher Dateien (Lektion 10)
    client.containers.delete(conteneur.id)
    return resultats

Geben Sie generierte Dateien nicht als input_file zurück: Ihre IDs (cfile_…) beziehen sich auf Container-Dateien, nicht auf Files-API-Dateien.

Speicher und schwere Verarbeitung

Die Dokumentation veröffentlicht keine maximale Ausführungszeit; die konkrete Grenze ist der Speicher des Containers, der bei der Erstellung gewählt wird und für dessen gesamten Lebenszyklus gilt. Für eine große Datei wählen Sie eine geeignete Stufe und lassen Sie die Arbeit aufteilen. Darüber hinaus – Modelltraining, massive Berechnungen – müssen Sie Ihre eigene Infrastruktur verwenden, wobei der Container das Werkzeug für die interaktive Analyse bleibt.

# Muster für schwere Verarbeitung: mehr Speicher, Arbeit aufteilen
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."
)

Datensicherheit

Sensible Daten

Daten, die in den Container kopiert werden, werden gelöscht, wenn dieser abläuft oder gelöscht wird. Dies gilt nicht für eine Datei, die über die Files API hochgeladen wurde: Sie bleibt dort, bis Sie sie löschen, es sei denn, Sie setzen eine Ablaufzeit (expires_after, zwischen einer Stunde und 30 Tagen). Und die Compliance-Begründung hört nicht hier auf: Ihre Daten haben Ihre Infrastruktur verlassen, um von einem Dritten verarbeitet zu werden. Die Pseudonymisierung vor dem Senden kostet nur wenige Zeilen und reduziert, was hinausgeht – denn eine Kunden-ID, die nie hinausgeht, kann kein Problem darstellen.

Ein keyed hash (HMAC) gibt stabile Pseudonyme von einem Senden zum nächsten, die niemand ohne den Schlüssel mit den ursprünglichen Werten verknüpfen kann. Gemäß der DSGVO bleibt das Ergebnis pseudonymisierte personenbezogene Daten, nicht anonym: Der Schlüssel muss bei Ihnen bleiben.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # Geheimnis, das außerhalb des Codes gehalten wird


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]):
    """Pseudonymisiert Daten vor dem Senden an 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)

    # Senden mit automatischem Ablauf nach einer Stunde
    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)  # ohne Warten auf Ablauf
    return response.output_text

Generierter Code

Isolierung schützt Ihr System, nicht die Korrektheit des Ergebnisses: Der Code läuft bei OpenAI in einem wegwerfbaren Container und berührt Ihre Maschinen nie. Das Risiko verschiebt sich zu dem, was Sie mit seinen Ausgaben tun. Wenn Sie den Code abrufen, um ihn auf Ihrem Ende auszuführen, überprüfen Sie ihn wie bei Code von Drittanbietern. Und wenn der Container eine erlaubte Liste hat, denken Sie daran, dass eine bösartige Datei Anweisungen enthalten kann, die das Modell dazu bringen, Daten an diese Domains zu senden.

Behandlung von Ausführungsfehlern

Code kann im Sandbox-Umfeld fehlschlagen. Das Modell versucht im Allgemeinen zu korrigieren:

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

# Das Modell führt den Code aus, erkennt den LinAlgError,
# erklärt dann, dass die Matrix singulär ist, und schlägt
# die Moore-Penrose-Pseudoinverse vor

Best Practices

# 1. Seien Sie in Ihren Anweisungen spezifisch
# Schlecht:
input_vague = "Analyze this data"

# Gut:
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. Fordern Sie kommentierten Code an
instructions = "Comment each step of the code. Display intermediate results."

# 3. Behandeln Sie große Dateien
instructions_lot = ("If the file exceeds 100,000 lines, "
                   "work on a representative sample of 10,000 lines "
                   "and indicate this in your response.")

Kernaussagen

• Der Container ist isoliert: Netzwerk standardmäßig geschlossen, Speicher begrenzt, Ablauf nach 20 Minuten Inaktivität
• OpenAI veröffentlicht die Paketliste nicht: Lassen Sie das Modell diese inventarisieren
• Eine Domänen-erlaubte Liste öffnet sich auf zwei Ebenen (Organisation, dann Anfrage) und exponiert für Exfiltration: Legen Sie nur vertrauenswürdige Domains dort
• Um Schritte zu verketteten, verwenden Sie denselben Container (client.containers.create, dann seine ID bei jedem Aufruf) und löschen Sie ihn am Ende
• Pseudonymisieren Sie sensible Daten vor dem Senden und löschen Sie hochgeladene Dateien nach der Verwendung
• Das Modell behandelt Ausführungsfehler und versucht zur Selbstkorrektur