Sandboxing i limity bezpieczeństwa
Na tej stronie
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 przeznaczeniemuser_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ć