Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Sandboxning och säkerhetsbegränsningar

Lektion 11 av 20 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Sandboxning och säkerhetsbegränsningar
  2. Sandboxarkitektur
  3. Vad som finns tillgängligt
  4. Vad som är begränsat
  5. Datasäkerhet
  6. Hantering av exekveringsfel
  7. Bästa praxis
  8. Viktiga punkter

Uppdaterad 2 november 2026 baserat på OpenAI-dokumentation: verktyget Code Interpreter kräver nu en parameter container (lagd till i alla exempel). Containernätverket, som är stängt som standard, kan nu öppnas för en tillåten lista över domäner. Regler för containerns livscykel (minne, utgång, återanvändning) följer den officiella guiden. Filer som bifogas ett meddelande laddas upp med syftet user_data, enligt OpenAI:s rekommendation för modellinmatningar. Källor: Code Interpreter · Container Network Access · Containers API · Files API.

Sandboxning och säkerhetsbegränsningar

Sandboxbegränsningar är inte buggar att kringgå: det är egenskaperna som gör att körning av genererad kod är acceptabel. En nätverksisolerad miljö med kort livslängd och resursbegränsningar kan inte exfiltrera dina data, lämna tillstånd liggande på obestämd tid eller konsumera resurser utan gräns.

Att känna till dessa begränsningar i förväg sparar dig från att felsöka det omöjliga. De tre återkommande frågorna – varför pip install misslyckas, varför min fil försvann mellan anrop, varför min bearbetning kraschar på en stor fil – har alla svar nedan, och inget av dem är buggar.

Sandboxarkitektur

Code Interpreter kör kod i en container, en isolerad virtuell maskin som hostas av OpenAI, med följande egenskaper:

  • Nätverk stängt som standard: inga utgående förfrågningar, utom för en explicit öppnad tillåten lista över domäner (se nedan)
  • Kort livslängd: containern upphör efter 20 minuters inaktivitet, och allt darin raderas sedan
  • Begränsat minne: 1 GB som standard, eller 4, 16 eller 64 GB på begäran (memory_limit), där varje nivå har sin egen prissättning
from openai import OpenAI

client = OpenAI()

# Utan en tillåten lista misslyckas nedladdningen: ingen nätverksåtkomst
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 kommer att förklara att nätverksåtkomst inte finns tillgänglig
print(response.output_text)

Vad som finns tillgängligt

Förinstallerade bibliotek

OpenAI publicerar ingen officiell lista över containerpaket, och den ändras över tid. En undersökning publicerad av en utvecklare på OpenAI-forumet i november 2025 räknade 389 paket, inklusive de förväntade biblioteken för analys: pandas, numpy, scipy och statsmodels för data; matplotlib, seaborn och plotly för visualisering; Pillow för bilder; sympy för symbolisk matematik; openpyxl för Excel. Anta inte, låt modellen inventera dem i början av ett 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 är lika viktiga som namn: samma undersökning visade pandas 1.5.3, vilket föregår pandas 2.0. Om din bearbetning beror på en ny funktion, verifiera att den finns innan du bygger vidare på den.

Filsystem

Kod läser och skriver filer inuti containern. Filer som modellen skapar citeras i dess svar och laddas ner med hjälp av funktionerna fichiers_generes och telecharger från lektion 10:

# Modellen kan skapa filer inuti containern
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)

Vad som är begränsat

Nätverksåtkomst

Som standard har containern ingen utgående åtkomst: ingen pip install, inga API-anrop, inga nedladdningar. Detta är den mest strukturella begränsningen, och den är avsiktlig: genererad kod kan inte skicka något någonstans. Det din bearbetning behöver måste finnas i containern eller laddas upp av dig – och om datan finns online kommer webbsearch-verktyget ofta att hämta den istället.

# Utan en tillåten lista (standardfall), omöjligt:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (inga nedladdningar)
# - Åtkomst till externa API:er
# - Skicka e-post

Att öppna åtkomst finns, men det beslutas på två nivåer. En administratör definierar först organisationens tillåtna lista i instrumentpanelen; varje förfrågan deklarerar sedan en network_policy som bara kan begränsa den ytterligare – en förfrågan som ber om en domän som saknas i organisationens lista misslyckas.

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

Att öppna domäner har en kostnad, och OpenAI säger det rakt ut: det är en dörr för dataexfiltrering via promptinjektion. Auktorisera endast betrodda domäner som en angripare inte kan använda för att ta emot data – och akta dig för delat hosting, där vem som helst kan sätta upp en server som loggar dina förfrågningar.

Beständighet mellan anrop

Bristen på beständighet överraskar de flesta när man kedjar anrop: DataFrame:en som laddades i det första anropet finns inte längre i det andra. Den exakta regeln hänger på auto-läget: det skapar en ny container, om inte modellkontexten redan innehåller ett Code Interpreter-anrop vars container fortfarande är aktiv – då återanvänds den istället. Två oberoende anrop arbetar därför var och en i sin egen, medan ett anrop som kedjas till det föregående (med previous_response_id) hittar sin egen om den inte har löpt ut. Inom ett enda anrop delar flera kodexekveringar samma session.

# Första anropet: skapar 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"}}]
)

# Andra anropet, oberoende av det första: ny container
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Fel: filen hittades inte

För att behålla resultat mellan anrop utan att bero på kontext, få dem att arbeta i samma container. Skapa den explicit med Containers API och skicka dess ID till varje anrop: filer som produceras av ett steg förblir tillgängliga för nästa. Som standard löper den ut efter 20 minuters inaktivitet och dess data går då permanent förlorad: ladda ner det du vill behålla, och radera den sedan själv.

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 nedladdning av användbara filer (Lektion 10)
    client.containers.delete(conteneur.id)
    return resultats

Returnera inte genererade filer som input_file: deras ID:n (cfile_…) refererar till containerfiler, inte Files API-filer.

Minne och tung bearbetning

Dokumentationen publicerar ingen maximal exekveringstid; den konkreta begränsningen är containerns minne, valt vid skapandet och giltigt under hela dess livstid. För en stor fil, välj en lämplig nivå och låt arbetet delas upp. Utöver det – modellträning, massiv beräkning – måste du använda din egen infrastruktur, där containern förblir verktyget för interaktiv analys.

# Mönster för tung bearbetning: mer minne, delat arbete
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."
)

Datasäkerhet

Känsliga data

Data som kopieras in i containern raderas när den löper ut eller tas bort. Detta gäller inte för en fil uppladdad via Files API: den finns kvar tills du tar bort den, om du inte ställer in en utgångstid (expires_after, mellan en timme och trettio dagar). Och resonemanget kring efterlevnad stannar inte där: dina data har lämnat din infrastruktur för att bearbetas av en tredje part. Pseudonymisering innan sändning kostar några rader och minskar det som lämnar – eftersom ett kund-ID som aldrig lämnar inte kan utgöra något problem.

En nycklad hash (HMAC) ger stabila pseudonymer från en sändning till nästa, som ingen kan länka till originalvärden utan nyckeln. Enligt GDPR förblir resultatet pseudonymiserade personuppgifter, inte anonyma: nyckeln måste stanna hos dig.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # hemlighet hållen utanför kod


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)

    # Skicka med automatisk utgång efter en timme
    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)  # utan att vänta på utgång
    return response.output_text

Genererad kod

Isolering skyddar ditt system, inte korrektheten i resultatet: koden körs hos OpenAI, i en engångscontainer, och rör aldrig dina maskiner. Risken flyttas till vad du gör med dess utdata. Om du hämtar koden för att köra den på din sida, granska den som tredjepartskod. Och om containern har en tillåten lista, kom ihåg att en skadlig fil kan innehålla instruktioner som pushar modellen att skicka data till dessa domäner.

Hantering av exekveringsfel

Kod kan misslyckas i sandboxen. Modellen försöker generellt att korrigera:

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 exekverar koden, upptäcker LinAlgError,
# förklarar sedan att matrisen är singulär och föreslår
# Moore-Penrose pseudoinversen

Bästa praxis

# 1. Var specifik i dina instruktioner
# Dåligt:
input_vague = "Analyze this data"

# Bra:
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. Begär kommenterad kod
instructions = "Comment each step of the code. Display intermediate results."

# 3. Hantera stora 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.")

Viktiga punkter

  • Containern är isolerad: nätverk stängt som standard, minne begränsat, utgång efter 20 minuters inaktivitet
  • OpenAI publicerar inte paketlistan: låt modellen inventera den
  • En tillåten lista över domäner öppnas på två nivåer (organisation, sedan förfrågan) och exponerar för exfiltrering: lägg endast till betrodda domäner där
  • För att kedja steg, återanvänd samma container (client.containers.create, sedan dess ID vid varje anrop), och radera den i slutet
  • Pseudonymisera känsliga data innan sändning och radera uppladdade filer efter användning
  • Modellen hanterar exekveringsfel och försöker självrätta