Si vous avez déjà prononcé cette phrase en voyant votre code échouer sur le serveur d'un collègue ou en production, vous savez pourquoi Docker est devenu incontournable.
Docker résout ce problème en emballant votre application et tout ce dont elle a besoin pour fonctionner (code, librairies, environnement) dans un conteneur. Et pour créer ce conteneur, vous avez besoin d'une recette : le Dockerfile.
Dans ce guide ultime, nous allons démystifier le Dockerfile et vous accompagner pas à pas pour créer votre première image Docker.
1. Qu'est-ce qu'un Dockerfile ?
Imaginez que vous vouliez cuisiner un gâteau.
- Le Dockerfile, c'est la recette de cuisine.
- L'Image Docker, c'est le gâteau cuit et prêt (mais pas encore mangé).
- Le Conteneur, c'est le moment où vous servez le gâteau et le consommez.
Techniquement, un Dockerfile est un simple fichier texte (sans extension) contenant une liste d'instructions que Docker va lire pour construire une image automatiquement.
2. Le vocabulaire essentiel (Les instructions)
Avant de coder, passons en revue les 5 instructions que vous utiliserez dans 90% de vos projets.
- FROM : C'est la fondation. Chaque image part d'une base (ex: Windows, Linux, Python, Node.js).
- WORKDIR : Définit le dossier de travail à l'intérieur du conteneur. C'est comme faire un cd /dossier.
- COPY : Copie des fichiers de votre ordinateur (l'hôte) vers l'intérieur du conteneur.
- RUN : Exécute une commande pendant la construction de l'image (ex: installer des dépendances, mettre à jour le système).
- CMD : La commande qui s'exécute au démarrage du conteneur (ex: lancer le serveur web).
💡 Différence clé : RUN prépare l'image (installation), tandis que CMD lance l'application.
3. Tutoriel pratique : Votre première image Docker
Passons à la pratique. Nous allons créer une petite application Python et la "dockeriser".
Prérequis
- Avoir Docker Desktop installé sur votre machine.
- Un éditeur de code (VS Code, Sublime Text, etc.).
Étape 1 : Créer l'application
Créez un dossier nommé mon-projet-docker. À l'intérieur, créez un fichier app.py :
code Python
downloadcontent_copy
expand_less
# app.pyimport osprint("---------------------------------------")print("Bienvenue dans votre premier conteneur !")print("Ceci tourne grâce à Python et Docker.")print("---------------------------------------")Étape 2 : Écrire le Dockerfile
Dans le même dossier, créez un fichier nommé Dockerfile (attention : pas d'extension .txt, juste "Dockerfile" avec une majuscule).
Copiez ce contenu :
code Dockerfile
downloadcontent_copy
expand_less
# 1. On part d'une image de base légère avec Python préinstalléFROM python:3.9-slim# 2. On définit le dossier de travail dans le conteneurWORKDIR /app# 3. On copie le fichier de notre PC vers le conteneurCOPY app.py .# 4. On indique la commande à lancer quand le conteneur démarreCMD ["python", "app.py"]
Étape 3 : Construire l'image (Build)
Ouvrez votre terminal dans le dossier du projet et lancez la commande suivante :
code Bash
downloadcontent_copy
expand_less
docker build -t ma-premiere-app .
- docker build : L'ordre de construire.
- -t ma-premiere-app : L'option "tag" pour donner un nom à votre image.
- . : Très important ! Cela indique à Docker de chercher le Dockerfile dans le dossier courant.
Docker va télécharger l'image Python, configurer le dossier et copier votre fichier. Une fois terminé, vous avez votre image !
Étape 4 : Lancer le conteneur (Run)
C'est le moment de vérité. Lancez :
code Bash
downloadcontent_copy
expand_less
docker run ma-premiere-app
Vous devriez voir s'afficher dans votre terminal :
code Text
downloadcontent_copy
expand_less
---------------------------------------Bienvenue dans votre premier conteneur !Ceci tourne grâce à Python et Docker.---------------------------------------
Félicitations ! Vous venez de créer et d'exécuter votre propre environnement conteneurisé.
4. Niveau Avancé : Gérer les dépendances
Dans la vraie vie, vos applications ont besoin de librairies externes. Voyons comment gérer cela proprement.
Imaginons que vous ayez un fichier requirements.txt (pour Python) ou package.json (pour Node.js).
Voici comment optimiser votre Dockerfile pour utiliser le cache de Docker :
code Dockerfile
downloadcontent_copy
expand_less
FROM python:3.9-slimWORKDIR /app# 1. On copie UNIQUEMENT le fichier de dépendances d'abordCOPY requirements.txt .# 2. On installe les dépendancesRUN pip install -r requirements.txt# 3. ENSUITE, on copie le reste du codeCOPY . .CMD ["python", "app.py"]
Pourquoi faire ça ?
Docker construit les images par "couches". Si vous modifiez votre code (app.py), Docker ne sera pas obligé de réinstaller toutes les librairies (RUN pip install) car le fichier requirements.txt n'a pas changé. Il réutilisera le cache des étapes précédentes. C'est un gain de temps énorme !
5. Les 3 erreurs à éviter (Best Practices)
Pour finir, voici trois conseils pour écrire des Dockerfiles comme un pro :
- Utilisez .dockerignore : Créez un fichier .dockerignore (similaire à .gitignore) pour exclure les fichiers inutiles. Vous ne voulez pas copier vos dossiers .git, vos fichiers temporaires ou vos mots de passe dans l'image !
- Évitez le tag :latest en production : Au lieu de FROM python:latest, utilisez une version précise comme FROM python:3.9.1. Cela garantit que votre application ne cassera pas si une nouvelle version majeure de Python sort demain.
- Une seule responsabilité : Un conteneur doit faire une seule chose. Ne tentez pas de lancer votre base de données ET votre serveur web dans le même Dockerfile. Utilisez Docker Compose pour orchestrer plusieurs conteneurs (sujet d'un prochain article !).
Conclusion
Le Dockerfile n'est pas si effrayant une fois qu'on comprend qu'il ne s'agit que d'une liste d'instructions séquentielle. En maîtrisant FROM, COPY, RUN et CMD, vous êtes déjà capable de dockeriser la majorité des applications simples.
À vous de jouer : Essayez de créer un Dockerfile pour un projet existant ou pour une simple application "Hello World" en Node.js ou en Go.
Vous avez aimé ce guide ? Partagez-le ou laissez un commentaire ci-dessous si vous avez rencontré une erreur !
