Docker Containerization expliqué simplement (avec schémas et vrai code)

Un guide qui va droit au but : Docker Containerization décortiqué avec des schémas, des exemples concrets et des commandes testées. Tout vient d'un cours structuré de 12 chapitres — en voici le meilleur.

Anatomie d'un Dockerfile

# Arrêter TOUS les conteneurs en cours
docker stop $(docker ps -a -q)

# Supprimer TOUS les conteneurs
docker rm $(docker ps -a -q)

# Supprimer TOUTES les images (optionnel)
docker rmi $(docker images -q)

# Forcer la suppression si une image résiste
docker rmi -f $(docker images -q)

Objectifs pédagogiques

Qu'est-ce qu'un Dockerfile ?

Un Dockerfile est un fichier texte qui contient une série d'instructions pour construire une image Docker. C'est comme une recette de cuisine : chaque instruction est une étape qui transforme l'image de base en votre image personnalisée.

Image de base

Le Dockerfile part toujours d'une image existante (FROM). On ne part jamais de zéro.

Instructions

Chaque ligne est une instruction qui modifie l'image : copier des fichiers, installer des paquets, configurer...

Image finale

Le résultat est une image personnalisée prête à être lancée avec docker run.

Les instructions principales

FROM – Image de base

Toute première instruction d'un Dockerfile. Elle définit l'image de départ sur laquelle on construit.

FROM python:3.11-slim

WORKDIR – Dossier de travail

Définit le répertoire de travail dans le conteneur. Toutes les instructions suivantes (COPY, RUN, CMD) s'exécuteront dans ce dossier.

WORKDIR /app

COPY – Copier des fichiers

Copie des fichiers depuis votre machine (le « contexte de build ») vers le conteneur.

COPY . .

Le premier . = le dossier courant sur votre machine. Le deuxième . = le WORKDIR dans le conteneur (/app).

Layers, cache et bonnes pratiques

# Arrêter TOUS les conteneurs en cours
docker stop $(docker ps -a -q)

# Supprimer TOUS les conteneurs
docker rm $(docker ps -a -q)

# Supprimer TOUTES les images (optionnel)
docker rmi $(docker images -q)

# Forcer la suppression si une image résiste
docker rmi -f $(docker images -q)

Objectifs pédagogiques

Chaque instruction = 1 layer

Quand Docker exécute un Dockerfile, chaque instruction (FROM, RUN, COPY, etc.) crée un nouveau layer (couche). Une image Docker est une pile de layers empilés les uns sur les autres.

FROM python:3.11-slim     ← Layer 1 (image de base)
WORKDIR /app              ← Layer 2
COPY requirements.txt .   ← Layer 3
RUN pip install ...       ← Layer 4
COPY . .                  ← Layer 5
CMD ["python", "app.py"]  ← Layer 6 (métadonnées)

Le cache Docker

Docker met en cache chaque layer. Lors d'un rebuild, Docker vérifie si un layer a changé. Si rien n'a changé, il réutilise le layer caché au lieu de le reconstruire.

Mauvais ordre vs bon ordre

MAUVAIS : requirements après COPY . .

FROM python:3.11-slim
WORKDIR /app
COPY . .                            ← Tout le code source
RUN pip install -r requirements.txt ← Installation des dépendances
CMD ["python", "app.py"]

BON : requirements avant COPY . .

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .             ← Seulement les dépendances
RUN pip install -r requirements.txt ← Installation (caché si requirements.txt n'a pas changé)
COPY . .                            ← Le code source (change souvent)
CMD ["python", "app.py"]

Mauvais ordre

Bon ordre

Démonstration : observer le cache

Étape 1 : Créer le projet

mkdir ~/demo-cache
cd ~/demo-cache

Créez requirements.txt :

touch requirements.txt
nano requirements.txt

Construire et lancer sa première image

# Arrêter TOUS les conteneurs en cours
docker stop $(docker ps -a -q)

# Supprimer TOUS les conteneurs
docker rm $(docker ps -a -q)

# Supprimer TOUTES les images (optionnel)
docker rmi $(docker images -q)

# Forcer la suppression si une image résiste
docker rmi -f $(docker images -q)

Objectifs pédagogiques

Créer le projet

Étape 1 : Créer le dossier du projet

mkdir ~/mon-premier-docker
cd ~/mon-premier-docker

Étape 2 : Créer le script Python

Créez un fichier hello.py :

touch hello.py
nano hello.py

Collez ce contenu, puis sauvegardez (Ctrl + O, Entrée, Ctrl + X) :

print("Bonjour depuis Docker !")

echo 'print("Bonjour depuis Docker !")' > hello.py

Vérifiez le contenu du fichier :

cat hello.py

Étape 3 : Créer le Dockerfile

Créez un fichier nommé Dockerfile (sans extension) :

touch Dockerfile
nano Dockerfile

Collez ce contenu, puis sauvegardez (Ctrl + O, Entrée, Ctrl + X) :

FROM python:3.11-slim
WORKDIR /app
COPY hello.py .
CMD ["python", "hello.py"]

FAQ

📬 Tu veux recevoir ce type de guide chaque semaine ? Abonne-toi gratuitement — code réel, zéro blabla.