La nuit est épaisse sur le port. Des conteneurs s'empilent, identiques, interchangeables. Chacun contient un monde complet. Isolé. Répétable. La réponse à la plus vieille excuse du métier : "Sur ma machine, ça marche."
1.1 Concepts Fondamentaux - Le Fantôme dans la Machine
La Conteneurisation : Une Idée Simple, un Changement Radical
Imaginez une cellule de prison.
Des murs épais. Une porte verrouillée.
À l'intérieur, un homme avec tout ce dont il a besoin pour vivre.
Il croit être seul au monde.
En réalité, il y a cent cellules identiques dans le même bâtiment.
Chacune avec son propre homme.
Chacune partageant les mêmes fondations, la même plomberie, la même électricité.
C'est ça, un conteneur.
Une cellule logicielle.
Isolement, mais sans duplication inutile.
Le Problème : "Ça Marche Sur Ma Machine"
Tu connais la scène.
3h du matin.
Le serveur de prod tombe.
"Mais sur ma machine, ça marche !"
Traduction : l'environnement est différent.
Les bibliothèques, les versions, les chemins, les permissions.
Le chaos.
La conteneurisation dit : "Ton environnement ? Prends-le avec toi."
Emballé. Scellé. Répétable.
Comme un dossier d'enquête avec tous les indices dans l'ordre.
Comparaison : VM vs Conteneur
Machine Virtuelle (l'ancienne école) :
┌─────────────────────────────────┐
│ Application │
├─────────────────────────────────┤
│ OS invité (Windows/Linux) │ ← 2 Go, 30 secondes
├─────────────────────────────────┤
│ Hyperviseur (VirtualBox, etc) │
├─────────────────────────────────┤
│ OS hôte │
├─────────────────────────────────┤
│ Matériel │
└─────────────────────────────────┘
Conteneur (la méthode moderne) :
┌─────────────────────────────────┐
│ Application │
├─────────────────────────────────┤
│ Binaires/Librairies │ ← 50 Mo, < 1 seconde
├─────────────────────────────────┤
│ Docker Engine │
├─────────────────────────────────┤
│ OS hôte (Linux) │
├─────────────────────────────────┤
│ Matériel │
└─────────────────────────────────┘
La différence :
La VM virtualise le matériel.
Le conteneur virtualise le système d'exploitation.
Les chiffres parlent :
- VM : Minutes pour démarrer, gigaoctets de mémoire
- Conteneur : Secondes pour démarrer, mégaoctets de mémoire
- Densité : 10-100x plus de conteneurs que de VMs sur la même machine
Historique : Les Origines Cachées
2013. Solomon Hykes présente Docker à PyCon.
L'idée n'est pas nouvelle. Elle s'appuie sur :
- cgroups (Control Groups) - Linux 2007 : Limiter, isoler les ressources
- namespaces - Linux 2002 : Isoler la vue du système (PID, réseau, etc.)
Docker a simplement rendu ça simple.
Comme un .38 : pas la première arme, mais celle qui a tout changé.
OCI (Open Container Initiative) - 2015
La normalisation arrive.
Comme un traité de paix entre les gangs.
Deux standards :
- Runtime Specification - Comment exécuter un conteneur
- Image Specification - Comment emballer un conteneur
L'écosystème aujourd'hui :
- Docker Engine - Le moteur
- Docker Hub - Le marché aux images
- Docker Compose - Les scénarios multi-conteneurs
- Kubernetes - Le chef d'orchestre (pas Docker, mais complémentaire)
1.2 Architecture de Docker - Les Rouages de la Machine
Les 5 Pièces Maîtresses
1. Docker Daemon (dockerd)
Le gardien de nuit.
Tourne en arrière-plan.
Écoute les ordres. Gère tout.
Si il meurt, tout s'arrête.
2. Docker Client (docker)
Toi. Ou plutôt, ta voix.
La ligne de commande.
Parle au daemon via une API REST.
Même si le daemon est sur une autre machine.
3. Images Docker
Les plans d'architecture.
Immuables. En couches.
Un conteneur est une instance d'une image.
Comme un tirage photo depuis un négatif.
4. Conteneurs
L'instance en vie.
Éphémère. Avec une couche modifiable par-dessus l'image.
Si on le supprime, la couche modifiable disparaît.
L'image reste.
5. Registries
Les archives centrales.
- Docker Hub : Le dépôt public (comme GitHub pour le code)
- Registries privés : Les archives internes (Harbor, Nexus)
- Artifactory : Le grand entrepôt
Le Modèle en Couches : Comme un Oignon
Chaque instruction dans un Dockerfile = une nouvelle couche.
Exemple :
FROM ubuntu:22.04 # Couche 1 : OS de base
RUN apt-get update # Couche 2 : Mise à jour
RUN apt-get install nginx # Couche 3 : Installation
COPY index.html /var/www # Couche 4 : Fichiers
EXPOSE 80 # Métadonnée, pas de couche
CMD ["nginx", "-g", "daemon off;"] # Commande de démarrage
La magie :
Si deux images partagent la même couche Ubuntu, elles la partagent sur le disque.
Pas de duplication.
C'est comme si tous les conteneurs de la ville partageaient les mêmes fondations.
Visualisation :
Image A Image B
┌─────────────────┐ ┌─────────────────┐
│ Couche app A │ │ Couche app B │ ← Uniques
├─────────────────┤ ├─────────────────┤
│ Couche Python │ │ Couche Python │ ← PARTAGÉE !
├─────────────────┤ ├─────────────────┤
│ Couche Ubuntu │ │ Couche Ubuntu │ ← PARTAGÉE !
└─────────────────┘ └─────────────────┘
L'avantage :
- Téléchargement rapide (on ne télécharge que les couches manquantes)
- Stockage efficace
- Build rapide (cache des couches)
Comment Ça Marche : Un Scénario Typique
# 1. Tu écris un Dockerfile (le plan)
# 2. Tu builds :
docker build -t mon_app .
# Ce qui se passe :
# - Docker lit le Dockerfile
# - Pour chaque instruction, vérifie si une couche identique existe déjà
# - Si oui, utilise le cache
# - Si non, exécute et crée une nouvelle couche
# - À la fin, crée une image avec toutes les couches
# 3. Tu pushes :
docker push mon_app
# Ce qui se passe :
# - Docker envoie seulement les couches qui ne sont pas sur le registry
# - Si le registry a déjà Ubuntu, il ne l'envoie pas
# 4. Sur une autre machine :
docker pull mon_app
# Seules les couches manquantes sont téléchargées
# 5. Tu run :
docker run mon_app
# Docker crée une couche modifiable par-dessus l'image
# Cette couche meurt avec le conteneur
Le Système de Fichiers : UnionFS
La technologie sous-jacente.
Permet d'empiler des couches en lecture seule, avec une dernière couche en écriture.
Types de stockage :
- overlay2 (recommandé) : Moderne, performant
- aufs : L'ancien
- btrfs, zfs : Pour les spécialistes
Vérifier le driver :
docker info | grep Storage
Le Premier Conteneur : Rite d'Initiation
# Vérifier l'installation
docker --version
docker info
# Lancer le hello world (le premier aveu)
docker run hello-world
# Ce qui s'affiche :
# 1. Unable to find image 'hello-world:latest' locally
# 2. Pulling from library/hello-world
# 3. Downloading... (les couches)
# 4. Hello from Docker!
# 5. Explanation of what just happened
# Voir l'image téléchargée
docker images
# Voir le conteneur (mort mais présent)
docker ps -a
Ce que tu viens de faire :
- Docker a cherché l'image localement → Pas trouvé
- Il l'a téléchargée depuis Docker Hub
- Il a créé un conteneur à partir de l'image
- Le conteneur a exécuté son programme (afficher le message)
- Le conteneur est mort (processus terminé)
Conclusion du Module
La conteneurisation, c'est l'art d'emballer des mondes complets dans des boîtes étanches.
Docker en a fait une commodité. Une routine.
À retenir :
- Isolation, pas virtualisation - Partage du noyau, pas duplication
- Images immuables - Les plans d'architecture
- Conteneurs éphémères - Les instances vivantes (et mortelles)
- Couches partagées - L'efficacité du système
- Registry central - La bibliothèque des images
Tu connais maintenant le terrain.
Les règles du jeu.
La prochaine fois, on ouvrira les boîtes.
On créera, on manipulera, on fera parler les conteneurs.
La ville des conteneurs est prête.
Ses lois sont établies.
Maintenant, on va la peupler.