TP2e année7 livrables
Conteneurs & Docker Compose
« Ça marche chez moi » — la phrase qui hante les déploiements. Docker y répond : il empaquette ton application avec tout son environnement, pour qu'elle tourne à l'identique partout. Aujourd'hui tu conteneurises AppliFrais (API + base + front) et tu l'orchestres d'une seule commande avec Docker Compose. La reproductibilité, enfin.
Par Josselyn C., prof de BTS SIO. Publié le .
- Objectif
- conteneuriser AppliFrais et orchestrer ses services avec Docker Compose
- On manipule
- Docker, un Dockerfile, un docker-compose.yml, des volumes/réseaux
- Pré-requis
- AppliFrais (API Node, Mongo), notions de terminal
- Pour qui
- SLAM, 2e année
- Durée
- 1 séance
Compétences : C1.5 Mettre à disposition des utilisateurs un service informatique, C1.1 Gérer le patrimoine informatique
Conteneuriser = rendre un service portable et reproductible : une compétence clé de la mise à disposition.
Avant de commencer
Pourquoi cette séance
Tu as déployé AppliFrais « à la main » sur un serveur. Problème : reproduire ce déploiement ailleurs (un autre serveur, un collègue, la prod) implique de réinstaller Node, Mongo, les bonnes versions, la config… et le moindre écart casse tout. Docker résout ça : il empaquette chaque service (l'API, la base, le front) dans un conteneur autonome, qui embarque tout son environnement. Le conteneur tourne à l'identique sur n'importe quelle machine qui a Docker. Docker Compose orchestre ensuite plusieurs conteneurs ensemble avec une seule commande. C'est la reproductibilité, et un grand classique de la mise à disposition de services (Bloc 1).
Comment avancer en autonomie
Vérifier que Docker est installé
docker --version
docker compose version
Docker version 24.0.7, build afdd53b
Docker Compose version v2.23.3
Ce que tu vas apprendre
| Concept | Ce que tu sauras faire |
|---|---|
| Conteneur vs VM | comprendre ce qu'est (et n'est pas) un conteneur |
| Image & Dockerfile | fabriquer l'image de ton API et la lancer |
| .dockerignore & images légères | une image petite, sans secret, à faible surface d'attaque |
| Docker Compose | orchestrer plusieurs services d'un coup |
| Volumes & réseaux | persister les données, faire communiquer les conteneurs |
| Variables d'env | configurer proprement (pas de secret en dur) |
0. C'est quoi un conteneur ?
Un conteneur est un paquet léger et isolé qui contient ton application et tout ce dont elle a besoin pour tourner (le runtime, les librairies, la config). Métaphore : un conteneur de transport — peu importe le navire (la machine), son contenu voyage à l'identique.
| Machine virtuelle (VM) | Conteneur | |
|---|---|---|
| Embarque | un OS entier + l'app (boot complet) | l'app + ses libs seulement (partage le noyau Linux de l'hôte) |
| Poids typique | 2–20 Go (OS + app) | 50–500 Mo — node:20-alpine = 142 Mo ; mongo:7 = 220 Mo |
| Démarrage | 1–3 min (boot BIOS → OS → app) | 0,1–5 s (juste un process à lancer) |
| Isolation | forte : hyperviseur, OS séparé | bonne : namespaces Linux (PID, réseau, FS, users) + cgroups (CPU/RAM limités) |
| Combien sur 8 Go RAM | 2–4 VM (chaque OS consomme 1–2 Go) | 20–100 conteneurs (partagent l'OS) |
| Quand choisir | OS différents requis, isolation maximale, legacy Windows | microservices, CI/CD, déploiement d'app — le cas AppliFrais |
Le vocabulaire de base
| Terme | Définition |
|---|---|
| Image | le « moule » : un modèle figé de l'app + son environnement |
| Conteneur | une instance qui tourne, créée à partir d'une image |
| Dockerfile | la recette qui décrit comment construire une image |
| Registry | un dépôt d'images en ligne (Docker Hub par défaut) |
Ces quatre mots décrivent un cycle : on écrit un Dockerfile, on le construit (build) en une image, et on lance (run) cette image en un conteneur qui tourne.
Flag A1
Checkpoint
Avec tes mots :
• différence entre une image et un conteneur ?
• différence entre une VM et un conteneur ?
• pour AppliFrais, liste les services à conteneuriser (API, base, front, stockage S3).
Rends : tes réponses + la liste des conteneurs.
1. Le Dockerfile de l'API
On fabrique l'image de l'API AppliFrais. Le Dockerfile décrit, étape par étape, comment construire cette image. On le crée à la racine de l'API (le dossier qui contient package.json et server.js).
Le Dockerfile, instruction par instruction
# Dockerfile (a la racine de l'API)
FROM node:20-alpine # (1) image de base : Node 20, version legere "alpine"
WORKDIR /app # (2) dossier de travail dans le conteneur
COPY package*.json ./ # (3) on copie d'abord les manifestes
RUN npm ci --omit=dev # (4) on installe les deps de prod (reproductible)
COPY . . # (5) on copie le reste du code
EXPOSE 3000 # (6) le port que l'app ecoute
CMD ["node", "server.js"] # (7) la commande de demarrage
Construire l'image
docker build -t appli-frais-api .
[+] Building 18.4s (10/10) FINISHED
=> [internal] load build definition from Dockerfile 0.0s
=> [internal] load .dockerignore 0.0s
=> [internal] load metadata for node:20-alpine 1.2s
=> [1/5] FROM docker.io/library/node:20-alpine 3.1s
=> [2/5] WORKDIR /app 0.2s
=> [3/5] COPY package*.json ./ 0.0s
=> [4/5] RUN npm ci --omit=dev 12.0s
=> [5/5] COPY . . 0.1s
=> exporting to image 0.4s
=> => naming to docker.io/library/appli-frais-api 0.0s
Les 5 étapes [1/5] à [5/5] correspondent aux 5 instructions qui produisent une couche. Au 2e build (sans changer package.json), tu verras CACHED sur les couches 1 à 4 : c'est le cache qui fait son travail.
Vérifier l'image et son poids
docker images appli-frais-api
REPOSITORY TAG IMAGE ID CREATED SIZE
appli-frais-api latest a1b2c3d4e5f6 12 seconds ago 142MB
Lancer le conteneur
docker run -p 3000:3000 appli-frais-api
> appli-frais-api@1.0.0 start
> node server.js
API AppliFrais a l'ecoute sur le port 3000
[attention] MongoDB injoignable : mongodb://localhost:27017 ECONNREFUSED
Sécuriser l'image : ne pas lancer l'app en root
Par défaut, les processus d'un conteneur tournent en tant que root (UID 0). Si l'app est compromise (faille injection, dépendance vulnérable), l'attaquant se retrouve root dans le conteneur — et potentiellement sur l'hôte si une mauvaise config laisse passer. La bonne pratique : créer un utilisateur dédié non-privilégié.
# Dockerfile (version sécurisée — ajout de USER après npm ci)
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY --chown=node:node . . # copie les fichiers avec le bon propriétaire d'emblée
USER node # node:20-alpine crée déjà l'utilisateur "node" (UID 1000)
EXPOSE 3000
CMD ["node", "server.js"]
Flag B1
Production (Dockerfile)
Écris le Dockerfile de l'API AppliFrais, construis l'image et lance le conteneur.
Rends : ton Dockerfile + la sortie de docker build + la sortie de docker images (poids de l'image) + la preuve que le conteneur démarre.
2. .dockerignore & images légères
Deux réflexes de pro, souvent oubliés, qui font la différence entre une image amateur et une image propre.
1. Le .dockerignore : ne pas tout copier
Le COPY . . du Dockerfile copie tout le dossier dans l'image… y compris des choses qu'il ne faut surtout pas embarquer. Le fichier .dockerignore (à côté du Dockerfile) liste ce qu'on exclut, exactement comme un .gitignore.
# .dockerignore (a la racine de l'API)
node_modules # reinstalle proprement dans l'image (RUN npm ci)
.env # SECRETS : jamais dans une image !
.git # historique git inutile et lourd
npm-debug.log # logs locaux
Dockerfile # pas besoin de se copier lui-meme
.dockerignore
Le piège invisible : un secret reste dans les couches
Même si tu fais RUN rm .env dans une instruction suivante, le fichier est toujours là dans la couche précédente. Docker superpose les couches mais ne les efface pas rétroactivement. Un attaquant qui a accès à l'image peut inspecter chaque couche avec cette commande.
docker history --no-trunc appli-frais-api
IMAGE CREATED CREATED BY SIZE
a1b2c3d4e5f6 2 min ago CMD ["node" "server.js"] 0B
<missing> 2 min ago EXPOSE 3000/tcp 0B
<missing> 2 min ago COPY . . # buildkit 4.2MB
<missing> 2 min ago RUN npm ci --omit=dev 38MB
<missing> 2 min ago COPY package*.json ./ 42kB
<missing> 2 min ago WORKDIR /app 0B
<missing> 3 weeks ago /bin/sh -c #(nop) CMD ["node"] 0B
...
2. Une image légère = moins de surface d'attaque
| Choix | Effet |
|---|---|
image de base alpine | ≈ 5 Mo de base au lieu de ~400 Mo : moins de paquets installés |
npm ci --omit=dev | pas les outils de test/build dans l'image de prod |
.dockerignore | pas de fichiers parasites ni de secrets |
Flag D1
Investigation
Va sur Docker Hub (hub.docker.com) et réponds :
• quelle est la différence de taille entre node:20 et node:20-alpine ?
• qu'est-ce qu'un tag d'image (ex. 20, 20-alpine, latest) et pourquoi figer une version plutôt que latest ?
• cherche « multi-stage build » : en une phrase, à quoi ça sert ?
Rends : tes 3 réponses, avec la source consultée.
3. Orchestrer avec Docker Compose
AppliFrais n'est pas un service : c'est l'API + la base Mongo (+ le front, + le stockage S3). Les lancer et les relier un par un, à la main, est pénible et source d'erreurs. Docker Compose décrit tous les services dans un seul fichier docker-compose.yml et les lance ensemble.
Le fichier docker-compose.yml
# docker-compose.yml (a la racine du projet)
services:
api:
build: ./api # construit depuis le Dockerfile de l'API
ports:
- "3000:3000" # publie le port de l'API vers l'hote
environment:
MONGO_URI: mongodb://mongo:27017/appliFrais # "mongo" = nom du service
JWT_SECRET: ${JWT_SECRET} # injecte depuis le .env
depends_on:
mongo:
condition: service_healthy # attend que mongo soit VRAIMENT pret
restart: unless-stopped # redemarrage automatique sauf si tu le stoppes
mongo:
image: mongo:7 # image officielle, rien a construire
# PAS de "ports:" ici : mongo n'est joignable que par l'API (securite)
volumes:
- mongo-data:/data/db # persistance des donnees
restart: unless-stopped
healthcheck:
test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
interval: 10s # on verifie toutes les 10 secondes
timeout: 5s # echec si pas de reponse en 5 s
retries: 3 # 3 echecs = service "unhealthy"
start_period: 20s # grace period au demarrage (Mongo met ~15 s)
volumes:
mongo-data: # volume nomme (survit aux redemarrages)
Valider la configuration avant de lancer
docker compose config
name: applifrais
services:
api:
build:
context: /home/user/applifrais/api
environment:
JWT_SECRET: mon-super-secret
MONGO_URI: mongodb://mongo:27017/appliFrais
...
mongo:
healthcheck:
interval: 10s
...
image: mongo:7
Le fichier .env (les secrets, hors du code)
# .env (a la racine, exclu par .gitignore ET .dockerignore)
JWT_SECRET=un-secret-long-et-aleatoire-genere-au-hasard
L'architecture orchestrée
Tout lancer d'une seule commande
docker compose up -d
[+] Running 4/4
Network applifrais_default Created 0.1s
Volume "applifrais_mongo-data" Created 0.0s
Container applifrais-mongo-1 Started 0.9s
Container applifrais-api-1 Started 1.1s
Voir l'état des services
docker compose ps
NAME IMAGE SERVICE STATUS PORTS
applifrais-api-1 applifrais-api api Up 20 seconds 0.0.0.0:3000->3000/tcp
applifrais-mongo-1 mongo:7 mongo Up 21 seconds 27017/tcp
Lire les logs, puis arrêter
docker compose logs api # voir ce que l'API affiche
docker compose down # tout arreter (le volume reste)
# logs api :
API AppliFrais a l'ecoute sur le port 3000
MongoDB connecte : mongodb://mongo:27017/appliFrais
# down :
[+] Running 3/3
Container applifrais-api-1 Removed 0.4s
Container applifrais-mongo-1 Removed 0.6s
Network applifrais_default Removed 0.1s
Flag B2
Production (Compose)
Écris le docker-compose.yml d'AppliFrais (au moins API + Mongo, avec volume et variable d'env) et le .env. Lance la stack.
Rends : ton fichier + la sortie de docker compose up -d et de docker compose ps + la preuve que l'API et la base communiquent (le log MongoDB connecte, ou un login qui marche).
4. Volumes, réseaux & persistance
Trois notions font la différence entre un service jouet et un service fiable.
| Notion | Rôle | Sans elle… |
|---|---|---|
| Volume | stocke les données hors du conteneur | les données disparaissent à chaque recréation |
| Réseau | fait communiquer les conteneurs par leur nom | les services ne se trouvent pas |
| Variables d'env | configure sans toucher au code/image | secrets en dur, image non réutilisable |
Volumes : nommés vs bind mounts (quand choisir quoi)
Il existe deux façons d'attacher du stockage à un conteneur. Le choix a un impact concret sur la portabilité et la sécurité.
| Volume nommé | Bind mount | |
|---|---|---|
| Syntaxe Compose | mongo-data:/data/db | ./data:/data/db ou /chemin/absolu:/data/db |
| Géré par | Docker (stocké dans /var/lib/docker/volumes/) | le système de fichiers de l'hôte, dossier que TU contrôles |
| Portabilité | forte : fonctionne identique sur tout hôte Docker | faible : dépend du chemin sur l'hôte |
| Performance | optimisé par Docker, meilleur en prod | légèrement moins performant sur Mac (FS overlay) |
| Usage typique | données de prod (base, uploads) — à préférer | code source en dev (live-reload, hot module replacement) |
| Inspecter | docker volume inspect mongo-data | directement sur le disque (ls ./data) |
Sauvegarder et restaurer un volume
Un volume nommé est géré par Docker, mais tu peux en faire une sauvegarde (dump) sans entrer dans le conteneur :
# Sauvegarder le volume mongo-data dans un fichier tar
docker run --rm \
-v applifrais_mongo-data:/source:ro \
-v $(pwd):/backup \
alpine tar -czf /backup/mongo-data-$(date +%F).tar.gz -C /source .
# Inspecter le volume (voir où Docker le stocke sur l'hôte)
docker volume inspect applifrais_mongo-data
[
{
"Name": "applifrais_mongo-data",
"Driver": "local",
"Mountpoint": "/var/lib/docker/volumes/applifrais_mongo-data/_data",
"CreatedAt": "2026-07-01T09:12:00Z",
"Labels": {"com.docker.compose.project": "applifrais"},
"Scope": "local"
}
]
Démontrer la persistance (en 4 commandes)
docker compose up -d # 1. la stack tourne
docker compose exec mongo mongosh appliFrais \
--eval 'db.test.insertOne({ note: "je survis" })' # 2. on ecrit une donnee
docker compose down # 3. on detruit les conteneurs
docker compose up -d # 4. on relance
Après l'étape 4, on relit la donnée :
docker compose exec mongo mongosh appliFrais \
--eval 'db.test.find().pretty()'
[
{ _id: ObjectId('66...'), note: 'je survis' }
]
Flag C1
Démonstration (persistance)
Reproduis la démonstration : insère une donnée, fais down puis up, prouve qu'elle est toujours là. Puis explique, en 2 phrases, ce qui se passerait sans le volume, et ce que ferait down -v.
Rends : tes commandes + la sortie du find() + ton explication.
Chapitre 4 bis — Déboguer un conteneur en vie
Un conteneur qui tourne est une boîte noire — jusqu'à ce que tu saches comment l'ouvrir. Ces quatre commandes couvrent 95 % des situations de débogage réel.
1. Entrer dans un conteneur (shell interactif)
docker exec -it applifrais-api-1 sh
/app # ls
node_modules package.json package-lock.json server.js
/app # cat package.json | grep version
"version": "1.0.0",
/app # exit
2. Suivre les logs en temps réel
docker compose logs -f --tail=50 api
applifrais-api-1 | API AppliFrais a l'ecoute sur le port 3000
applifrais-api-1 | MongoDB connecte : mongodb://mongo:27017/appliFrais
applifrais-api-1 | POST /api/auth/login 200 - 43ms
applifrais-api-1 | GET /api/frais 200 - 12ms
applifrais-api-1 | POST /api/frais 201 - 67ms
3. Surveiller la consommation (CPU, RAM)
docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O
a1b2c3d4e5f6 applifrais-api-1 0.12% 48.3MiB / 7.77GiB 0.61% 5.2MB / 1.8MB
f7e8d9c0b1a2 applifrais-mongo-1 0.08% 112.4MiB / 7.77GiB 1.41% 1.8MB / 5.2MB
4. Inspecter la configuration d'un conteneur
docker inspect applifrais-mongo-1
[{
"Id": "f7e8d9c0b1a2...",
"State": {"Status": "running", "Health": {"Status": "healthy"}},
"Mounts": [{"Type": "volume", "Name": "applifrais_mongo-data", "Destination": "/data/db"}],
"NetworkSettings": {"Networks": {"applifrais_default": {"IPAddress": "172.20.0.2"}}}
}]
5. Mini-projet : AppliFrais conteneurisé
La mission
Livre AppliFrais entièrement conteneurisé et orchestré, prêt à démarrer n'importe où en une commande :
- un Dockerfile pour l'API (+
.dockerignore) ; - un docker-compose.yml : API + Mongo ;
- un volume pour la persistance de la base, des variables d'env (
.env) pour la config/secrets ; - un README : « cloner →
docker compose up→ l'app tourne ».
Le README « clone & run »
# AppliFrais - demarrage
## Pre-requis
- Docker + Docker Compose installes
## Lancer
1. git clone <url-du-depot> && cd applifrais
2. cp .env.example .env # puis renseigner JWT_SECRET
3. docker compose up -d # construit et lance API + Mongo
4. ouvrir http://localhost:3000
## Arreter
- docker compose down # garde les donnees
- docker compose down -v # efface aussi les donnees
Flag B3
Mini-projet (livrable)
Livre la stack Docker complète d'AppliFrais : un git clone + docker compose up doit suffire à tout démarrer.
Rends : tes fichiers (Dockerfile, docker-compose.yml, .dockerignore, .env.example, README) + la preuve que l'app démarre d'une commande.
Une stack reproductible « clone & run » est une réalisation de portfolio E5 qui impressionne.
Aller plus loin — le front en multi-stage
Le front React+Vite ne se sert pas comme l'API : on le compile (build) en fichiers statiques, puis un petit serveur (Nginx) les sert. Le multi-stage build fait les deux dans un seul Dockerfile, et ne garde que le résultat final (image minuscule).
# front/Dockerfile (multi-stage)
# --- etape 1 : build ---
FROM node:20-alpine AS build # etape nommee "build"
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build # produit le dossier dist/
# --- etape 2 : servir ---
FROM nginx:alpine # image finale, tres legere
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80
Flag E1
Extension (qualité)
Ajoute le front à ta stack en multi-stage (build React → service Nginx), et déclare-le comme 3e service dans le docker-compose.yml.
Rends : le Dockerfile multi-stage du front + le service Compose + la sortie de docker compose ps montrant les 3 conteneurs.
Bonus : ajoute un conteneur MinIO (S3 local) pour les justificatifs et relie-le à l'API.
Pour finir
L'essentiel
| Notion | À retenir |
|---|---|
| conteneur | app + son environnement, léger, reproductible (vs VM lourde) |
| image / Dockerfile | le moule et sa recette ; image légère, sans secret |
| .dockerignore | exclut node_modules, .env, .git : pas de secret dans l'image |
| Docker Compose | orchestrer plusieurs services d'une commande |
| volume | persister les données hors du conteneur éphémère |
| nom de service | les conteneurs se joignent par leur nom via le réseau interne |
Vérifie tes acquis
- Différence entre une VM et un conteneur ?
- Différence entre une image et un conteneur ?
- Pourquoi copier
package.jsonet fairenpm ciavantCOPY . .? - À quoi sert un
.dockerignore, et pourquoi exclure.env? - Comment deux services Compose communiquent-ils sans IP ?
- Pourquoi un volume est-il indispensable pour la base ? Que fait
down -v? - Pourquoi préférer une image de base légère (alpine) ? (lien sécurité)
Commandes essentielles — antisèche
| Commande | Ce qu'elle fait | Quand l'utiliser |
|---|---|---|
docker compose up -d | construit (si besoin) et démarre tous les services en arrière-plan | lancer la stack |
docker compose down | arrête et supprime conteneurs + réseau (garde les volumes) | éteindre proprement |
docker compose down -v | idem + supprime les volumes | reset complet (dev only) |
docker compose ps | état des conteneurs (Up / Exit / Restarting) | vérifier que tout tourne |
docker compose logs -f --tail=50 api | logs en temps réel d'un service | déboguer une erreur |
docker compose config | affiche la config résolue (variables d'env substituées) | valider avant de lancer |
docker compose build --no-cache api | reconstruction complète sans cache | forcer la mise à jour des deps |
docker compose restart api | redémarre un seul service | recharger la config sans tout redémarrer |
docker exec -it <nom> sh | shell interactif dans un conteneur qui tourne | inspecter l'intérieur |
docker stats | monitoring CPU/RAM/réseau en temps réel | détecter une fuite mémoire |
docker images | liste les images locales avec leur taille | vérifier le poids d'une image |
docker volume ls | liste tous les volumes Docker | savoir quels volumes existent |
docker system prune | nettoie conteneurs stoppés, images non utilisées, réseaux orphelins | récupérer de l'espace disque |
Glossaire
| Mot | Définition |
|---|---|
| Conteneur | paquet isolé contenant l'app et son environnement (partage le noyau Linux) |
| Image | modèle figé à partir duquel on crée des conteneurs ; une image = N conteneurs possibles |
| Dockerfile | recette de construction d'une image, instruction par instruction |
| Couche (layer) | résultat mis en cache d'une instruction du Dockerfile ; un secret dans une couche y reste pour toujours |
| Registry | dépôt d'images en ligne (Docker Hub = public ; GitHub Container Registry / ECR = privé) |
| Docker Compose | outil pour décrire et lancer plusieurs services dans un seul fichier YAML |
| Volume nommé | stockage persistant géré par Docker, survit aux cycles down/up |
| Bind mount | dossier de l'hôte monté dans le conteneur ; pratique en dev pour le live-reload |
| Réseau Docker | réseau interne où les services se joignent par leur nom de service (pas par IP) |
| Healthcheck | commande que Compose exécute périodiquement pour savoir si un service est vraiment prêt |
| Multi-stage build | Dockerfile à plusieurs étapes ; ne garde que le résultat final dans l'image livrée |
| Surface d'attaque | ensemble des points qu'un attaquant peut viser ; réduite par les images légères (alpine, --omit=dev) |
| Namespace Linux | mécanisme noyau qui isole ce que voit un conteneur (PID, réseau, FS…) |
| cgroup | mécanisme noyau qui limite ce que consomme un conteneur (CPU, RAM) |
| Trivy | outil open source de scan de vulnérabilités d'images Docker (trivy image mon-image) |
Connecte-toi pour lire tout le TP
C'est gratuit, avec ton compte Google : un clic, et tu reviens ici. Ta progression te suit ensuite sur tous tes appareils.
Le site garde ton nom et ton email, rien d'autre. Tes données