Docker pour les débutants : comprendre images, containers et volumes

Introduction : Docker, la révolution de la portabilité

Docker permet de faire tourner ton code "partout de la même façon". C'est l'un des piliers du DevOps moderne et la solution au fameux "Ça marche sur ma machine !". Docker résout un problème universel : garantir que ton app tourne de manière identique sur ton PC, le serveur de staging et la production.

Qu'est-ce que Docker ?

Docker est une plateforme de conteneurisation qui emballe ton application avec toutes ses dépendances dans une unité légère et portable appelée container.

Différence avec une VM

• Virtual Machine : Émule un OS complet (lourd, lent)
• Docker Container : Partage le kernel de l'hôte (léger, rapide)

Un container Docker démarre en quelques millisecondes vs plusieurs minutes pour une VM.

Les 3 concepts fondamentaux

Image Docker

Une image est un template immuable qui contient :

• Un système d'exploitation minimal (Alpine, Ubuntu...)
• Ton runtime (Node.js, Python, Java...)
• Tes dépendances
• Ton code applicatif

Pense à une image comme une recette de cuisine : elle décrit comment construire l'environnement.

Container Docker

Un container est une instance en exécution d'une image. Analogie : si l'image est la recette, le container est le plat cuisiné. Tu peux lancer plusieurs containers à partir de la même image (comme faire plusieurs gâteaux avec la même recette).

Volume Docker

Un volume est un stockage persistant qui survit à la suppression du container. Pourquoi c'est crucial ? Parce que les containers sont éphémères : quand tu supprimes un container, toutes ses données internes disparaissent. Les volumes permettent de :

• Persister les données de base de données
• Partager des fichiers entre containers
• Séparer les données du code

Créer ta première image Docker

Le Dockerfile

Le Dockerfile est le fichier de configuration qui définit comment construire ton image. Exemple pour une app Node.js : Instructions expliquées :

• FROM node:20-alpine : Image de base (Node 20 sur Alpine Linux, super léger 40 MB)
• WORKDIR /app : Répertoire de travail dans le container
• COPY package*.json ./ : Copier les fichiers de dépendances en premier (optimisation cache)
• RUN npm ci : Installer les dépendances (npm ci = plus rapide et déterministe que npm install)
• COPY . . : Copier tout le code source
• EXPOSE 3000 : Documenter le port (informatif uniquement)
• CMD : Commande exécutée au démarrage du container

Build de l'image

• docker build -t my-app .

L'option -t donne un nom (tag) à ton image.

Lancer un container

Commande de base

• docker run -p 3000:3000 my-app

-p 3000:3000 : Mapper le port 3000 du container au port 3000 de ton PC

Options utiles

• -d : Mode détaché (arrière-plan)
• --name mon-container : Donner un nom au container
• -e VAR=value : Passer une variable d'environnement
• -v /host/path:/container/path : Monter un volume
• --rm : Supprimer le container automatiquement après arrêt

Exemple complet :

• docker run -d --name api -p 5000:5000 -e NODE_ENV=production my-app

Gérer les volumes

Créer un volume nommé

• docker volume create my-data

Utiliser le volume dans un container

• docker run -v my-data:/app/data my-app

Les données écrites dans /app/data dans le container seront persistées dans le volume.

Bind mount (mapper un dossier local)

• docker run -v $(pwd):/app my-app

Utile pour le hot reload en développement.

Commandes Docker essentielles

Gestion des containers

• docker ps : Lister les containers en cours
• docker ps -a : Tous les containers (même arrêtés)
• docker stop : Arrêter un container
• docker start : Redémarrer un container arrêté
• docker rm : Supprimer un container
• docker logs : Voir les logs
• docker exec -it sh : Ouvrir un shell dans le container

Gestion des images

• docker images : Lister les images
• docker rmi : Supprimer une image
• docker pull : Télécharger une image du Docker Hub
• docker push : Pousser une image sur un registry

Nettoyage

• docker system prune : Nettoyer tout ce qui est inutilisé
• docker system prune -a --volumes : Nettoyage agressif (tout supprimer)

Best practices

• Utilise des images Alpine (plus légères)
• Multi-stage builds pour réduire la taille finale
• .dockerignore pour exclure node_modules, .git, etc.
• Ne pas run en root (sécurité)
• Copier package.json avant le code (optimisation cache)
• Un processus par container (principe Unix)

Cas d'usage concrets

Dev local identique à la prod

Plus de "ça marche sur ma machine" : tout le monde utilise le même container.

CI/CD automatisé

Build une image, teste-la, déploie-la. Même artefact du dev à la prod.

Isolation de projets

Projet A avec Node 18, Projet B avec Node 20 ? Aucun conflit.

Conclusion

Docker, c'est la clé de la portabilité moderne. Les 3 concepts à retenir :

• Image : Template immuable
• Container : Instance en exécution
• Volume : Persistance des données

Tu codes sur ton PC, tu déploies sur n'importe quel serveur. Build once, run anywhere. Ressources :

• docs.docker.com
• hub.docker.com (images officielles)
• dockerlabs.collabnix.com

> "Docker solved the 'works on my machine' problem forever."