Przejdź do głównej treści
Polski— Wybierz język
Menu

Sandboxing i limity bezpieczeństwa

Lekcja 11 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Sandboxing i limity bezpieczeństwa
  2. Architektura sandboxa
  3. Co jest dostępne
  4. Co jest ograniczone
  5. Bezpieczeństwo danych
  6. Obsługa błędów wykonania
  7. Najlepsze praktyki
  8. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 r. na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga teraz parametru container (dodano do wszystkich przykładów). Sieć kontenera, domyślnie zamknięta, może być teraz otwarta na listę dozwolonych domen. Zasady cyklu życia kontenera (pamięć, wygaśnięcie, ponowne użycie)遵循 oficjalny przewodnik. Pliki dołączone do wiadomości są przesyłane z przeznaczeniem user_data, zgodnie z zaleceniami OpenAI dla danych wejściowych modelu. Źródła: Code Interpreter · Dostęp do sieci kontenera · API kontenerów · API plików.

Sandboxing i limity bezpieczeństwa

Limity sandboxa nie są błędami, które należy obejść: to właściwości, które sprawiają, że uruchamianie generowanego kodu jest akceptowalne. Środowisko odizolowane od sieci, o krótkim czasie życia i ograniczonych zasobach, nie może wykradać Twoich danych, pozostawiać stanu w nieskończoność ani zużywać zasobów bez limitu.

Znajomość tych limitów z góry uchroni Cię przed debugowaniem rzeczy niemożliwych. Trzy powtarzające się pytania – dlaczego pip install zawodzi, dlaczego mój plik zniknął między wywołaniami, dlaczego moje przetwarzanie crashinguje na dużym pliku – mają odpowiedzi poniżej i żadne z nich nie są błędami.

Architektura sandboxa

Code Interpreter uruchamia kod w kontenerze, izolowanej maszynie wirtualnej hostowanej przez OpenAI, o następujących właściwościach:

  • Sieć domyślnie zamknięta: brak żądań wychodzących, z wyjątkiem wyraźnie otwartej listy dozwolonych domen (patrz poniżej)
  • Krótki czas życia: kontener wygasa po 20 minutach bezczynności, a wszystko, co się w nim znajduje, zostaje następnie usunięte
  • Ograniczona pamięć: domyślnie 1 GB, lub 4, 16 czy 64 GB na żądanie (memory_limit), przy czym każdy poziom ma swoją własną cenę
from openai import OpenAI

client = OpenAI()

# Bez listy dozwolonych domen pobieranie się nie powiedzie: brak dostępu do sieci
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"}}]
)

# Model wyjaśni, że dostęp do sieci jest niedostępny
print(response.output_text)

Co jest dostępne

Preinstalowane biblioteki

OpenAI nie publikuje oficjalnej listy pakietów w kontenerze i zmienia się ona z czasem. Badanie opublikowane przez dewelopera na forum OpenAI w listopadzie 2025 r. naliczyło 389 pakietów, w tym oczekiwane biblioteki do analizy: pandas, numpy, scipy i statsmodels do danych; matplotlib, seaborn i plotly do wizualizacji; Pillow do obrazów; sympy do matematyki symbolicznej; openpyxl do Excela. Zamiast zakładać, poproś model o ich inwentaryzację na początku projektu:

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)

Wersje są tak samo ważne jak nazwy: to samo badanie wykazało pandas 1.5.3, co poprzedza pandas 2.0. Jeśli Twoje przetwarzanie zależy od niedawnej funkcji, zweryfikuj jej istnienie przed budowaniem na niej.

System plików

Kod odczytuje i zapisuje pliki wewnątrz kontenera. Pliki utworzone przez model są cytowane w jego odpowiedzi i pobierane przy użyciu funkcji fichiers_generes i telecharger z Lekcji 10:

# Model może tworzyć pliki wewnątrz kontenera
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)

Co jest ograniczone

Dostęp do sieci

Domyślnie kontener nie ma dostępu wychodzącego: brak pip install, brak wywołań API, brak pobierania. To najbardziej strukturalne ograniczenie i jest zamierzone: generowany kod nie może niczego nigdzie wysłać. To, czego potrzebuje Twoje przetwarzanie, musi znajdować się w kontenerze lub zostać przesłane przez Ciebie – a jeśli dane są online, narzędzie wyszukiwania w sieci często je pobierze zamiast tego.

# Bez listy dozwolonych domen (przypadek domyślny), niemożliwe:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (brak pobierania)
# - Dostęp do zewnętrznych API
# - Wysyłanie e-maili

Otwarcie dostępu istnieje, ale jest decydowane na dwóch poziomach. Administrator najpierw definiuje listę dozwolonych domen organizacji w panelu; każde żądanie deklaruje następnie network_policy, które może je tylko dodatkowo ograniczyć – żądanie proszące o domenę nieobecną na liście organizacji kończy się niepowodzeniem.

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

Otwieranie domen ma koszt, a OpenAI stwierdza to wprost: to furtka do wykradania danych poprzez wstrzykiwanie promptów. Autoryzuj tylko zaufane domeny, których atakujący nie może użyć do otrzymywania danych – i uważaj na hosting współdzielony, gdzie każdy może postawić serwer, który będzie logował Twoje żądania.

Trwałość między wywołaniami

Brak trwałości zaskakuje większość osób przy łączeniu wywołań: DataFrame załadowany w pierwszym wywołaniu nie istnieje już w drugim. Dokładna zasada zależy od trybu auto: tworzy on nowy kontener, chyba że kontekst modelu zawiera już wywołanie Code Interpreter, którego kontener jest nadal aktywny – wtedy go ponownie wykorzystuje. Dwa niezależne wywołania pracują więc każde we własnym, podczas gdy wywołanie połączone z poprzednim (z previous_response_id) znajduje swoje własne, jeśli nie wygasło. W ramach pojedynczego wywołania wiele wykonań kodu dzieli tę samą sesję.

# Pierwsze wywołanie: tworzy plik
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"}}]
)

# Drugie wywołanie, niezależne od pierwszego: nowy kontener
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Błąd: plik nie znaleziony

Aby zachować wyniki między wywołaniami bez polegania na kontekście, spraw, by pracowały w tym samym kontenerze. Utwórz go jawnie za pomocą API kontenerów i przekaż jego ID do każdego wywołania: pliki wyprodukowane przez jeden krok pozostają dostępne dla następnego. Domyślnie wygasa on po 20 minutach bezczynności, a jego dane są wtedy trwale tracone: pobierz to, co chcesz zachować, a następnie usuń go samodzielnie.

def pipeline_avec_persistance(etapes: list[str]) -> list:
    """Wykonuje kolejne kroki w tym samym kontenerze."""
    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)

    # Po pobraniu użytecznych plików (Lekcja 10)
    client.containers.delete(conteneur.id)
    return resultats

Nie zwracaj generowanych plików jako input_file: ich ID (cfile_…) odnoszą się do plików kontenera, a nie plików API plików.

Pamięć i ciężkie przetwarzanie

Dokumentacja nie publikuje maksymalnego czasu wykonania; konkretnym limitem jest pamięć kontenera, wybierana przy tworzeniu i ważna przez cały jego żywot. Dla dużego pliku wybierz odpowiedni poziom i podziel pracę. Poza tym – trenowanie modeli, masywne obliczenia – musisz użyć własnej infrastruktury, przy czym kontener pozostaje narzędziem do analizy interaktywnej.

# Wzorzec dla ciężkiego przetwarzania: więcej pamięci, podzielona praca
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."
)

Bezpieczeństwo danych

Dane wrażliwe

Dane skopiowane do kontenera są usuwane, gdy wygasa on lub zostaje usunięty. Nie dotyczy to pliku przesłanego przez API plików: pozostaje tam, dopóki go nie usuniesz, chyba że ustawisz wygaśnięcie (expires_after, od jednej godziny do trzydziestu dni). Rozumowanie zgodności nie kończy się jednak na tym: Twoje dane opuściły Twoją infrastrukturę, aby zostać przetworzone przez stronę trzecią. Pseudonimizacja przed wysłaniem kosztuje kilka linii i redukuje to, co opuszcza środowisko – ponieważ ID klienta, które nigdy nie opuszcza systemu, nie może stanowić żadnego problemu.

Haszowanie z kluczem (HMAC) daje stabilne pseudonimy z jednego wysłania na drugie, których nikt nie może powiązać z oryginalnymi wartościami bez klucza. Zgodnie z RODO wynik pozostaje pseudonimizowanymi danymi osobowymi, a nie anonimowymi: klucz musi pozostać u Ciebie.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # sekret przechowywany poza kodem


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]):
    """Pseudonimizuje dane przed wysłaniem do 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)

    # Wyślij z automatycznym wygaśnięciem po jednej godzinie
    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)  # bez czekania na wygaśnięcie
    return response.output_text

Generowany kod

Izolacja chroni Twój system, a nie poprawność wyniku: kod działa u OpenAI, w jednorazowym kontenerze, i nigdy nie dotyka Twoich maszyn. Ryzyko przesuwa się na to, co robisz z jego wynikami. Jeśli pobierasz kod, aby uruchomić go u siebie, przeglądaj go jak kod strony trzeciej. A jeśli kontener ma listę dozwolonych domen, pamiętaj, że złośliwy plik może zawierać instrukcje, które skłonią model do wysłania danych do tych domen.

Obsługa błędów wykonania

Kod może zawieść w sandboxie. Model zazwyczaj próbuje się poprawić:

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

# Model wykonuje kod, wykrywa LinAlgError,
# następnie wyjaśnia, że macierz jest osobliwa i proponuje
# pseudoinwersję Moore'a-Penrose'a

Najlepsze praktyki

# 1. Bądź konkretny w swoich instrukcjach
# Źle:
input_vague = "Analyze this data"

# Dobrze:
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. Żądaj komentowanego kodu
instructions = "Comment each step of the code. Display intermediate results."

# 3. Obsługuj duże pliki
instructions_lot = ("If the file exceeds 100,000 lines, "
                   "work on a representative sample of 10,000 lines "
                   "and indicate this in your response.")

Kluczowe wnioski

  • Kontener jest izolowany: sieć domyślnie zamknięta, pamięć ograniczona, wygaśnięcie po 20 minutach bezczynności
  • OpenAI nie publikuje listy pakietów: poproś model o ich inwentaryzację
  • Lista dozwolonych domen otwiera się na dwóch poziomach (organizacja, następnie żądanie) i naraża na wykradanie danych: umieszczaj tam tylko zaufane domeny
  • Aby łączyć kroki, użyj ponownie tego samego kontenera (client.containers.create, a następnie jego ID przy każdym wywołaniu) i usuń go na końcu
  • Pseudonimizuj dane wrażliwe przed wysłaniem i usuwaj przesłane pliki po użyciu
  • Model obsługuje błędy wykonania i próbuje się sam poprawić