Deployer une application multi-conteneurs avec Docker Compose en 2026

Docker Compose v5.1.3 permet de lancer une stack complete (API, base de donnees, cache) en une seule commande docker compose up -d. Ce guide vous fait construire et deployer une application Node.js + PostgreSQL + Redis en moins de 30 minutes. Version 5.1.3 — Documentation officielle.

Ce que vous allez construire et pourquoi en 2026

Vous allez deployer une application web composee de 3 conteneurs : une API Node.js/Express sur le port 3000, une base PostgreSQL 16 sur le port 5432, et un cache Redis 7 sur le port 6379. Docker Compose orchestre le reseau, les volumes persistants, l'ordre de demarrage et les variables d'environnement — tout depuis un seul fichier compose.yaml. En 2026, Compose V2 est le standard (V1 est abandonne), le format de fichier est passe a la spec Compose v1.0+, et les commandes utilisent le plugin docker compose (sans tiret).

Installation : commandes exactes a copier

Sur Ubuntu/Debian (methode recommandee)

# Ajouter le depot Docker officiel
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin # Verifier
docker compose version
# Docker Compose version v5.1.3

Sur macOS / Windows

# Installer Docker Desktop qui inclut Compose
# macOS : https://docs.docker.com/desktop/setup/install/mac/
# Windows : https://docs.docker.com/desktop/setup/install/windows/ # Verifier apres installation
docker compose version

Installation manuelle sur Linux (sans depot)

mkdir -p ~/.docker/cli-plugins
curl -SL https://github.com/docker/compose/releases/download/v5.1.3/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose
chmod +x ~/.docker/cli-plugins/docker-compose
docker compose version

Configuration : fichiers et variables a definir

Creer un repertoire de projet et les fichiers suivants :

# Structure du projet
mon-app/
├── compose.yaml
├── .env
├── app/
│ ├── Dockerfile
│ ├── package.json
│ └── index.js

Fichier .env (variables d'environnement)

POSTGRES_USER=appuser
POSTGRES_PASSWORD=Ch4ng3M3!2026
POSTGRES_DB=appdb
DATABASE_URL=postgresql://appuser:Ch4ng3M3!2026@db:5432/appdb
REDIS_URL=redis://cache:6379
NODE_ENV=production
PORT=3000

Fichier compose.yaml

services: api: build: context: ./app dockerfile: Dockerfile ports: - "3000:3000" environment: - DATABASE_URL=${DATABASE_URL} - REDIS_URL=${REDIS_URL} - NODE_ENV=${NODE_ENV} depends_on: db: condition: service_healthy cache: condition: service_started restart: unless-stopped healthcheck: test: ["CMD", "curl", "-f", "http://localhost:3000/health"] interval: 30s timeout: 10s retries: 3 db: image: postgres:16-alpine ports: - "5432:5432" environment: - POSTGRES_USER=${POSTGRES_USER} - POSTGRES_PASSWORD=${POSTGRES_PASSWORD} - POSTGRES_DB=${POSTGRES_DB} volumes: - pgdata:/var/lib/postgresql/data restart: unless-stopped healthcheck: test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"] interval: 10s timeout: 5s retries: 5 cache: image: redis:7-alpine ports: - "6379:6379" restart: unless-stopped healthcheck: test: ["CMD", "redis-cli", "ping"] interval: 10s timeout: 5s retries: 3 volumes: pgdata:

Le code du projet : construire la fonctionnalite principale

app/package.json

{ "name": "mon-app-api", "version": "1.0.0", "main": "index.js", "scripts": { "start": "node index.js" }, "dependencies": { "express": "^4.21.0", "pg": "^8.13.0", "ioredis": "^5.4.0" }
}

app/Dockerfile

FROM node:20-alpine
WORKDIR /app
COPY package.json ./
RUN npm install --omit=dev
COPY .
EXPOSE 3000
CMD ["node", "index.js"]

app/index.js — API Express avec PostgreSQL et Redis

const express = require('express');
const { Pool } = require('pg');
const Redis = require('ioredis'); const app = express();
app.use(express.json()); const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const redis = new Redis(process.env.REDIS_URL); // Health check
app.get('/health', (req, res) => res.json({ status: 'ok' })); // Creer une note avec cache
app.post('/notes', async (req, res) => { const { title, content } = req.body; if (!title) return res.status(400).json({ error: 'title requis' }); const result = await pool.query( 'INSERT INTO notes (title, content) VALUES ($1, $2) RETURNING *', [title, content || null] ); await redis.del('notes:all'); res.status(201).json(result.rows[0]);
}); // Lister les notes avec cache Redis
app.get('/notes', async (req, res) => { const cached = await redis.get('notes:all'); if (cached) return res.json(JSON.parse(cached)); const result = await pool.query('SELECT * FROM notes ORDER BY id DESC'); await redis.set('notes:all', JSON.stringify(result.rows), 'EX', 60); res.json(result.rows);
}); // Initialiser la table au demarrage
pool.query(` CREATE TABLE IF NOT EXISTS notes ( id SERIAL PRIMARY KEY, title TEXT NOT NULL, content TEXT, created_at TIMESTAMPTZ DEFAULT NOW() )
`).then(() => console.log('Table notes prete')); app.listen(process.env.PORT || 3000, () => console.log('API demarree sur le port ' + (process.env.PORT || 3000)));

Tester et valider que ca fonctionne

# Lancer tous les conteneurs
docker compose up -d --build # Verifier que les 3 services tournent
docker compose ps
# NAME STATUS PORTS
# mon-app-api-1 Up (healthy) 0.0.0.0:3000->3000/tcp
# mon-app-db-1 Up (healthy) 0.0.0.0:5432->5432/tcp
# mon-app-cache-1 Up (healthy) 0.0.0.0:6379->6379/tcp # Tester l'API
curl http://localhost:3000/health
# {"status":"ok"} # Creer une note
curl -X POST http://localhost:3000/notes -H 'Content-Type: application/json' -d '{"title":"Premiere note","content":"Test Docker Compose"}' # Lister les notes (verifie cache Redis)
curl http://localhost:3000/notes # Voir les logs
docker compose logs -f api # Arreter proprement
docker compose down # Arreter et supprimer les volumes
docker compose down -v

Deployer et utiliser en production

Pour la production, ajoutez ces bonnes pratiques :

# 1. Utiliser un fichier compose.prod.yaml pour les overrides
docker compose -f compose.yaml -f compose.prod.yaml up -d # 2. Limiter les ressources par service
services: api: deploy: resources: limits: cpus: '1.0' memory: 512M # 3. Configurer les logs pour eviter le plein disque
services: api: logging: driver: json-file options: max-size: "10m" max-file: "3" # 4. Utiliser des secrets Docker (pas de .env en clair)
echo "Ch4ng3M3!2026" | docker secret create db_password - # 5. Mettre a jour un seul service sans coupure
docker compose up -d --no-deps --build api

Aller plus loin : 3 extensions concretes

1. Ajouter un reverse proxy Nginx avec SSL automatique — Utilisez nginx-proxy + letsencrypt companion pour le HTTPS automatise. Ajoutez un service proxy dans votre compose.yaml avec les labels letsencrypt.host sur chaque service web.

2. Ajouter un monitoring avec Prometheus + Grafana — Ajoutez 2 services dans votre compose.yaml : prometheus avec l'image prom/prometheus et grafana avec l'image grafana/grafana. Exposez les metrics Express via prom-client (npm install prom-client) sur /metrics.

3. Configurer un CI/CD avec GitHub Actions — Utilisez docker/build-push-action dans votre workflow YAML pour builder et pousser les images sur Docker Hub ou GitHub Container Registry, puis deployez avec docker compose pull && docker compose up -d sur votre serveur via SSH.