Exercice 01 : Écrire votre premier Dockerfile

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

• ✅ Écrire un Dockerfile complet pour une application web simple
• ✅ Utiliser FROM, WORKDIR, ENV, COPY, RUN, EXPOSE, CMD
• ✅ Construire une image avec docker build -t
• ✅ Forcer une reconstruction propre avec --no-cache
• ✅ Lancer et tester votre image localement

Durée estimée : 35 min | Difficulté : ⭐⭐⭐☆☆

📖 Contexte

Un Dockerfile est un fichier texte qui décrit, étape par étape, comment construire une image Docker. Chaque instruction crée un layer immuable. Comprendre leur rôle est indispensable pour packager n'importe quelle application.

📋 Énoncé

Créez un Dockerfile pour une petite application Node.js qui expose un serveur HTTP sur le port 3000. Construisez l'image, lancez le conteneur, et vérifiez qu'il répond correctement.

🧭 Déroulement

Tâche 1 : Préparer l'application

Créez un dossier mon-app/ et ajoutez-y un fichier server.js :

const http = require('http');
const PORT = process.env.PORT || 3000;
http.createServer((req, res) => {
  res.end(`Bonjour depuis Docker ! PORT=${PORT}\n`);
}).listen(PORT, () => console.log(`Serveur démarré sur le port ${PORT}`));

Indice : Pas besoin de npm init - Node.js standard library suffit ici.

Vérification : node server.js doit afficher Serveur démarré sur le port 3000.

Tâche 2 : Écrire le Dockerfile

Dans mon-app/, créez un Dockerfile en respectant l'ordre suivant :

1. Base : image officielle node:20-alpine
2. Répertoire de travail : /app
3. Variable d'environnement : NODE_ENV=production
4. Copie de server.js dans le conteneur
5. Port exposé : 3000
6. Commande de démarrage : node server.js

Indice : WORKDIR crée le dossier s'il n'existe pas et change le répertoire courant pour les instructions suivantes.

Vérification : docker build -t mon-app . doit terminer avec Successfully built ou naming to docker.io/library/mon-app.

Tâche 3 : Construire l'image

Construisez l'image en lui donnant le tag mon-app:1.0.

Indice : L'option -t accepte le format nom:tag. Le . désigne le répertoire contenant le Dockerfile.

Vérification : docker images mon-app liste l'image avec le tag 1.0.

Tâche 4 : Lancer et tester le conteneur

Lancez un conteneur depuis mon-app:1.0 en mappant le port 3000 de l'hôte sur le port 3000 du conteneur.

Indice : -p hote:conteneur mappe les ports. Ajoutez -d pour lancer en arrière-plan.

Vérification : curl http://localhost:3000 retourne Bonjour depuis Docker ! PORT=3000.

Tâche 5 : Reconstruire sans cache

Modifiez le message de réponse dans server.js, puis reconstruisez l'image en forçant Docker à ignorer le cache.

Indice : --no-cache force Docker à exécuter chaque instruction depuis zéro, même si les layers existent déjà.

Vérification : curl http://localhost:3000 affiche le nouveau message après redémarrage du conteneur.

🗂️ Mini-Projet

Construisez l'image complète et validez chaque checkpoint :

mkdir mon-app && cd mon-app
# Créer server.js (voir Tâche 1)
# Créer Dockerfile (voir Tâche 2)
docker build -t mon-app:1.0 .
docker run -d -p 3000:3000 --name test-app mon-app:1.0
curl http://localhost:3000
docker stop test-app && docker rm test-app
docker build --no-cache -t mon-app:1.1 .

Checkpoints de validation :

• Dockerfile contient FROM node:20-alpine
• WORKDIR /app est défini avant COPY
• ENV NODE_ENV=production est présent
• docker build -t mon-app:1.0 . réussit sans erreur
• curl http://localhost:3000 retourne le message attendu
• docker build --no-cache reconstruit tous les layers