Automatisation de navigateur avec Docker : guide de deploiement et de mise a l'echelle

Introduction

Docker fournit la reproductibilite, l'isolation et les primitives de mise a l'echelle dont les deploiements BotBrowser en production ont besoin. Chaque conteneur demarre a partir d'un etat connu, fonctionne independamment des autres conteneurs et peut etre replique sur toute infrastructure supportant Docker. Plus de problemes du type "ca marche sur ma machine".

Ce guide couvre le flux de travail complet du deploiement Docker : construction d'images, gestion des profils et scripts avec des montages de volumes, configuration de la memoire partagee, mise a l'echelle avec Docker Compose et renforcement pour la production. Que vous executiez un seul conteneur localement ou que vous orchestriez des dizaines de workers dans le cloud, les patterns presentes ici s'appliquent.

Pourquoi le deploiement Docker est important

BotBrowser depend de bibliotheques systeme specifiques, d'un serveur d'affichage virtuel et d'une configuration d'environnement soigneuse. Sur du bare metal, chaque nouveau serveur necessite la meme configuration manuelle : installer les dependances, configurer Xvfb, definir les variables d'environnement et verifier l'installation. Docker empaquette tout cela dans une seule image qui se deploie de maniere identique partout.

Docker fournit egalement l'isolation des processus. Chaque conteneur execute sa propre instance BotBrowser avec son propre systeme de fichiers, espace de noms reseau et limites de ressources. Une fuite memoire dans un conteneur n'affecte pas les autres. Un worker plante peut etre automatiquement redemarre par la politique de redemarrage de Docker sans intervention humaine.

Pour les equipes executant plusieurs instances BotBrowser avec differents profils et proxies, Docker Compose ou les plateformes d'orchestration de conteneurs facilitent la definition, la mise a l'echelle et la gestion de l'ensemble de la flotte a partir d'un seul fichier de configuration.

Contexte technique

Chrome et la memoire partagee

Chrome utilise intensivement /dev/shm (memoire partagee) pour la communication inter-processus entre le processus navigateur, le processus GPU et les processus de rendu. L'allocation par defaut de /dev/shm par Docker est de 64 Mo, ce qui est bien trop petit. Chrome plantera ou se comportera de maniere erratique sans au moins 1-2 Go de memoire partagee.

La solution est simple : ajoutez --shm-size=2g a votre commande docker run ou definissez shm_size: '2g' dans votre fichier Docker Compose.

Serveur d'affichage dans les conteneurs

Tout comme sur un serveur bare metal, BotBrowser dans Docker a besoin de Xvfb pour l'initialisation de l'affichage. Le conteneur doit demarrer Xvfb avant de lancer Chrome, et la variable d'environnement DISPLAY doit etre definie.

Repertoires de donnees utilisateur

Chaque instance BotBrowser a besoin de son propre --user-data-dir. Dans Docker, ce repertoire se trouve par defaut a l'interieur du conteneur et est perdu lorsque le conteneur s'arrete. Pour des sessions persistantes, montez un volume hote pour preserver l'etat du navigateur entre les redemarrages du conteneur.

Considerations sur la taille des images

Une image Docker BotBrowser avec toutes les dependances fait generalement 500-800 Mo. L'utilisation de builds multi-etapes ou la reduction de la liste de paquets peut reduire cette taille. Le compromis est que chaque bibliotheque manquante est un echec potentiel a l'execution.

<svg viewBox="0 0 700 280" xmlns="http://www.w3.org/2000/svg" style={{maxWidth: '100%', height: 'auto'}}> Docker Container Xvfb :10 Virtual Display BotBrowser Chrome + Profile Node.js Automation Script /dev/shm 2 GB Shared Mem Volume: /opt/profiles (host mounted) Volume: /data/sessions (persistent)

Approches courantes et limites

Conteneur monolithique unique

Tout executer dans un seul conteneur (Xvfb, BotBrowser, script d'automatisation et monitoring) est l'approche la plus simple mais limite la scalabilite. Vous ne pouvez pas mettre a l'echelle le script d'automatisation independamment du navigateur, et un probleme dans n'importe quel composant fait tomber l'ensemble du conteneur.

Un conteneur par navigateur

Executer un conteneur par instance BotBrowser fournit la meilleure isolation. Chaque conteneur a son propre profil, proxy et repertoire de donnees utilisateur. La surcharge est plus elevee (chaque conteneur inclut un jeu complet de bibliotheques systeme), mais l'isolation rend le debogage et la mise a l'echelle simples.

Pattern sidecar

Certains deploiements utilisent un conteneur sidecar executant Xvfb que plusieurs conteneurs navigateur partagent. Cela reduit l'utilisation des ressources mais ajoute de la complexite reseau et cree un point de defaillance unique.

Construction a partir d'images de base Chromium

Utiliser les images Docker Chromium officielles de Google comme base peut reduire l'effort de configuration, mais ces images peuvent ne pas inclure toutes les bibliotheques dont BotBrowser a besoin. Construire a partir d'Ubuntu offre plus de controle sur la liste des dependances.

L'approche de BotBrowser

Le systeme de profils multi-plateformes de BotBrowser est particulierement adapte aux deploiements Docker. Le meme profil produit la meme empreinte quelle que soit l'image de base du conteneur, la version du kernel ou la machine hote. Cela elimine une source courante d'incoherence dans les deploiements de navigateurs conteneurises.

La strategie de conteneurisation recommandee ici utilise Ubuntu 22.04 comme base, installe toutes les dependances requises, copie le binaire BotBrowser et les profils dans l'image, et demarre Xvfb avant le script d'automatisation. Cette approche est testee, fiable et produit des resultats coherents entre les fournisseurs cloud.

Configuration et utilisation

Dockerfile de base

FROM ubuntu:22.04

# Installer les dependances systeme
RUN apt-get update && apt-get install -y \
    wget ca-certificates fonts-liberation \
    libasound2 libatk-bridge2.0-0 libatk1.0-0 \
    libcups2 libdbus-1-3 libdrm2 libgbm1 \
    libgtk-3-0 libnspr4 libnss3 \
    libxcomposite1 libxdamage1 libxrandr2 \
    xdg-utils xvfb curl \
    && rm -rf /var/lib/apt/lists/*

# Installer Node.js
RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
    && apt-get install -y nodejs \
    && rm -rf /var/lib/apt/lists/*

# Definir l'environnement d'affichage
ENV DISPLAY=:10.0

# Copier le binaire BotBrowser
COPY botbrowser/ /opt/botbrowser/
RUN chmod +x /opt/botbrowser/chrome

# Copier les profils
COPY profiles/ /opt/profiles/

# Copier les scripts d'automatisation
WORKDIR /opt/app
COPY package.json package-lock.json ./
RUN npm ci --production
COPY scripts/ ./scripts/

# Verification de sante
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD pgrep -x Xvfb && pgrep -f "chrome" || exit 1

# Demarrer Xvfb et executer le script d'automatisation
CMD Xvfb :10 -screen 0 1920x1080x24 -ac & \
    sleep 1 && \
    node scripts/main.js

Construction et execution

docker build -t botbrowser-worker .
docker run --rm --shm-size=2g botbrowser-worker

Le flag --shm-size=2g est obligatoire. Sans lui, Chrome plante ou se comporte de maniere imprevisible en raison d'une memoire partagee insuffisante.

Script d'automatisation

// scripts/main.js
const { chromium } = require('playwright-core');

const PROFILE = process.env.PROFILE || '/opt/profiles/profile.enc';
const PROXY = process.env.PROXY || '';

async function main() {
  const args = [
    '--disable-setuid-sandbox',
    `--bot-profile=${PROFILE}`,
  ];

  if (PROXY) {
    args.push(`--proxy-server=${PROXY}`);
  }

  const browser = await chromium.launch({
    executablePath: '/opt/botbrowser/chrome',
    args: args,
    headless: true,
  });

  try {
    const context = await browser.newContext();
    const page = await context.newPage();
    await page.goto('https://example.com');
    console.log('Title:', await page.title());

    // Votre logique d'automatisation ici

  } finally {
    await browser.close();
  }
}

// Gerer l'arret propre
process.on('SIGTERM', async () => {
  console.log('Received SIGTERM, shutting down...');
  process.exit(0);
});

process.on('SIGINT', async () => {
  console.log('Received SIGINT, shutting down...');
  process.exit(0);
});

main().catch(console.error);

Docker Compose pour plusieurs workers

version: '3.8'

services:
  worker-us:
    build: .
    shm_size: '2g'
    environment:
      - PROFILE=/opt/profiles/windows-chrome-131.enc
      - PROXY=socks5://user:pass@us-proxy.example.com:1080
    volumes:
      - ./profiles:/opt/profiles:ro
      - session-us:/data/session
    deploy:
      resources:
        limits:
          memory: 4g
          cpus: '2'
    restart: unless-stopped

  worker-eu:
    build: .
    shm_size: '2g'
    environment:
      - PROFILE=/opt/profiles/windows-chrome-132.enc
      - PROXY=socks5://user:pass@eu-proxy.example.com:1080
    volumes:
      - ./profiles:/opt/profiles:ro
      - session-eu:/data/session
    deploy:
      resources:
        limits:
          memory: 4g
          cpus: '2'
    restart: unless-stopped

volumes:
  session-us:
  session-eu:

Demarrer la flotte :

docker compose up -d
docker compose logs -f

Mettre a l'echelle un worker specifique :

docker compose up -d --scale worker-us=3

Montages de volumes

Montez les profils en volumes en lecture seule pour pouvoir les mettre a jour sans reconstruire l'image :

docker run --rm --shm-size=2g \
  -v /host/profiles:/opt/profiles:ro \
  -v /host/sessions/worker-1:/data/session \
  -e PROFILE=/opt/profiles/profile.enc \
  -e PROXY=socks5://user:pass@proxy:1080 \
  botbrowser-worker

Variables d'environnement

Utilisez des variables d'environnement pour la configuration par conteneur :

Variable	Description	Exemple
PROFILE	Chemin vers le fichier de profil dans le conteneur	/opt/profiles/win-chrome-131.enc
PROXY	URL du proxy avec identifiants	socks5://user:pass@proxy:1080
DISPLAY	Affichage X (defini dans le Dockerfile)	:10.0

Script d'entrypoint

Pour une logique de demarrage plus complexe, utilisez un script d'entrypoint :

#!/bin/bash
# entrypoint.sh

# Demarrer Xvfb
Xvfb :10 -screen 0 1920x1080x24 -ac &
XVFB_PID=$!

# Attendre que Xvfb soit pret
for i in $(seq 1 10); do
  if xdpyinfo -display :10 > /dev/null 2>&1; then
    break
  fi
  sleep 0.5
done

# Executer le script principal
exec node /opt/app/scripts/main.js

Mettre a jour le Dockerfile :

COPY entrypoint.sh /opt/app/
RUN chmod +x /opt/app/entrypoint.sh
ENTRYPOINT ["/opt/app/entrypoint.sh"]

Verification

Verifiez votre configuration Docker :

# Construire l'image
docker build -t botbrowser-worker .

# Executer avec un shell interactif pour le debogage
docker run --rm --shm-size=2g -it botbrowser-worker bash

# A l'interieur du conteneur :
Xvfb :10 -screen 0 1920x1080x24 &
export DISPLAY=:10.0
/opt/botbrowser/chrome --version
ldd /opt/botbrowser/chrome | grep "not found"

Aucune ligne "not found" ne devrait apparaitre. Executez une navigation de test :

docker run --rm --shm-size=2g botbrowser-worker

Verifiez la sortie pour le titre de page attendu et l'absence de messages d'erreur.

Bonnes pratiques

Definissez toujours --shm-size=2g ou plus. C'est le probleme le plus courant avec Docker + Chrome. Les 64 Mo par defaut sont insuffisants.

Utilisez --disable-setuid-sandbox dans les conteneurs. Les conteneurs Docker fonctionnent generalement sans les capacites kernel requises par le sandbox de Chrome.

Montez les profils en volumes en lecture seule. Cela separe les mises a jour de profils des constructions d'images et empeche les modifications accidentelles.

Definissez des limites de ressources. Utilisez les flags --memory et --cpus de Docker pour empecher tout conteneur de consommer toutes les ressources de l'hote.

Gerez SIGTERM pour un arret propre. Docker envoie SIGTERM lors de l'arret des conteneurs. Votre script doit fermer le navigateur et liberer les ressources.

Utilisez .dockerignore. Excluez node_modules, .git et les fichiers de developpement local du contexte de construction pour reduire la taille de l'image et le temps de construction.

Taguez les images avec des numeros de version. Utilisez botbrowser-worker:1.2.0 au lieu de :latest pour des deploiements reproductibles.

Questions frequentes

Pourquoi Chrome plante-t-il avec "out of memory" dans Docker ?

La cause la plus courante est une taille de /dev/shm insuffisante. Ajoutez --shm-size=2g a votre commande docker run. Si le conteneur lui-meme est limite en memoire, augmentez la limite avec --memory=4g.

Puis-je utiliser Alpine Linux au lieu d'Ubuntu ?

Les dependances de Chrome sont basees sur glibc. Alpine utilise musl libc, qui est incompatible. Restez avec des images basees sur Debian ou Ubuntu.

Comment mettre a jour les profils sans reconstruire l'image ?

Montez votre repertoire de profils comme volume : -v /host/profiles:/opt/profiles:ro. Mettez a jour les fichiers sur l'hote et redemarrez le conteneur.

Puis-je exposer le port de debogage distant ?

Oui. Utilisez -p 9222:9222 et ajoutez --remote-debugging-port=9222 aux flags de lancement de Chrome. Soyez prudent avec cela en production car le port de debogage donne un controle total sur le navigateur.

Comment voir les logs du conteneur ?

Utilisez docker logs <container-id> ou docker compose logs <service-name>. La sortie console.log de votre script apparait ici.

Quelle image de base utiliser ?

Ubuntu 22.04 LTS est le choix le plus teste et le plus fiable. Ubuntu 24.04 fonctionne avec des noms de paquets ajustes. Debian 12 (Bookworm) est egalement une option solide.

Puis-je executer plusieurs instances BotBrowser dans un seul conteneur ?

Oui, mais des conteneurs separes offrent une meilleure isolation et gestion des ressources. Si vous executez plusieurs instances dans un seul conteneur, assurez-vous que chacune a son propre --user-data-dir et --remote-debugging-port.

Comment gerer les processus zombie Chrome ?

Ajoutez --init a votre commande docker run pour utiliser le processus init de Docker, qui recupere les processus enfants orphelins. Alternativement, utilisez dumb-init ou tini dans votre Dockerfile.

Resume

Docker fournit le moyen le plus fiable et reproductible de deployer BotBrowser en production. Construisez votre image une fois avec toutes les dependances, utilisez des montages de volumes pour les profils et les donnees persistantes, et mettez a l'echelle avec Docker Compose ou des outils d'orchestration. L'exigence de configuration cle est une memoire partagee adequate (--shm-size=2g).

Pour la configuration bare metal, consultez Configuration de serveur headless. Pour l'optimisation des performances, consultez Optimiser les performances de BotBrowser. Pour la reference des flags CLI, consultez Recettes CLI.