Bacs à sable d’agents fondés sur Docker
Lancer des conteneurs jetables pour exécuter du code généré par l’agent.
Bacs à sable d’agents fondés sur Docker est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.
Pourquoi les agents ont-ils besoin de bacs à sable ?
Lorsqu’un agent exécute du code écrit par un LLM, ce code est non fiable. Il peut tenter de lire des fichiers sensibles, d’établir des connexions sortantes ou de consommer des ressources sans limite.
Un bac à sable isole l’exécution du code afin que les dommages restent limités, quelles que soient les actions du code.
Docker comme couche de bac à sable
Les conteneurs Docker fournissent une isolation légère au niveau du système d’exploitation. Chaque extrait de code s’exécute dans un conteneur neuf avec des limites explicites de ressources et des restrictions réseau.
Le SDK Python docker vous permet de créer et de détruire des conteneurs automatiquement depuis votre agent.
import docker
client = docker.from_env()
print(client.version()['Version'])Exécution de base d’un conteneur
client.containers.run() démarre un conteneur, exécute une commande et renvoie la sortie sous forme d’octets. La définition de auto_remove=True nettoie le conteneur après son arrêt.
import docker
client = docker.from_env()
output = client.containers.run(
'python:3.12-slim',
'python -c "print(2 + 2)"',
auto_remove=True
)
print(output.decode()) # '4'Limites de mémoire et de CPU
Sans limites, un script malveillant peut épuiser la mémoire de l’hôte. Transmettez mem_limit et nano_cpus pour plafonner l’utilisation des ressources.
Si le processus dépasse mem_limit, le conteneur est arrêté par OOM et une exception est levée.
output = client.containers.run(
'python:3.12-slim',
'python -c "x = [0]*10**8"', # tries to allocate ~800 MB
mem_limit='256m',
nano_cpus=1_000_000_000, # 1 CPU
auto_remove=True
)
# Raises docker.errors.ContainerError if OOM-killedDésactivation du réseau
La définition de network_disabled=True empêche le conteneur d’effectuer des appels réseau entrants ou sortants — même les recherches DNS échouent. Cela bloque l’exfiltration de données et les rappels de commande et de contrôle.
output = client.containers.run(
'python:3.12-slim',
'python -c "import urllib.request; urllib.request.urlopen(\"http://example.com\")"',
network_disabled=True,
auto_remove=True
)
# Raises ContainerError: network unreachableDélai d’exécution
Une boucle infinie dans le bac à sable bloquerait votre agent indéfiniment. Transmettez un timeout (en secondes) à containers.run() afin que Docker arrête le conteneur après l’échéance.
import docker
from docker.errors import ContainerError
client = docker.from_env()
try:
output = client.containers.run(
'python:3.12-slim',
'python -c "while True: pass"',
mem_limit='256m',
network_disabled=True,
auto_remove=True,
timeout=30
)
except Exception as e:
print(f'Sandbox timeout or error: {e}')Fonction d’assistance complète pour le bac à sable
Regrouper tous les paramètres dans une fonction réutilisable facilite son appel depuis les outils de l’agent. Renvoyez à la fois la sortie standard et un indicateur d’état afin que l’agent puisse réagir aux échecs.
import docker
client = docker.from_env()
def run_in_sandbox(code: str, timeout: int = 30) -> dict:
cmd = f'python -c "{code.replace(chr(34), chr(39))}"'
try:
out = client.containers.run(
'python:3.12-slim',
cmd,
mem_limit='256m',
nano_cpus=500_000_000,
network_disabled=True,
auto_remove=True,
timeout=timeout
)
return {'success': True, 'output': out.decode()}
except Exception as e:
return {'success': False, 'error': str(e)}Montage d’un espace de travail temporaire
Si le code doit lire des fichiers d’entrée ou écrire des fichiers de sortie, montez un répertoire temporaire de l’hôte dans le conteneur. Utilisez volumes avec le mode 'rw' pour l’espace de travail, et rien d’autre.
import tempfile, os
with tempfile.TemporaryDirectory() as tmpdir:
# Write input data
with open(os.path.join(tmpdir, 'data.txt'), 'w') as f:
f.write('hello sandbox')
output = client.containers.run(
'python:3.12-slim',
'python -c "print(open(\"/workspace/data.txt\").read())"',
volumes={tmpdir: {'bind': '/workspace', 'mode': 'rw'}},
mem_limit='256m',
network_disabled=True,
auto_remove=True
)
print(output.decode())Système de fichiers en lecture seule
Définissez read_only=True pour monter le système de fichiers racine du conteneur en lecture seule. Le code ne peut écrire que dans les volumes explicitement montés. Cela empêche les écritures dans /etc, /usr ou d’autres chemins sensibles de l’image.
import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
output = client.containers.run(
'python:3.12-slim',
'python -c "open(\"/output/result.txt\",\"w\").write(str(1+1))"',
volumes={tmpdir: {'bind': '/output', 'mode': 'rw'}},
read_only=True,
mem_limit='256m',
network_disabled=True,
auto_remove=True
)
print(open(f'{tmpdir}/result.txt').read()) # '2'Intégration du bac à sable dans un outil d’agent
Enregistrez l’exécuteur du bac à sable comme un outil que le LLM peut appeler. L’agent génère du code, l’outil l’exécute de manière isolée, puis la sortie revient à l’étape de raisonnement suivante.
tools = [
{
'type': 'function',
'function': {
'name': 'execute_python',
'description': 'Run a Python snippet in an isolated Docker sandbox.',
'parameters': {
'type': 'object',
'properties': {
'code': {'type': 'string', 'description': 'Python code to execute.'}
},
'required': ['code']
}
}
}
]
def handle_tool_call(name, args):
if name == 'execute_python':
return run_in_sandbox(args['code'])Gestion des erreurs et nettoyage
Les conteneurs peuvent ne pas démarrer si le démon Docker n’est pas en cours d’exécution ou si l’image n’est pas mise en cache. Gérez toujours docker.errors.DockerException et assurez-vous que les conteneurs sont nettoyés, même en cas d’exception.
from docker.errors import DockerException, ImageNotFound
def safe_run(code: str) -> dict:
try:
return run_in_sandbox(code)
except ImageNotFound:
# Pull the image first
client.images.pull('python:3.12-slim')
return run_in_sandbox(code)
except DockerException as e:
return {'success': False, 'error': f'Docker unavailable: {e}'}
except Exception as e:
return {'success': False, 'error': str(e)}Quel paramètre du bac à sable est le plus important pour empêcher l’exfiltration de données ?
Le bac à sable d’un agent doit empêcher le code exécuté d’envoyer des données volées vers un serveur externe. Quel paramètre Docker bloque directement l’accès réseau sortant ?
Récapitulatif des bacs à sable Docker
Les bacs à sable basés sur Docker fournissent aux agents un environnement d’exécution sûr en combinant des limites de mémoire et de CPU, un isolement réseau, des délais d’exécution et des systèmes de fichiers en lecture seule.
Regroupez ces paramètres dans une fonction d’assistance réutilisable et exposez-la comme outil d’agent afin de permettre au LLM d’exécuter en toute sécurité le code généré sans risquer d’endommager le système hôte.
Questions Fréquemment Posées
La leçon « Bacs à sable d’agents fondés sur Docker » est-elle gratuite ?
Oui — le texte complet de « Bacs à sable d’agents fondés sur Docker » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Bacs à sable d’agents fondés sur Docker » ?
Lancer des conteneurs jetables pour exécuter du code généré par l’agent. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Agents ?
Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Bacs à sable d’agents fondés sur Docker » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?
Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Bacs à sable d’agents fondés sur Docker
- Isolation par VM pour les agents exécutant du code hautement sécurisé
- E2B et services de bacs à sable cloud
- Politiques de sécurité pour l’exécution du code