Skip to content

docker

Jump to bottom
GitHub Actions edited this page Feb 3, 2026 · 1 revision

🐳 Docker & Containerisation

Guide complet pour dockeriser vos applications et configurer la communication inter-services

📋 Table des Matières

  1. Vue d'ensemble
  2. Wizard Docker
  3. Dockerfiles par Stack
  4. Docker Compose
  5. Communication Inter-Services
  6. Services Additionnels
  7. Bonnes Pratiques
  8. Dépannage

Vue d'ensemble

L'AI Agent Kit fournit un système complet de containerisation Docker permettant :

  • Dockerfiles optimisés pour chaque stack technique (9 stacks supportés)
  • Docker Compose pour orchestrer plusieurs services
  • Réseau bridge pour la communication inter-services
  • Services additionnels pré-configurés (bases de données, cache, etc.)
  • Wizard de configuration pour une mise en place guidée

Architecture Docker

┌─────────────────────────────────────────────────────────────┐
│                       app-network                           │
│                                                             │
│  ┌───────────┐     ┌───────────┐    ┌───────────────────┐   │
│  │  Frontend │───▶│  Backend  │───▶│     Database      │   │
│  │   :3000   │     │   :5000   │    │      :5432        │   │
│  └───────────┘     └───────────┘    └───────────────────┘   │
│       │                │                    │               │
│       │                │                    │               │
│       ▼                ▼                    ▼               │
│   http://          http://           postgresql://          │
│   frontend:3000    backend:5000      postgres:5432          │
│                                                             │
│  ┌───────────┐    ┌───────────┐    ┌───────────────────┐    │
│  │   Redis   │    │ RabbitMQ  │    │   Elasticsearch   │    │
│  │   :6379   │    │   :5672   │    │      :9200        │    │
│  └───────────┘    └───────────┘    └───────────────────┘    │
└─────────────────────────────────────────────────────────────┘

Wizard Docker

Le wizard Docker (docker-setup.wizard.yaml) guide la configuration interactive.

Localisation

.ai-agents/wizards/docker-setup.wizard.yaml

Étapes du Wizard

  1. Type d'application

    • Frontend (React, Angular, Vue)
    • Backend API (.NET, Node.js, Python)
    • Fullstack (Frontend + Backend)
    • Microservices (Multiple services)

  2. Stack technique

    • Sélection du framework backend/frontend
    • Versions supportées

  3. Services additionnels

    • Bases de données (PostgreSQL, MySQL, MongoDB)
    • Cache (Redis)
    • Message Queue (RabbitMQ)
    • Search (Elasticsearch)
    • Storage (MinIO)
    • Dev tools (MailHog)

  4. Configuration réseau

    • Nom du réseau Docker
    • Health checks
    • Traefik (optionnel)

  5. Détails du projet

    • Nom du projet
    • Environnement cible

Exemple d'Utilisation

# Le wizard génère automatiquement :
# - Dockerfile(s)
# - docker-compose.yml
# - .dockerignore
# - .env.example

Dockerfiles par Stack

Backend

.NET (ASP.NET Core)

# templates/docker/Dockerfile.dotnet.template
FROM mcr.microsoft.com/dotnet/sdk:9.0-alpine AS build
# Multi-stage build avec restauration cached
# Image finale: aspnet:9.0-alpine (~80MB)

Caractéristiques :

  • Multi-stage build (SDK → Runtime)
  • Image Alpine légère
  • Utilisateur non-root
  • Health check intégré

Node.js (TypeScript)

# templates/docker/Dockerfile.nodejs.template
FROM node:22-alpine AS build
# pnpm pour gestion des dépendances
# Pruning des dev dependencies

Caractéristiques :

  • pnpm (plus rapide que npm)
  • Multi-stage build
  • Node 22 Alpine (~50MB)

Python (FastAPI)

# templates/docker/Dockerfile.python.template
FROM python:3.12-slim AS build
# uv pour installation rapide des packages
# uvicorn pour le serveur ASGI

Caractéristiques :

  • uv package manager (10x plus rapide que pip)
  • Image slim
  • uvicorn ASGI server

Go

# templates/docker/Dockerfile.go.template
FROM golang:1.22-alpine AS build
# Compilation statique
# Image finale: scratch (0MB base)

Caractéristiques :

  • Compilation statique (CGO_ENABLED=0)
  • Image scratch (binaire seul ~5-10MB)
  • Minimal attack surface

Java (Spring Boot)

# templates/docker/Dockerfile.java.template
FROM eclipse-temurin:21-jdk-alpine AS build
# Layered jars pour caching optimisé
# JVM avec support containers

Caractéristiques :

  • Layered jars (cache des dépendances)
  • Eclipse Temurin JRE
  • Support -XX:+UseContainerSupport

Rust

# templates/docker/Dockerfile.rust.template
FROM rust:1.76-alpine AS build
# cargo-chef pour caching des dépendances
# Image Alpine finale

Caractéristiques :

  • cargo-chef (dependency caching)
  • musl libc (fully static)
  • Image Alpine ou scratch

Frontend

React / Next.js

# templates/docker/Dockerfile.react.template
FROM node:22-alpine AS build
# Next.js standalone mode
# Output optimisé pour production

Caractéristiques :

  • Next.js standalone output
  • Static file serving
  • Health check API

Angular

# templates/docker/Dockerfile.angular.template
FROM node:22-alpine AS build
# Angular CLI build
FROM nginx:alpine AS runtime
# Nginx avec SPA routing

Caractéristiques :

  • Build Angular optimisé
  • Nginx pour serving statique
  • Configuration SPA (try_files)

Vue.js

# templates/docker/Dockerfile.vue.template
FROM node:22-alpine AS build
# Vite build
FROM nginx:alpine AS runtime
# Nginx avec Vue Router support

Caractéristiques :

  • Vite pour build rapide
  • Nginx configuration
  • Gzip compression

Docker Compose

Fichiers Disponibles

Template Usage
docker-compose.yaml.template Application simple
docker-compose.fullstack.yaml.template Frontend + Backend + DB
docker-compose.microservices.yaml.template Architecture microservices

Fullstack Example

# docker-compose.yml (généré)
version: "3.8"

networks:
  app-network:
    driver: bridge

services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    environment:
      - API_URL=http://backend:5000
    depends_on:
      - backend

  backend:
    build: ./backend
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/myapp
    depends_on:
      postgres:
        condition: service_healthy

  postgres:
    image: postgres:16-alpine
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready"]

volumes:
  postgres_data:

Commandes Essentielles

# Démarrer tous les services
docker compose up -d

# Démarrer avec rebuild
docker compose up -d --build

# Voir les logs (tous les services)
docker compose logs -f

# Voir les logs d'un service
docker compose logs -f backend

# Arrêter tous les services
docker compose down

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

# Reconstruire un service spécifique
docker compose build backend
docker compose up -d backend

# Scaler un service
docker compose up -d --scale backend=3

Communication Inter-Services

Principe

Dans un réseau Docker bridge, les services peuvent se contacter par leur nom de service comme hostname.

Exemples de Configuration

Frontend → Backend

// Dans le frontend (Next.js SSR)
const apiUrl = process.env.API_URL; // http://backend:5000

// Appel API
const response = await fetch(`${apiUrl}/api/users`);
// Angular service
@Injectable()
export class ApiService {
  private apiUrl = environment.apiUrl; // http://backend:5000

  getUsers() {
    return this.http.get(`${this.apiUrl}/api/users`);
  }
}

Backend → Database

// .NET appsettings.json (via env var)
{
  "ConnectionStrings": {
    "DefaultConnection": "Host=postgres;Database=myapp;Username=postgres;Password=postgres"
  }
}
# Python FastAPI
DATABASE_URL = os.environ["DATABASE_URL"]
# postgresql://postgres:postgres@postgres:5432/myapp
// Node.js TypeORM
const connection = await createConnection({
  type: "postgres",
  host: "postgres",  // Nom du service Docker
  port: 5432,
  database: process.env.DB_NAME,
});

Backend → Redis

# Python
import redis
r = redis.from_url("redis://redis:6379")
// Node.js
import Redis from 'ioredis';
const redis = new Redis({ host: 'redis', port: 6379 });

Variables d'Environnement

Le fichier .env.docker généré contient toutes les URLs de services :

# Database
DATABASE_URL=postgresql://postgres:postgres@postgres:5432/myapp

# Redis
REDIS_URL=redis://redis:6379

# RabbitMQ
RABBITMQ_URL=amqp://guest:guest@rabbitmq:5672

# Elasticsearch
ELASTICSEARCH_URL=http://elasticsearch:9200

# Services
BACKEND_URL=http://backend:5000
FRONTEND_URL=http://frontend:3000

Services Additionnels

PostgreSQL

postgres:
  image: postgres:16-alpine
  environment:
    POSTGRES_USER: postgres
    POSTGRES_PASSWORD: postgres
    POSTGRES_DB: myapp
  volumes:
    - postgres_data:/var/lib/postgresql/data
  healthcheck:
    test: ["CMD", "pg_isready", "-U", "postgres"]

MySQL

mysql:
  image: mysql:8.0
  environment:
    MYSQL_ROOT_PASSWORD: root
    MYSQL_DATABASE: myapp
  volumes:
    - mysql_data:/var/lib/mysql
  healthcheck:
    test: ["CMD", "mysqladmin", "ping"]

MongoDB

mongodb:
  image: mongo:7.0
  environment:
    MONGO_INITDB_ROOT_USERNAME: mongo
    MONGO_INITDB_ROOT_PASSWORD: mongo
  volumes:
    - mongodb_data:/data/db

Redis

redis:
  image: redis:7-alpine
  command: redis-server --appendonly yes
  volumes:
    - redis_data:/data
  healthcheck:
    test: ["CMD", "redis-cli", "ping"]

RabbitMQ

rabbitmq:
  image: rabbitmq:3-management-alpine
  ports:
    - "5672:5672"    # AMQP
    - "15672:15672"  # Management UI
  environment:
    RABBITMQ_DEFAULT_USER: guest
    RABBITMQ_DEFAULT_PASS: guest

Elasticsearch

elasticsearch:
  image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
  environment:
    - discovery.type=single-node
    - xpack.security.enabled=false
    - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
  volumes:
    - elasticsearch_data:/usr/share/elasticsearch/data

MinIO (S3 Compatible)

minio:
  image: minio/minio:latest
  ports:
    - "9000:9000"   # API
    - "9001:9001"   # Console
  environment:
    MINIO_ROOT_USER: minioadmin
    MINIO_ROOT_PASSWORD: minioadmin
  command: server /data --console-address ":9001"
  volumes:
    - minio_data:/data

MailHog (Email Testing)

mailhog:
  image: mailhog/mailhog:latest
  ports:
    - "1025:1025"   # SMTP
    - "8025:8025"   # Web UI

Bonnes Pratiques

1. Sécurité

  • ✅ Utilisez des utilisateurs non-root dans les containers
  • ✅ Ne stockez jamais de secrets en dur (utilisez des variables d'environnement)
  • ✅ Utilisez des images officielles et maintenez-les à jour
  • ✅ Activez les health checks pour tous les services

2. Performance

  • ✅ Utilisez le multi-stage build pour réduire la taille des images
  • ✅ Ordonnez les instructions Dockerfile pour maximiser le cache
  • ✅ Utilisez .dockerignore pour exclure les fichiers inutiles
  • ✅ Choisissez des images Alpine quand possible

3. Développement

# docker-compose.override.yml (dev only)
services:
  backend:
    volumes:
      - ./backend/src:/app/src  # Hot reload
    environment:
      - NODE_ENV=development

4. Production

  • ✅ Utilisez des tags de version spécifiques (pas latest)
  • ✅ Configurez les limites de ressources
  • ✅ Activez restart: unless-stopped
  • ✅ Utilisez un reverse proxy (Traefik, Nginx)

Dépannage

Container ne démarre pas

# Voir les logs
docker compose logs backend

# Voir les logs en temps réel
docker compose logs -f backend

# Inspecter le container
docker inspect myapp_backend

Problèmes de réseau

# Lister les réseaux
docker network ls

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

# Tester la connectivité
docker compose exec backend ping postgres

Problèmes de build

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

# Voir les étapes de build
docker compose build --progress=plain

Nettoyage

# Supprimer les containers arrêtés
docker container prune

# Supprimer les images non utilisées
docker image prune

# Supprimer les volumes non utilisés
docker volume prune

# Nettoyage complet
docker system prune -a --volumes

Fichiers Générés

Après utilisation du wizard ou des scaffolds avec Docker :

mon-projet/
├── docker-compose.yml       # Orchestration des services
├── .dockerignore            # Fichiers exclus du build
├── .env.example             # Template des variables d'environnement
├── backend/
│   └── Dockerfile           # Build du backend
└── frontend/
    └── Dockerfile           # Build du frontend

Ressources

💡 Conseil : Commencez avec le wizard Docker pour une configuration guidée, puis personnalisez les fichiers générés selon vos besoins.

Dernière mise à jour : 3 février 2026

📚 Ressources

🤝 Contribuer

Les contributions sont bienvenues ! Voir CONTRIBUTING.md

This documentation is automatically synced from the main repository.

Navigation

Clone this wiki locally