Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Sandboxing og sikkerhedsgrænser

Lektion 11 af 20 Opdateret 2. november 2026 Udvikler
På denne side
  1. Sandboxing og sikkerhedsgrænser
  2. Sandbox-arkitektur
  3. Hvad er tilgængeligt
  4. Hvad er begrænset
  5. Datasikkerhed
  6. Håndtering af eksekveringsfejl
  7. Bedste praksis
  8. Vigtige pointer

Opdateret 2. november 2026 baseret på OpenAI-dokumentation: Code Interpreter-værktøjet kræver nu en container-parameter (tilføjet til alle eksempler). Containernettetværket, der som standard er lukket, kan nu åbnes for en tilladelsesliste over domæner. Regler for containerlevetid (hukommelse, udløb, genbrug) følger den officielle guide. Filer, der er vedhæftet en besked, uploades med formålet user_data, som anbefalet af OpenAI til modelinput. Kilder: Code Interpreter · Container Network Access · Containers API · Files API.

Sandboxing og sikkerhedsgrænser

Sandbox-begrænsninger er ikke fejl, du skal finde udenom: det er de egenskaber, der gør det acceptabelt at køre genereret kode. Et netværksisoleret miljø med kort levetid og ressourcegrænser kan ikke eksfiltrere dine data, efterlade tilstand liggende på ubestemt tid eller forbruge ressourcer uden grænser.

At kende disse grænser på forhånd sparer dig for at fejlsøge det umulige. De tre tilbagevendende spørgsmål – hvorfor pip install fejler, hvorfor min fil forsvandt mellem kald, og hvorfor min behandling crascher på en stor fil – har alle svar nedenfor, og ingen af dem er fejl.

Sandbox-arkitektur

Code Interpreter kører kode i en container, en isoleret virtuel maskine hostet af OpenAI, med følgende egenskaber:

  • Netværk lukket som standard: ingen udgående anmodninger, undtagen for en eksplicit åbnet tilladelsesliste over domæner (se nedenfor)
  • Kort levetid: containeren udløber efter 20 minutters inaktivitet, og alt indeni slettes derefter
  • Begrænset hukommelse: 1 GB som standard, eller 4, 16 eller 64 GB på anmodning (memory_limit), hvor hvert niveau har sin egen prissætning
from openai import OpenAI

client = OpenAI()

# Uden en tilladelsesliste vil downloadet fejle: ingen netværksadgang
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"}}]
)

# Modellen vil forklare, at netværksadgang ikke er tilgængelig
print(response.output_text)

Hvad er tilgængeligt

Forinstallerede biblioteker

OpenAI offentliggør ikke en officiel liste over containerpakker, og den ændrer sig over tid. En undersøgelse offentliggjort af en udvikler på OpenAI-forummet i november 2025 talte 389 pakker, herunder de forventede biblioteker til analyse: pandas, numpy, scipy og statsmodels til data; matplotlib, seaborn og plotly til visualisering; Pillow til billeder; sympy til symbolsk matematik; openpyxl til Excel. I stedet for at antage noget, bør du få modellen til at inventarisere dem ved starten af et projekt:

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)

Versioner er lige så vigtige som navne: den samme undersøgelse viste pandas 1.5.3, som er ældre end pandas 2.0. Hvis din behandling afhænger af en ny funktion, skal du verificere, at den eksisterer, før du bygger videre på den.

Filsystem

Kode læser og skriver filer inde i containeren. Filer, som modellen opretter, citeres i dens svar og downloades ved hjælp af funktionerne fichiers_generes og telecharger fra lektion 10:

# Modellen kan oprette filer inde i containeren
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)

Hvad er begrænset

Netværksadgang

Som standard har containeren ingen udgående adgang: ingen pip install, ingen API-kald, ingen downloads. Dette er den mest strukturelle begrænsning, og den er tilsigtet: genereret kode kan ikke sende noget som helst nogen steder hen. Det, din behandling har brug for, skal være til stede i containeren eller uploades af dig – og hvis dataene er online, vil web search-værktøjet ofte hente dem i stedet.

# Uden en tilladelsesliste (standardtilfælde), umuligt:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (ingen downloads)
# - Adgang til eksterne API'er
# - Afsendelse af e-mails

Der findes mulighed for at åbne adgang, men det afgøres på to niveauer. En administrator definerer først organisationens tilladelsesliste i dashboardet; hver anmodning erklærer derefter en network_policy, der kun kan indskrænke den yderligere – en anmodning, der beder om et domæne, som mangler på organisationens liste, vil fejle.

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

At åbne domæner har en omkostning, og OpenAI siger det rent ud: det er en dør til dataeksfiltrering via prompt injection. Autorisér kun betroede domæner, som en angriber ikke kan bruge til at modtage data – og pas på shared hosting, hvor hvem som helst kan opsætte en server, der vil logge dine anmodninger.

Persistens mellem kald

Manglen på persistens overrasker de fleste, når man kæder kald sammen: DataFrame’en indlæst i det første kald eksisterer ikke længere i det andet. Den nøjagtige regel afhænger af auto-tilstanden: den opretter en ny container, medmindre modelkonteksten allerede indeholder et Code Interpreter-kald, hvis container stadig er aktiv – i så fald genbruges den. To uafhængige kald arbejder derfor hver i sin egen, mens et kald kædet til det foregående (med previous_response_id) finder sin egen, hvis den ikke er udløbet. Inden for et enkelt kald deler flere kodeeksekveringer dog den samme session.

# Første kald: opretter en fil
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"}}]
)

# Andet kald, uafhængigt af det første: ny container
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Fejl: fil ikke fundet

For at beholde resultater mellem kald uden at afhænge af kontekst, skal du få dem til at arbejde i den samme container. Opret den eksplicit med Containers API og send dens ID til hvert kald: filer produceret af ét trin forbliver tilgængelige for det næste. Som standard udløber den efter 20 minutters inaktivitet, og dens data går derefter permanent tabt: download det, du vil beholde, og slet den derefter selv.

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)

    # Efter download af nyttige filer (Lektion 10)
    client.containers.delete(conteneur.id)
    return resultats

Returnér ikke genererede filer som input_file: deres ID’er (cfile_…) refererer til containerfiler, ikke Files API-filer.

Hukommelse og tung behandling

Dokumentationen offentliggør ikke en maksimal eksekveringsvarighed; den konkrete grænse er containerens hukommelse, valgt ved oprettelse og gældende for hele dens levetid. Til en stor fil skal du vælge et passende niveau og få arbejdet opdelt. Derudover – modeltræning, massiv beregning – skal du bruge din egen infrastruktur, hvor containeren forbliver værktøjet til interaktiv analyse.

# Mønster for tung behandling: mere hukommelse, opdelt arbejde
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."
)

Datasikkerhed

Følsomme data

Data kopieret ind i containeren slettes, når den udløber eller slettes. Dette gælder ikke for en fil uploadet via Files API: den bliver liggende, indtil du sletter den, medmindre du sætter en udløbstid (expires_after, mellem en time og tredive dage). Og ræsonnementet omkring compliance stopper ikke der: dine data har forladt din infrastruktur for at blive behandlet af en tredjepart. Pseudonymisering før afsendelse koster få linjer og reducerer det, der forlader dig – for et kunde-ID, der aldrig forlader dig, kan ikke udgøre noget problem.

En nøglebaseret hash (HMAC) giver stabile pseudonymer fra én afsendelse til den næste, som ingen kan linke til originale værdier uden nøglen. Under GDPR forbliver resultatet pseudonymiserede personoplysninger, ikke anonyme: nøglen skal blive hos dig.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # hemmelighed opbevaret uden for 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)

    # Send med automatisk udløb efter en time
    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)  # uden at vente på udløb
    return response.output_text

Genereret kode

Isolation beskytter dit system, ikke korrektheden af resultatet: koden kører hos OpenAI, i en engangs-container, og rører aldrig dine maskiner. Risikoen flytter sig til det, du gør med dens output. Hvis du henter koden for at køre den lokalt, skal du gennemgå den som tredjepartskode. Og hvis containeren har en tilladelsesliste, skal du huske på, at en ondsindet fil kan indeholde instrukser, der presser modellen til at sende data til disse domæner.

Håndtering af eksekveringsfejl

Kode kan fejle i sandboxen. Modellen forsøger generelt at rette op:

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

# Modellen eksekverer koden, opdager LinAlgError,
# forklarer derefter at matricen er singulær og foreslår
# Moore-Penrose pseudoinversen

Bedste praksis

# 1. Vær specifik i dine instrukser
# Dårligt:
input_vague = "Analyze this data"

# Godt:
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. Anmod om kommenteret kode
instructions = "Comment each step of the code. Display intermediate results."

# 3. Håndter store filer
instructions_lot = ("If the file exceeds 100,000 lines, "
                   "work on a representative sample of 10,000 lines "
                   "and indicate this in your response.")

Vigtige pointer

  • Containeren er isoleret: netværk lukket som standard, hukommelse begrænset, udløb efter 20 minutters inaktivitet
  • OpenAI offentliggør ikke pakkelisten: få modellen til at inventarisere den
  • En domæne-tilladelsesliste åbnes på to niveauer (organisation, derefter anmodning) og eksponerer for eksfiltrering: sæt kun betroede domæner der
  • For at kæde trin sammen skal du genbruge den samme container (client.containers.create, derefter dens ID på hvert kald) og slette den til sidst
  • Pseudonymisér følsomme data før afsendelse og slet uploadede filer efter brug
  • Modellen håndterer eksekveringsfejl og forsøger at selvkorrigere