Web Analytics Made Easy - Statcounter
Skip to content

DĂ©ploiement Docker

DĂ©ployez Duckling avec Docker pour une mise en place rapide et une isolation.

TL;DR – Démarrage en une commande

curl -O https://raw.githubusercontent.com/davidgs/duckling/main/docker-compose.prebuilt.yml && docker-compose -f docker-compose.prebuilt.yml up -d
Ouvrez ensuite http://localhost:3000 🎉

Prérequis

  • Docker 20.10+
  • Docker Compose 2.0+

DĂ©marrage rapide

Option 1 : Construire localement

# Cloner le dépôt
git clone https://github.com/davidgs/duckling.git
cd duckling

# Construire et démarrer (mode développement)
docker-compose up --build

# Ou exécuter en arrière-plan
docker-compose up -d --build

Option 2 : Utiliser des images préconstruites

# Télécharger docker-compose.prebuilt.yml
curl -O https://raw.githubusercontent.com/davidgs/duckling/main/docker-compose.prebuilt.yml

# Démarrer avec des images préconstruites
docker-compose -f docker-compose.prebuilt.yml up -d

Accédez à l’application sur http://localhost:3000

Fichiers Docker Compose

Duckling fournit plusieurs configurations Docker Compose :

Fichier RĂ´le
docker-compose.yml DĂ©veloppement avec builds locaux
docker-compose.prod.yml Surcharges production
docker-compose.prebuilt.yml Images préconstruites depuis le registre

DĂ©veloppement

docker-compose up --build

Production

docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Images préconstruites

# Registre par défaut (davidgs)
docker-compose -f docker-compose.prebuilt.yml up -d

# Registre personnalisé
DOCKER_REGISTRY=ghcr.io/yourusername docker-compose -f docker-compose.prebuilt.yml up -d

# Version spécifique
VERSION=1.0.0 docker-compose -f docker-compose.prebuilt.yml up -d

Construire les images Docker

Script de build

Utilisez le script de build fourni pour construire facilement les images. Le script construit automatiquement la documentation MkDocs avant les images Docker :

# Construire les images localement (inclut la doc)
./scripts/docker-build.sh

# Construire et pousser vers Docker Hub
./scripts/docker-build.sh --push

# Construire avec une version précise
./scripts/docker-build.sh --version 1.0.0

# Construire pour plusieurs plateformes (nécessite buildx)
./scripts/docker-build.sh --multi-platform --push

# Pousser vers un registre personnalisé
./scripts/docker-build.sh --push --registry ghcr.io/yourusername

# Ignorer la construction de la doc (utiliser site/ existant)
./scripts/docker-build.sh --skip-docs

Construction de la documentation

Le script de build exécute automatiquement mkdocs build pour que la documentation soit disponible dans les conteneurs Docker. Si MkDocs n’est pas installé, il tente pip install -r backend/requirements.txt avant la construction. L’image backend n’installe les dépendances qu’à partir de backend/requirements.txt.

Publication automatique (CI/CD)

Lorsqu’une pull request est fusionnée dans main, le workflow GitHub Actions Publish Docker Images s’exécute automatiquement. Il :

  1. Construit des images multi-plateformes (linux/amd64, linux/arm64)
  2. Pousse vers Docker Hub en {DOCKERHUB_USERNAME}/duckling-backend et {DOCKERHUB_USERNAME}/duckling-frontend
  3. Pousse vers GitHub Container Registry en ghcr.io/{owner}/duckling-backend et ghcr.io/{owner}/duckling-frontend

Les images sont étiquetées avec la version de frontend/package.json et latest.

Secrets du dépôt requis (Settings → Secrets and variables → Actions) :

Secret Description
DOCKERHUB_USERNAME Nom d’utilisateur Docker Hub
DOCKERHUB_TOKEN Jeton d’accès Docker Hub (ou mot de passe)

L’authentification GHCR utilise GITHUB_TOKEN, fourni automatiquement par GitHub Actions.

Build manuel

# Backend (cible production)
cd backend
docker build --target production -t duckling-backend:latest .

# Frontend
cd frontend
docker build --target production -t duckling-frontend:latest .

Variables d’environnement

Créez un fichier .env à la racine du projet :

# Sécurité (requis en production)
SECRET_KEY=your-very-secure-random-key-at-least-32-chars

# Configuration Flask
FLASK_ENV=production
DEBUG=False

# Facultatif : registre personnalisé pour images préconstruites
DOCKER_REGISTRY=davidgs
VERSION=latest

Sécurité

Définissez toujours une SECRET_KEY forte en production. Générez-en une avec : 

python -c "import secrets; print(secrets.token_hex(32))"

GĂ©rer les conteneurs

Voir l’état

# État des conteneurs
docker-compose ps

# Utilisation des ressources
docker stats

Voir les journaux

# Tous les services
docker-compose logs -f

# Service précis
docker-compose logs -f backend

# 100 dernières lignes
docker-compose logs --tail=100 backend

ArrĂŞter les services

# ArrĂŞter les conteneurs
docker-compose down

# ArrĂŞter et supprimer les volumes
docker-compose down -v

# ArrĂŞter et supprimer les images
docker-compose down --rmi all

Redémarrer les services

# Tout redémarrer
docker-compose restart

# Redémarrer un service précis
docker-compose restart backend

Prise en charge GPU

Pour l’OCR accéléré par GPU avec des GPU NVIDIA :

# docker-compose.gpu.yml
version: '3.8'

services:
  backend:
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - NVIDIA_VISIBLE_DEVICES=all

Exécution :

docker-compose -f docker-compose.yml -f docker-compose.gpu.yml up

NVIDIA Container Toolkit

La prise en charge GPU nécessite le NVIDIA Container Toolkit.

Stockage persistant

Par défaut (montages liés)

volumes:
  - ./uploads:/app/uploads
  - ./outputs:/app/outputs

Volumes nommés (recommandé en production)

services:
  backend:
    volumes:
      - duckling-uploads:/app/uploads
      - duckling-outputs:/app/outputs
      - duckling-data:/app/data

volumes:
  duckling-uploads:
  duckling-outputs:
  duckling-data:

Sauvegarder les données

# Sauvegarder les volumes
docker run --rm -v duckling-outputs:/data -v $(pwd):/backup alpine tar cvf /backup/outputs-backup.tar /data

# Restaurer les volumes
docker run --rm -v duckling-outputs:/data -v $(pwd):/backup alpine tar xvf /backup/outputs-backup.tar -C /

Vérifications d’intégrité (health checks)

Les deux conteneurs incluent des health checks :

# VĂ©rifier le backend
curl http://localhost:5001/api/health
# RĂ©ponse : {"status": "healthy", "service": "duckling-backend"}

# VĂ©rifier le frontend (renvoie du HTML)
curl -I http://localhost:3000
# RĂ©ponse : HTTP/1.1 200 OK

Docker Compose attend les health checks :

frontend:
  depends_on:
    backend:
      condition: service_healthy

Limites de ressources

La configuration de production inclut des limites de ressources :

services:
  backend:
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G
        reservations:
          cpus: '0.5'
          memory: 1G

  frontend:
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M

RĂ©seau

Les services communiquent sur un réseau bridge :

networks:
  duckling-network:
    driver: bridge

Le frontend proxifie les requĂŞtes API vers le backend :

Navigateur → Frontend (nginx:3000) → Backend (flask:5001)

DĂ©pannage

Le conteneur ne démarre pas

# Consulter les journaux
docker-compose logs backend

# Vérifier l’état des conteneurs
docker-compose ps

# Inspecter le conteneur
docker inspect duckling-backend

Conflits de ports

Modifiez les ports dans docker-compose.yml :

services:
  backend:
    ports:
      - "5002:5001"  # Port externe modifié
  frontend:
    ports:
      - "8080:3000"  # Port externe modifié

Échecs de build

# Vider le cache de build
docker builder prune

# Reconstruire sans cache
docker-compose build --no-cache

Problèmes de mémoire

# Vérifier l’utilisation mémoire
docker stats

# Augmenter la limite mémoire Docker (Docker Desktop)
# Settings → Resources → Memory

Problèmes réseau

# Lister les réseaux
docker network ls

# Inspecter le réseau
docker network inspect duckling_duckling-network

# Recréer le réseau
docker-compose down
docker network prune
docker-compose up

Étapes suivantes