Sandboxing et limites de sécurité
Na tejto strane
Mis à jour le 2 novembre 2026 selon la documentation d’OpenAI : l’outil Code Interpreter nécessite désormais un paramètre
container(ajouté à tous les exemples). Le réseau du conteneur, fermé par défaut, peut désormais s’ouvrir à une liste blanche de domaines. Les règles de cycle de vie du conteneur (mémoire, expiration, réutilisation) suivent le guide officiel. Les fichiers joints à un message sont téléchargés avec l’objectifuser_data, comme recommandé par OpenAI pour les entrées du modèle. Sources : Code Interpreter · Accès réseau du conteneur · API des conteneurs · API des fichiers.
Sandboxing et limites de sécurité
Les limites du sandbox ne sont pas des bugs à contourner : ce sont les propriétés qui rendent l’exécution de code généré acceptable. Un environnement isolé du réseau, avec une durée de vie courte et des plafonds de ressources, ne peut pas exfiltrer tes données, laisser un état traîner indéfiniment ni consommer des ressources sans limite.
Connaître ces limites à l’avance t’évite de déboguer l’impossible. Les trois questions récurrentes — pourquoi pip install échoue, pourquoi mon fichier a disparu entre deux appels, pourquoi mon traitement plante sur un gros fichier — ont toutes une réponse ci-dessous, et aucune n’est un bug.
Architecture du sandbox
Code Interpreter exécute le code dans un conteneur, une machine virtuelle isolée hébergée par OpenAI, avec les propriétés suivantes :
- Réseau fermé par défaut : aucune requête sortante, sauf pour une liste blanche de domaines explicitement ouverte (voir ci-dessous)
- Durée de vie courte : le conteneur expire après 20 minutes d’inactivité, et tout ce qu’il contient est alors effacé
- Mémoire plafonnée : 1 Go par défaut, ou 4, 16 ou 64 Go sur demande (
memory_limit), chaque niveau ayant sa propre tarification
from openai import OpenAI
client = OpenAI()
# Sans liste blanche, le téléchargement échouera : pas d'accès réseau
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"}}]
)
# Le modèle expliquera que l'accès réseau n'est pas disponible
print(response.output_text)
Ce qui est disponible
Bibliothèques préinstallées
OpenAI ne publie pas de liste officielle des paquets du conteneur, et elle évolue dans le temps. Une enquête publiée par un développeur sur le forum OpenAI en novembre 2025 a recensé 389 paquets, dont les bibliothèques attendues pour l’analyse : pandas, numpy, scipy et statsmodels pour les données ; matplotlib, seaborn et plotly pour la visualisation ; Pillow pour les images ; sympy pour les mathématiques symboliques ; openpyxl pour Excel. Plutôt que de supposer, demande au modèle d’en faire l’inventaire au début d’un projet :
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)
Les versions comptent autant que les noms : la même enquête montrait pandas 1.5.3, qui précède pandas 2.0. Si ton traitement dépend d’une fonction récente, vérifie qu’elle existe avant de construire dessus.
Système de fichiers
Le code lit et écrit des fichiers à l’intérieur du conteneur. Les fichiers créés par le modèle sont cités dans sa réponse et téléchargés à l’aide des fonctions fichiers_generes et telecharger de la leçon 10 :
# Le modèle peut créer des fichiers à l'intérieur du conteneur
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)
Ce qui est limité
Accès réseau
Par défaut, le conteneur n’a aucun accès sortant : pas de pip install, pas d’appels API, pas de téléchargements. C’est la limite la plus structurelle, et elle est intentionnelle : le code généré ne peut rien envoyer nulle part. Ce dont ton traitement a besoin doit être présent dans le conteneur ou téléchargé par toi — et si les données sont en ligne, l’outil de recherche web les récupérera souvent à ta place.
# Sans liste blanche (cas par défaut), impossible :
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (pas de téléchargements)
# - Accès aux API externes
# - Envoi d'e-mails
L’ouverture d’accès existe, mais elle se décide à deux niveaux. Un administrateur définit d’abord la liste blanche de l’organisation dans le tableau de bord ; chaque requête déclare ensuite une network_policy qui ne peut que la restreindre davantage — une requête demandant un domaine absent de la liste de l’organisation échouera.
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"],
},
},
}],
)
Ouvrir des domaines a un coût, et OpenAI le dit clairement : c’est une porte ouverte à l’exfiltration de données via l’injection de prompt. N’autorise que des domaines de confiance qu’un attaquant ne peut pas utiliser pour recevoir des données — et méfie-toi de l’hébergement partagé, où n’importe qui peut mettre en place un serveur qui journalisera tes requêtes.
Persistance entre les appels
L’absence de persistance surprend la plupart lors de l’enchaînement d’appels : le DataFrame chargé dans le premier appel n’existe plus dans le second. La règle exacte repose sur le mode auto : il crée un nouveau conteneur, sauf si le contexte du modèle contient déjà un appel Code Interpreter dont le conteneur est encore actif — il réutilise alors celui-ci. Deux appels indépendants travaillent donc chacun dans le leur, tandis qu’un appel enchaîné au précédent (avec previous_response_id) retrouve le sien s’il n’a pas expiré. Au sein d’un même appel, plusieurs exécutions de code partagent la même session.
# Premier appel : crée un fichier
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"}}]
)
# Deuxième appel, indépendant du premier : nouveau conteneur
response2 = client.responses.create(
model="gpt-5.6-terra",
input="Read the file created previously",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Erreur : fichier non trouvé
Pour conserver des résultats entre les appels sans dépendre du contexte, fais-les travailler dans le même conteneur. Crée-le explicitement avec l’API des conteneurs et passe son ID à chaque appel : les fichiers produits par une étape restent disponibles pour la suivante. Par défaut, il expire après 20 minutes d’inactivité et ses données sont alors définitivement perdues : télécharge ce que tu veux garder, puis supprime-le toi-même.
def pipeline_avec_persistance(etapes: list[str]) -> list:
"""Exécute des étapes successives dans le même conteneur."""
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)
# Après avoir téléchargé les fichiers utiles (Leçon 10)
client.containers.delete(conteneur.id)
return resultats
Ne retourne pas les fichiers générés en tant que input_file : leurs ID (cfile_…) font référence à des fichiers de conteneur, pas à des fichiers de l’API Files.
Mémoire et traitements lourds
La documentation ne publie pas de durée d’exécution maximale ; la limite concrète est la mémoire du conteneur, choisie à la création et valable pour toute sa durée de vie. Pour un gros fichier, choisis un niveau approprié et fais diviser le travail. Au-delà — entraînement de modèle, calcul massif — tu dois utiliser ta propre infrastructure, le conteneur restant l’outil pour l’analyse interactive.
# Modèle pour les traitements lourds : plus de mémoire, travail découpé
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."
)
Sécurité des données
Données sensibles
Les données copiées dans le conteneur sont effacées lorsqu’il expire ou est supprimé. Ce n’est pas le cas d’un fichier téléchargé via l’API Files : il y reste jusqu’à ce que tu le supprimes, sauf si tu définis une expiration (expires_after, entre une heure et trente jours). Et le raisonnement de conformité ne s’arrête pas là : tes données ont quitté ton infrastructure pour être traitées par un tiers. La pseudonymisation avant envoi coûte quelques lignes et réduit ce qui sort — car un ID client qui ne sort jamais ne peut poser aucun problème.
Un hachage clé (HMAC) donne des pseudonymes stables d’un envoi à l’autre, que personne ne peut relier aux valeurs originales sans la clé. Selon le RGPD, le résultat reste des données personnelles pseudonymisées, pas anonymes : la clé doit rester chez toi.
import hashlib
import hmac
import os
import pandas as pd
CLE = os.environ["CLE_PSEUDONYMISATION"].encode() # secret gardé hors du code
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]):
"""Pseudonymise les données avant envoi à 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)
# Envoi avec expiration automatique après une heure
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) # sans attendre l'expiration
return response.output_text
Code généré
L’isolation protège ton système, pas la justesse du résultat : le code s’exécute chez OpenAI, dans un conteneur jetable, et ne touche jamais tes machines. Le risque se déplace vers ce que tu fais de ses sorties. Si tu récupères le code pour l’exécuter chez toi, examine-le comme un code tiers. Et si le conteneur a une liste blanche, garde à l’esprit qu’un fichier malveillant peut contenir des instructions qui poussent le modèle à envoyer des données vers ces domaines.
Gestion des erreurs d’exécution
Le code peut échouer dans le sandbox. Le modèle essaie généralement de se corriger :
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."
)
# Le modèle exécute le code, détecte la LinAlgError,
# puis explique que la matrice est singulière et propose
# la pseudo-inverse de Moore-Penrose
Bonnes pratiques
# 1. Sois précis dans tes instructions
# Mauvais :
input_vague = "Analyze this data"
# Bon :
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. Demande du code commenté
instructions = "Comment each step of the code. Display intermediate results."
# 3. Gère les gros fichiers
instructions_lot = ("If the file exceeds 100,000 lines, "
"work on a representative sample of 10,000 lines "
"and indicate this in your response.")
Kľúčové poznatky
- Le conteneur est isolé : réseau fermé par défaut, mémoire plafonnée, expiration après 20 minutes d’inactivité
- OpenAI ne publie pas la liste des paquets : fais-la inventorier par le modèle
- Une liste blanche de domaines s’ouvre à deux niveaux (organisation, puis requête) et expose à l’exfiltration : n’y mets que des domaines de confiance
- Pour enchaîner des étapes, réutilise le même conteneur (
client.containers.create, puis son ID à chaque appel), et supprime-le à la fin - Pseudonymise les données sensibles avant envoi et supprime les fichiers téléchargés après usage
- Le modèle gère les erreurs d’exécution et tente de s’autocorriger