Sandboxing et limites de sécurité
Na této stránce
Mis à jour le 2 novembre 2026 sur la base de la documentation 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 traîner un état 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 palier 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="Télécharge le contenu de https://example.com en utilisant 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 celle-ci é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="Liste les paquets Python installés avec leurs versions, "
"puis affiche la version de Python.",
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 en utilisant les 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="Crée un fichier CSV avec 100 lignes de données de test "
"(nom, age, ville, salaire) et retourne-le.",
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 à la 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 de l’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="Mets à jour pandas avec pip, puis affiche la version installée.",
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 souvent 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 seul appel, plusieurs exécutions de code partagent bien la même session.
# Premier appel : crée un fichier
response1 = client.responses.create(
model="gpt-5.6-terra",
input="Crée une variable x = 42 et sauvegarde-la dans un fichier",
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="Lis le fichier créé précédemment",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Erreur : fichier introuvable
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 palier 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 un traitement lourd : 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": (
"Traite ce fichier CSV de 500 000 lignes par lots de 50 000. "
"Pour chaque lot, calcule les statistiques et accumule les résultats."
)},
{"type": "input_file", "file_id": fichier.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto", "memory_limit": "4g"}}],
instructions="Si le traitement risque d'être long, découpe-le en étapes "
"et affiche la progression."
)
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. Pseudonymiser 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": "Analyse les tendances de ces données"},
{"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 éphémère, 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, révise-le comme un code tiers. Et si le conteneur a une liste blanche, garde en tête qu’un fichier malveillant peut contenir des instructions poussant 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="Calcule la matrice inverse d'une matrice singulière [[1,2],[2,4]]",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions="Si le code produit une erreur, explique pourquoi "
"et propose une 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 = "Analyse ces données"
# Bon :
input_precis = ("Charge ce CSV avec pandas. "
"Calcule la moyenne, la médiane et l'écart-type de la colonne 'montant'. "
"Identifie les valeurs supérieures à 3 écarts-types. "
"Génère un diagramme en boîte.")
# 2. Demande du code commenté
instructions = "Commente chaque étape du code. Affiche les résultats intermédiaires."
# 3. Gère les gros fichiers
instructions_lot = ("Si le fichier dépasse 100 000 lignes, "
"travaille sur un échantillon représentatif de 10 000 lignes "
"et indique-le dans ta réponse.")
Klíč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’auto-corriger