Aller au contenu
Découvrez la page dédiée à nos 15 ans
Intelligence Artificielle

Agents IA en production : pourquoi Docker ne suffit pas (et comment bien faire)

Déployer des agents IA sans les isoler correctement, c'est inviter le chaos dans vos pipelines. Retour d'expérience sur la mise en production sécurisée avec Docker et sandboxes.

20 novembre 2026
8 min
Shipping containers and cranes at Hamburg port showcasing global trade.

Un agent IA qui génère du code SQL à la volée. Une belle promesse d'automatisation pour vos pipelines data. Sauf qu'en production, cet agent a accidentellement écrasé une table de production parce qu'il a mal interprété une instruction. Le genre de scénario qui transforme une démonstration impressionnante en incident majeur.

Cette situation n'a rien d'exceptionnel. On voit de plus en plus d'organisations intégrer des agents IA avec sandboxes Docker pour pipelines data, que ce soit pour générer des transformations dbt, optimiser des requêtes Databricks ou orchestrer des pipelines complexes. Le problème ne vient pas de la capacité de ces agents à produire du code fonctionnel. Il vient du fait qu'on les laisse s'exécuter dans des environnements où une erreur peut avoir des conséquences irréversibles.

La conteneurisation avec Docker semble une solution évidente. On isole l'agent, on contrôle ses ressources, on nettoie après exécution. Mais Docker seul ne résout qu'une partie du problème. Ce qui compte vraiment, c'est de créer un véritable environnement sandbox qui limite non seulement l'isolation système, mais aussi l'accès aux données, les permissions réseau et les capacités d'exécution. Cette approche s'inscrit dans une transformation plus large du rôle des analytics engineers face à l'automatisation.

Les risques réels des agents IA non isolés

Quand on déploie un agent IA pour automatiser des tâches data, on lui donne généralement accès à trois choses critiques : des credentials, du code exécutable et des données. C'est exactement ce dont il a besoin pour faire son travail. C'est aussi exactement ce qui peut mal tourner.

Prenons un cas concret : un agent IA configuré pour générer des modèles dbt à partir de descriptions en langage naturel. L'utilisateur demande "crée-moi un modèle qui agrège les ventes par région". L'agent génère le code SQL, le fichier YAML de configuration, et propose même des tests. Tout semble parfait en développement.

En production, le même agent reçoit une instruction ambiguë. Il génère du code qui référence une table sensible qu'il ne devrait pas toucher. Ou pire, il crée une boucle infinie de transformations qui sature le cluster Databricks. Sans agent sandbox isolation appropriée, cet agent opère avec les mêmes permissions que le compte de service qui l'exécute, c'est-à-dire potentiellement un accès complet à votre lakehouse.

Les LLMs ont cette particularité dérangeante : ils sont statistiquement cohérents, pas logiquement infaillibles. Un modèle peut générer du code parfaitement valide sur le plan syntaxique, mais catastrophique sur le plan métier. Il peut confondre "supprimer les doublons" avec "supprimer toutes les lignes sauf une". Il peut interpréter "optimiser cette requête" comme "refactoriser complètement la logique métier".

L'isolation ne sert pas qu'à se protéger des erreurs. Elle sert aussi à limiter la surface d'attaque. Un agent compromis, que ce soit par un prompt injection ou par une faille dans sa chaîne d'exécution, ne doit pas pouvoir accéder à l'ensemble de votre infrastructure. Les enjeux de AI agents security dépassent largement la simple question technique.

Architecture d'une sandbox robuste avec Docker

Créer une sandbox efficace pour un agent IA, c'est empiler plusieurs couches de sécurité. Docker en est une, essentielle, mais insuffisante si elle est seule.

La première couche, c'est l'isolation système. Un conteneur Docker bien configuré tourne avec un utilisateur non-root, des capacités kernel limitées, et un filesystem en lecture seule sauf pour des répertoires temporaires spécifiques. Pour un agent qui génère du code dbt, on monte le répertoire du projet en lecture seule, on autorise l'écriture uniquement dans un dossier /output dédié, et on s'assure qu'aucun processus dans le conteneur ne peut escalader ses privilèges.

Voici à quoi ressemble une configuration Docker for LLM agents appropriée pour ce cas d'usage. On définit un utilisateur dédié dans le Dockerfile, on limite les capacités et on monte les volumes de manière restrictive :

FROM python:3.11-slim

RUN useradd -m -u 1000 dbt-agent && \
    pip install dbt-core dbt-databricks

USER dbt-agent
WORKDIR /workspace

COPY --chown=dbt-agent:dbt-agent requirements.txt .
RUN pip install --user -r requirements.txt

COPY --chown=dbt-agent:dbt-agent agent/ /app/agent/

ENV PATH="/home/dbt-agent/.local/bin:$PATH"
CMD ["python", "/app/agent/main.py"]

Au runtime, on renforce encore l'isolation avec des flags Docker spécifiques. On désactive les nouvelles permissions, on limite la mémoire et le CPU, et on isole le réseau sauf pour les endpoints strictement nécessaires :

docker run --rm \
  --user 1000:1000 \
  --read-only \
  --tmpfs /tmp:rw,noexec,nosuid,size=100m \
  --security-opt=no-new-privileges \
  --cap-drop=ALL \
  --network=none \
  -v /chemin/projet/dbt:/workspace:ro \
  -v /chemin/output:/output:rw \
  --memory=2g \
  --cpus=1.5 \
  dbt-agent:latest

Cette configuration empêche le conteneur d'accéder au réseau par défaut. Pour un agent qui doit communiquer avec Databricks, on crée un réseau Docker custom avec uniquement les routes nécessaires, ou on passe par un proxy qui filtre les requêtes.

La deuxième couche, c'est l'isolation des secrets. Un agent IA n'a pas besoin des credentials permanents de votre compte Databricks. Il a besoin d'un token temporaire, scopé sur un catalogue spécifique, avec des permissions limitées à la lecture et l'écriture de certaines tables. On génère ce token juste avant l'exécution de l'agent, on l'injecte via une variable d'environnement (jamais dans le code ou les logs), et on le révoque immédiatement après.

Databricks permet de créer des service principals avec des permissions très granulaires. Pour un agent qui génère des transformations dbt, on lui donne accès en lecture à un catalogue source, accès en écriture à un schema de staging dédié, et rien d'autre. Si l'agent tente d'accéder à une ressource hors scope, la requête échoue au niveau du lakehouse, pas au niveau de l'agent.

Validation et exécution contrôlée du code généré

Isoler l'environnement d'exécution ne suffit pas. Il faut aussi valider ce que l'agent produit avant de l'exécuter. Un agent IA qui génère du code dbt peut créer des fichiers syntaxiquement corrects mais sémantiquement dangereux. La validation doit intervenir à plusieurs niveaux.

D'abord, on valide la structure. Un modèle dbt généré doit respecter les conventions du projet : nommage cohérent, métadonnées complètes, références correctes aux autres modèles. On peut automatiser cette vérification avec des scripts qui parsent le YAML et le SQL générés. Si l'agent produit un fichier qui référence une table inexistante ou qui manque de tests, on rejette le résultat avant même de tenter une compilation.

Ensuite, on compile sans exécuter. dbt permet de valider qu'un modèle compile correctement avec dbt compile. Cette étape vérifie que les références entre modèles sont cohérentes, que les macros sont utilisables, que le SQL généré est valide pour le moteur cible. On effectue cette compilation dans la sandbox Docker, avec accès au catalogue Databricks en lecture seule.

Si la compilation réussit, on passe à une phase de dry-run. On exécute le modèle sur un subset minime de données, dans un schema temporaire isolé. L'objectif n'est pas de valider les résultats métier, c'est de s'assurer que l'exécution ne provoque pas d'erreur runtime, ne consomme pas de ressources excessives, et ne tente pas d'accéder à des ressources interdites.

Cette approche multi-étapes permet de détecter 90 % des problèmes avant qu'ils n'atteignent les données réelles. Le code généré passe par quatre vérifications : validation structurelle, compilation, dry-run, puis seulement après validation humaine ou automatisée des résultats du dry-run, exécution en production.

Un exemple concret de workflow pour des agentic data pipelines : l'agent génère un modèle dbt qui agrège les transactions par client. Le fichier SQL et le YAML sont écrits dans /output du conteneur. Un script de validation externe parse ces fichiers, vérifie qu'ils respectent les conventions, lance dbt compile dans le conteneur. Si ça passe, on lance dbt run --select modele_genere --target dev_sandbox sur 1000 lignes. Si le résultat est cohérent, un data engineer valide le modèle, et seulement après, il est mergé dans le repository principal et exécuté sur les données complètes.

Monitoring et limites : parce que les agents ne sont pas infaillibles

Même avec toutes ces précautions, un agent IA peut dysfonctionner. Il peut entrer dans une boucle, générer du code de plus en plus aberrant, ou tout simplement échouer silencieusement. Le monitoring d'un agent en production ressemble au monitoring d'un système distribué : on observe les métriques système, les logs applicatifs, et les résultats métier.

Côté métriques système, on surveille la consommation CPU, mémoire, et I/O du conteneur. Un agent qui génère du code dbt ne devrait pas avoir besoin de 8 Go de RAM. Si la consommation explose, c'est probablement qu'il est en train de générer quelque chose d'anormal. On configure des alertes sur ces seuils, et on kill automatiquement le conteneur s'il dépasse les limites.

Côté logs, on capture tout ce que l'agent produit : les prompts envoyés au LLM, les réponses reçues, les fichiers générés, les commandes exécutées. Ces logs sont essentiels pour comprendre ce qui s'est passé en cas d'incident. On les structure en JSON, on les envoie vers un système centralisé (Elasticsearch, Datadog, etc.), et on y applique des règles de détection d'anomalies.

On définit aussi des timeouts stricts. Un agent qui génère un modèle dbt simple ne devrait pas mettre plus de deux minutes. Au-delà, on interrompt l'exécution. On limite également le nombre d'itérations : si l'agent essaie de regénérer le même modèle cinq fois de suite parce qu'il n'arrive pas à passer la validation, on stoppe le processus et on alerte un humain.

Enfin, on valide les résultats métier. Un modèle dbt qui s'exécute sans erreur technique peut quand même produire des résultats incohérents. On met en place des tests automatisés sur les données générées : volumétrie attendue, distributions de valeurs, cohérence avec les données sources. Si un modèle généré produit soudainement 10 fois moins de lignes que d'habitude, c'est un signal d'alarme. Cette approche rejoint les principes de validation sémantique pour prévenir les erreurs analytiques.

L'idée n'est pas de créer un système parfait où aucun agent ne peut jamais se tromper. C'est impossible. L'idée est de détecter rapidement les anomalies, de limiter leur impact, et de donner aux équipes les moyens de comprendre ce qui s'est passé. Un agent IA bien isolé peut échouer sans mettre en danger l'ensemble du système.

Conclusion : l'isolation comme prérequis, pas comme option

Déployer des agents IA en production sans isolation robuste, c'est prendre un risque disproportionné par rapport au gain d'automatisation. Docker offre une base solide, mais une sandbox efficace nécessite plusieurs couches : isolation système, gestion restrictive des secrets, validation multi-étapes du code généré, et monitoring continu.

Cette approche demande plus d'effort initial qu'un simple docker run. Elle impose des contraintes sur l'architecture, sur les workflows de validation, sur la manière dont on expose les credentials. Mais elle transforme un prototype impressionnant en un système fiable qu'on peut déployer à l'échelle.

Les agents IA ne vont pas disparaître de nos pipelines data. Ils vont devenir plus nombreux, plus autonomes, plus intégrés dans nos workflows quotidiens. Autant apprendre dès maintenant à les sécuriser correctement. Parce qu'entre un agent qui automatise efficacement vos transformations dbt et un agent qui supprime accidentellement votre catalogue production, la différence tient souvent à quelques lignes de configuration Docker et à une architecture pensée pour limiter les dégâts.

Questions fréquentes

Pourquoi Docker seul ne suffit pas pour isoler les agents IA en production ?▼

Docker fournit une isolation au niveau du conteneur, mais ne protège pas contre les fuites de ressources, les accès non autorisés au système de fichiers ou les appels système dangereux. Pour les agents IA autonomes, vous avez besoin de sandboxes supplémentaires (namespaces, seccomp, AppArmor) pour restreindre les permissions au-delà du conteneur et empêcher les agents de compromettre votre infrastructure ou d'accéder aux données d'autres pipelines.

Quels risques de sécurité posent les agents IA en production sans isolation correcte ?▼

Un agent IA mal isolé peut exécuter du code malveillant, accéder à des données sensibles, consommer tous les ressources système, modifier des fichiers critiques, ou communiquer avec des services externes non autorisés. Ces risques s'amplifient dans les pipelines data où plusieurs agents partagent la même infrastructure, créant des vecteurs d'attaque en chaîne et des fuites de données.

Comment combiner Docker et sandboxes pour sécuriser les agents IA ?▼

Utilisez Docker comme première couche d'isolation, puis ajoutez des sandboxes système : limitez les appels système avec seccomp, isolez le réseau avec les network policies, restreignez le système de fichiers avec des volumes read-only, et contrôlez les ressources avec les cgroups. Cette approche en défense en profondeur garantit que même si un agent s'échappe du conteneur, il reste confiné dans un périmètre de sécurité strict.

Quels outils sandboxes compléter Docker pour les pipelines data avec IA ?▼

Les solutions courantes incluent gVisor (sandbox léger sans virtualisation), Kata Containers (conteneurs avec micro-VMs), Firecracker (pour l'isolation à grain fin), et les outils natifs Linux (seccomp, AppArmor, SELinux). Le choix dépend de votre équilibre acceptable entre sécurité et performance : gVisor offre une bonne sécurité avec peu de surcoût, tandis que les micro-VMs offrent une isolation maximale mais plus lourde.

Comment monitorer et limiter les ressources des agents IA en production ?▼

Définissez des limites CPU, mémoire et I/O via les cgroups Docker, et mettez en place un monitoring actif pour détecter les dépassements anormaux. Utilisez des métriques temps réel (utilisation mémoire, nombre de fichiers ouverts, connexions réseau) pour identifier les agents compromis ou dysfonctionnels, et planifiez des kill automatiques si les seuils critiques sont atteints pour protéger les autres pipelines.

Vous avez un projet data ?

Nous serions ravis de discuter de vos besoins en visualisation et analytics.

Nous contacter