Docker : tutoriel complet pour maîtriser les conteneurs

Vous avez déjà eu ce problème : « Ça marche sur ma machine, mais pas en production » ? Docker résout exactement ce casse-tête. Ce guide vous apprend à installer Docker, créer vos premiers conteneurs et construire des images personnalisées — le tout en partant de zéro.

Que vous soyez développeur, administrateur système ou simplement curieux de la conteneurisation, vous trouverez ici tout ce qu’il faut pour démarrer avec Docker et l’intégrer dans vos workflows quotidiens. Prérequis : un ordinateur (Linux, Windows ou macOS) et une connexion internet.

Ce que vous allez apprendre

Installer Docker

Installation sur Linux (Ubuntu/Debian), Windows (WSL2/Desktop) et macOS (Colima).

Gérer images et conteneurs

Commandes pull, run, ps, stop, rm — le cycle de vie complet.

Construire des images

Écrire un Dockerfile efficace et créer vos propres images.

Maintenir votre environnement

Nettoyer les ressources, surveiller, diagnostiquer les problèmes.

Qu’est-ce que Docker ?

Imaginez que vous déménagiez. Deux options s’offrent à vous : emballer chaque objet séparément dans des cartons de tailles différentes, ou utiliser des conteneurs standards où tout est parfaitement rangé et transportable. Docker fonctionne exactement comme ces conteneurs standards, mais pour vos applications.

Le problème que Docker résout

Avant Docker, déployer une application ressemblait à un parcours du combattant. Chaque serveur avait sa propre configuration, ses propres versions de bibliothèques, ses propres particularités. Le résultat ? Le fameux « ça marche chez moi » — cette phrase que tout développeur a entendue au moins une fois.

Sans Docker	Avec Docker
L’application fonctionne sur le poste du développeur mais échoue en production	L’application fonctionne de manière identique partout
Chaque serveur nécessite une configuration manuelle	L’environnement est packagé avec l’application
Les conflits de versions de bibliothèques sont fréquents	Chaque conteneur a ses propres dépendances isolées
Mise à jour risquée (peut casser d’autres applications)	Conteneurs indépendants les uns des autres

Glissez pour voir

Définition simple

Docker est une plateforme open source qui permet de packager une application avec tout ce dont elle a besoin (code, bibliothèques, configuration) dans une unité appelée conteneur. Ce conteneur peut ensuite s’exécuter de manière identique sur n’importe quel serveur où Docker est installé.

Concrètement, un conteneur est comme une boîte hermétique qui contient votre application et tout son environnement. Que vous lanciez cette boîte sur votre laptop, sur un serveur d’entreprise ou dans le cloud AWS, le contenu se comportera exactement de la même façon.

L'analogie du conteneur maritime

Le nom « Docker » vient directement du monde maritime. Tout comme les conteneurs de transport ont standardisé le commerce mondial (un conteneur se charge de la même façon à Shanghai qu’à Rotterdam), Docker standardise le déploiement d’applications. Un conteneur Docker se déploie de la même façon sur votre laptop qu’en production.

Docker vs machine virtuelle

Si vous connaissez les machines virtuelles (VM), vous vous demandez peut-être quelle est la différence. La réponse tient en un mot : légèreté.

Une machine virtuelle embarque un système d’exploitation complet. C’est comme si vous transportiez une maison entière pour chaque application. Un conteneur Docker, lui, partage le noyau Linux de la machine hôte — il ne transporte que le strict nécessaire.

Critère	Machine virtuelle	Conteneur Docker
Démarrage	Minutes (boot complet de l’OS)	Secondes (processus isolé)
Taille	Gigaoctets (OS complet)	Mégaoctets (application seule)
Isolation	Complète (hyperviseur)	Processus (namespaces Linux)
Ressources	Allouées en bloc	Partagées dynamiquement
Densité	10-20 VM par serveur	Centaines de conteneurs

Glissez pour voir

En pratique, vous pouvez lancer des dizaines de conteneurs sur un laptop ordinaire, là où vous seriez limité à quelques VM.

L’histoire de Docker en bref

L’histoire de Docker commence en 2010, lorsque Solomon Hykes, un ingénieur français, travaille sur un projet de virtualisation légère. L’idée : simplifier le déploiement d’applications en utilisant les conteneurs Linux (une technologie existante mais complexe à utiliser).

En 2013, Docker est publié en open source. La promesse est simple : « Build once, run anywhere » (construisez une fois, exécutez partout). En quelques années, Docker devient le standard de facto de la conteneurisation. Aujourd’hui, il est utilisé par des millions de développeurs et d’entreprises dans le monde.

Concepts fondamentaux

Avant de lancer votre premier conteneur, prenons quelques minutes pour comprendre les briques de base de Docker. Ces concepts reviendront constamment — les maîtriser maintenant vous fera gagner un temps précieux par la suite.

Images Docker

Une image Docker est comme une recette de cuisine. Elle contient toutes les instructions et ingrédients pour préparer un plat (votre application), mais ce n’est pas le plat lui-même.

Plus techniquement, une image est un package immuable qui contient :

• Le code de votre application
• Les bibliothèques et dépendances nécessaires
• Les fichiers de configuration
• Les variables d’environnement

Une fois créée, une image ne change jamais. C’est cette immutabilité qui garantit la reproductibilité : la même image donnera toujours le même résultat, que vous la lanciez aujourd’hui ou dans six mois.

Les images sont souvent basées sur d’autres images. Par exemple, une image d’application Python sera basée sur une image Python officielle, elle-même basée sur une image Debian ou Alpine. C’est le principe des couches (layers).

Conteneurs

Un conteneur est une instance en cours d’exécution d’une image. Si l’image est la recette, le conteneur est le plat préparé et servi.

Contrairement à l’image (immuable), un conteneur a un état qui peut changer : des fichiers peuvent être créés, modifiés, supprimés pendant son exécution. Mais attention : ces modifications disparaissent quand le conteneur est supprimé (sauf si vous utilisez des volumes, on y vient).

Un conteneur fonctionne dans un environnement isolé grâce à deux mécanismes Linux :

• Les namespaces : isolent ce que le conteneur voit (processus, réseau, utilisateurs…)
• Les cgroups : limitent ce que le conteneur utilise (CPU, mémoire, I/O…)

Conteneur vs Container

Vous verrez les deux termes utilisés : « conteneur » (français) et « container » (anglais). Dans ce guide, j’utilise principalement « conteneur » mais les deux sont corrects. Les commandes Docker utilisent « container » (docker container ls).

Dockerfile

Le Dockerfile est un fichier texte qui contient les instructions pour construire une image Docker. C’est la recette écrite, étape par étape, que Docker exécute pour créer votre image.

Chaque ligne du Dockerfile correspond à une instruction :

• FROM : l’image de base sur laquelle construire
• RUN : exécuter une commande (installer un paquet, créer un dossier…)
• COPY : copier des fichiers depuis votre machine vers l’image
• ENV : définir une variable d’environnement
• EXPOSE : documenter le port sur lequel l’application écoute
• CMD : la commande à exécuter au démarrage du conteneur

Nous verrons plus tard comment écrire un Dockerfile efficace.

Les couches (Layers)

Chaque instruction du Dockerfile crée une couche dans l’image finale. Ces couches sont empilées les unes sur les autres et forment ensemble l’image complète.

L’intérêt de ce système de couches est l’optimisation :

• Cache : si une couche n’a pas changé, Docker la réutilise au lieu de la reconstruire
• Partage : plusieurs images basées sur la même image de base partagent les couches communes
• Téléchargement : seules les couches manquantes sont téléchargées

Par exemple, si vous avez 10 images basées sur python:3.12, la couche Python n’est stockée qu’une seule fois sur votre disque.

Volumes

Les volumes résolvent un problème fondamental : comment conserver des données alors que les conteneurs sont éphémères ?

Un volume est un espace de stockage en dehors du conteneur qui persiste même si le conteneur est supprimé. Les cas d’usage typiques :

• Base de données (MySQL, PostgreSQL) : les données doivent survivre aux redémarrages
• Fichiers uploadés par les utilisateurs
• Logs que vous voulez analyser plus tard
• Configuration que vous voulez modifier sans reconstruire l’image

Docker propose plusieurs types de montages :

Type	Description	Cas d’usage
Volume nommé	Géré par Docker, stocké dans /var/lib/docker/volumes/	Données de bases de données, fichiers applicatifs persistants
Bind mount	Pointe vers un chemin sur l’hôte	Développement (code source), fichiers de configuration
tmpfs	Stocké en mémoire uniquement	Données sensibles temporaires, cache éphémère

Glissez pour voir

Réseaux

Docker crée automatiquement des réseaux virtuels pour que vos conteneurs puissent communiquer entre eux et avec l’extérieur.

Par défaut, Docker utilise le réseau bridge qui isole les conteneurs tout en leur permettant de communiquer. Mais vous pouvez créer différents types de réseaux selon vos besoins :

Type de réseau	Description	Quand l’utiliser
bridge	Réseau isolé par défaut	Applications multi-conteneurs sur une seule machine
host	Partage la pile réseau de l’hôte	Performance réseau maximale (pas d’isolation)
overlay	Communication entre hôtes différents	Clusters Docker Swarm ou Kubernetes
none	Pas de réseau	Conteneurs sans accès réseau (sécurité)

Glissez pour voir

Pour l’instant, retenez que Docker gère le réseau automatiquement — vous pouvez lancer des conteneurs sans vous soucier de la configuration réseau.

Disponibilité de Docker

Docker est disponible sur toutes les plateformes majeures :

Linux : Ubuntu, Debian, Fedora, RHEL, CentOS, Alpine, Arch Linux, openSUSE… Docker s’exécute nativement grâce au noyau Linux.

Windows : via Docker Desktop qui utilise WSL 2 (Windows Subsystem for Linux) pour exécuter Docker. Fonctionne sur Windows 10/11 Pro, Enterprise et Education.

macOS : via Docker Desktop ou Colima (alternative légère). Utilise une machine virtuelle Linux en arrière-plan car macOS n’a pas de noyau Linux.

Cloud : tous les grands providers (AWS, Google Cloud, Azure) proposent des services Docker pré-configurés.

Installation de Docker

L’installation varie selon votre système d’exploitation. Je vous guide étape par étape pour chaque plateforme.

Installation sur Linux (Ubuntu/Debian)

L’installation sur Linux est la plus directe car Docker s’exécute nativement sur le noyau Linux.

N'installez pas le paquet docker.io

Le paquet docker.io des dépôts Ubuntu/Debian est souvent obsolète. Installez toujours Docker depuis les dépôts officiels pour avoir la dernière version et les correctifs de sécurité.

1. Mettre à jour le système

   Commencez par mettre à jour la liste des paquets. Cette étape garantit que vous installerez les versions les plus récentes des dépendances.

   sudo apt-get update
   sudo apt-get upgrade -y

2. Installer les prérequis

   Docker nécessite quelques paquets pour télécharger de manière sécurisée depuis les dépôts HTTPS.

   sudo apt-get install -y \
     apt-transport-https \
     ca-certificates \
     curl \
     software-properties-common

3. Ajouter la clé GPG officielle

   Cette clé permet de vérifier que les paquets téléchargés proviennent bien de Docker et n’ont pas été altérés.

   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
     sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

4. Ajouter le dépôt Docker

   Configurez APT pour utiliser le dépôt officiel Docker. La commande détecte automatiquement votre architecture (amd64, arm64) et votre version d’Ubuntu.

   echo "deb [arch=$(dpkg --print-architecture) \
     signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
     https://download.docker.com/linux/ubuntu \
     $(lsb_release -cs) stable" | \
     sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

5. Installer Docker Engine

   Mettez à jour la liste des paquets (pour inclure le nouveau dépôt) puis installez Docker.

   sudo apt-get update
   sudo apt-get install -y docker-ce docker-ce-cli containerd.io

   Vérification : Docker devrait maintenant être installé. Vérifiez avec :

   docker --version
   # Docker version 27.x.x, build xxxxxxx

6. Configurer les permissions utilisateur

   Par défaut, Docker nécessite les droits root (sudo). Pour éviter de taper sudo à chaque commande, ajoutez votre utilisateur au groupe docker :

   sudo usermod -aG docker ${USER}

   Important : déconnectez-vous puis reconnectez-vous pour que le changement prenne effet. Vous pouvez aussi lancer newgrp docker pour l’appliquer immédiatement dans le terminal courant.

Installation sur Windows

Sur Windows, Docker s’installe via Docker Desktop, une application qui fournit une interface graphique et la CLI Docker.

Configuration requise

• Windows 10 version 2004+ ou Windows 11
• WSL 2 activé (Docker Desktop le propose automatiquement)
• 4 Go de RAM minimum (8 Go recommandés)
• Virtualisation activée dans le BIOS

1. Télécharger Docker Desktop

   Rendez-vous sur docker.com/products/docker-desktop et téléchargez l’installateur Windows.

2. Lancer l’installation

   Double-cliquez sur le fichier téléchargé et suivez l’assistant. Lors de l’installation :

   • Cochez « Use WSL 2 instead of Hyper-V » (recommandé pour les performances)
   • Acceptez les paramètres par défaut

3. Redémarrer si demandé

   Windows peut nécessiter un redémarrage pour finaliser l’activation de WSL 2.

4. Lancer Docker Desktop

   Après le redémarrage, lancez Docker Desktop depuis le menu Démarrer. Une icône apparaît dans la barre des tâches :

   • Icône verte : Docker est prêt
   • Icône orange : Docker démarre
   • Icône rouge : problème de configuration

5. Vérifier l’installation

   Ouvrez PowerShell ou le terminal Windows et tapez :

   docker --version
   docker run hello-world

Installation sur macOS avec Colima

Colima est une alternative légère à Docker Desktop sur macOS. Il utilise une machine virtuelle Lima et consomme moins de ressources système.

Pourquoi Colima plutôt que Docker Desktop ?

• Plus léger : moins de RAM et CPU utilisés
• Open source : pas de restrictions de licence
• Compatible Apple Silicon : fonctionne nativement sur M1/M2/M3
• Simple : s’installe en une commande avec Homebrew

1. Installer Homebrew (si pas déjà fait)

   Homebrew est le gestionnaire de paquets standard sur macOS :

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Installer Docker CLI et Colima

   brew install docker colima

3. Démarrer Colima

   Lancez Colima avec la configuration par défaut (2 CPU, 2 Go RAM) :

   colima start

   Pour plus de ressources (recommandé pour des projets conséquents) :

   colima start --cpu 4 --memory 8 --disk 100

4. Vérifier l’installation

   docker --version
   docker run hello-world

5. Gérer Colima

   Quelques commandes utiles pour gérer la VM Colima :

   colima status    # État de la VM
   colima stop      # Arrêter Docker (et la VM)
   colima start     # Redémarrer
   colima delete    # Supprimer la VM (recrée une fresh)

Vérification du bon fonctionnement

Quelle que soit la méthode d’installation, vérifiez que Docker fonctionne correctement avec le conteneur de test hello-world :

docker run hello-world

Si tout est bien configuré, vous verrez un message de bienvenue expliquant ce qui vient de se passer :

1. Docker a téléchargé l’image hello-world depuis Docker Hub
2. Un conteneur a été créé à partir de cette image
3. Le conteneur a affiché le message puis s’est arrêté

Si vous obtenez une erreur « permission denied » : vérifiez que vous avez bien ajouté votre utilisateur au groupe docker (Linux) ou que Docker Desktop est bien démarré (Windows/macOS).

Votre premier conteneur

Maintenant que Docker est installé, lançons quelques conteneurs pour comprendre les commandes de base.

Lancer un conteneur simple

La commande docker run est la plus utilisée. Elle crée et démarre un conteneur à partir d’une image.

Lancez un conteneur Ubuntu interactif :

docker run -it ubuntu bash

Que se passe-t-il ?

1. Docker vérifie si l’image ubuntu existe localement
2. Si non, il la télécharge depuis Docker Hub
3. Il crée un conteneur à partir de cette image
4. Il lance bash à l’intérieur et vous connecte au terminal

Vous êtes maintenant à l’intérieur du conteneur. Le prompt a changé (root@<container_id>:#). Essayez quelques commandes :

cat /etc/os-release    # Vérifie que c'est bien Ubuntu
ls /                   # Liste les fichiers à la racine
exit                   # Quitte le conteneur (et l'arrête)

Comprendre les options -it

• -i (interactive) : garde l’entrée standard (stdin) ouverte
• -t (tty) : alloue un pseudo-terminal pour l’affichage

Sans ces options, vous ne pourriez pas interagir avec le shell bash.

Lancer un serveur web

Lançons maintenant quelque chose de plus utile — un serveur web Nginx :

docker run -d -p 8080:80 --name mon-nginx nginx

Décortiquons cette commande :

Option	Signification
-d	Detached : le conteneur s’exécute en arrière-plan
-p 8080:80	Port mapping : le port 8080 de votre machine → port 80 du conteneur
--name mon-nginx	Donne un nom explicite au conteneur (sinon Docker génère un nom aléatoire)
nginx	L’image à utiliser

Glissez pour voir

Vérification : ouvrez votre navigateur à l’adresse http://localhost:8080. Vous devriez voir la page d’accueil de Nginx.

Pour voir les conteneurs en cours d’exécution :

docker ps

Résultat :

CONTAINER ID   IMAGE   COMMAND                  CREATED         STATUS         PORTS                  NAMES
a1b2c3d4e5f6   nginx   "/docker-entrypoint.…"   2 minutes ago   Up 2 minutes   0.0.0.0:8080->80/tcp   mon-nginx

Les options essentielles de docker run

La commande docker run accepte de nombreuses options. Voici les plus utilisées au quotidien :

Option	Description	Exemple
-d	Mode détaché (arrière-plan)	docker run -d nginx
-p host:container	Mapping de port	docker run -p 8080:80 nginx
--name	Nom du conteneur	docker run --name web nginx
-e VAR=val	Variable d’environnement	docker run -e DEBUG=true myapp
-v host:container	Monter un volume	docker run -v ./data:/app/data nginx
--rm	Supprimer après arrêt	docker run --rm ubuntu echo "test"
-it	Mode interactif + terminal	docker run -it ubuntu bash
--restart	Politique de redémarrage	docker run --restart=always nginx

Glissez pour voir

Un exemple combinant plusieurs options :

docker run -d \
  --name mon-app \
  -p 3000:3000 \
  -e NODE_ENV=production \
  -v $(pwd)/logs:/app/logs \
  --restart unless-stopped \
  node:20-alpine node server.js

Cette commande lance une application Node.js en production avec persistance des logs et redémarrage automatique.

Gérer les images Docker

Les images sont les briques de base de Docker. Apprenons à les rechercher, télécharger, lister et supprimer.

Rechercher une image

Docker Hub est le registre public où les éditeurs et la communauté publient leurs images. Vous pouvez rechercher directement depuis le terminal :

docker search python

Résultat :

NAME                    DESCRIPTION                                     STARS     OFFICIAL
python                  Python is an interpreted, interactive...        9500      [OK]
pypy                    PyPy is a fast, compliant alternative...        400       [OK]
bitnami/python          Bitnami Python Docker Image                     30

Conseil : privilégiez les images [OFFICIAL] — elles sont maintenues par les éditeurs officiels et régulièrement mises à jour avec les correctifs de sécurité.

Télécharger une image (pull)

Pour télécharger une image sans lancer de conteneur :

docker pull nginx

Docker télécharge l’image couche par couche :

Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete
a9edb18cadd1: Pull complete
589b7251471a: Pull complete
...
Digest: sha256:abc123...
Status: Downloaded newer image for nginx:latest

Les tags : par défaut, Docker utilise le tag latest. Mais vous pouvez (et devriez) spécifier une version précise :

docker pull nginx:1.25-alpine    # Version 1.25 basée sur Alpine (légère)
docker pull python:3.12-slim     # Python 3.12, image minimale
docker pull node:20-bookworm     # Node.js 20 sur Debian Bookworm

Évitez le tag latest en production

Le tag latest pointe vers la dernière version disponible, qui peut changer à tout moment. En production, spécifiez toujours une version explicite pour garantir la reproductibilité de vos déploiements.

Lister les images locales

Pour voir toutes les images présentes sur votre machine :

docker images

Résultat :

REPOSITORY   TAG            IMAGE ID       CREATED        SIZE
nginx        latest         605c77e624dd   2 weeks ago    187MB
nginx        1.25-alpine    a6eb2a334a9f   2 weeks ago    43MB
python       3.12-slim      c1e47f78a7d4   3 days ago     156MB
ubuntu       latest         ca2b0f26964c   4 weeks ago    77MB

Les colonnes importantes :

• REPOSITORY : nom de l’image
• TAG : version/variante de l’image
• IMAGE ID : identifiant unique (utile pour les commandes)
• SIZE : espace disque occupé

Pour avoir plus de détails sur une image spécifique :

docker inspect nginx

Cette commande retourne un JSON complet avec la configuration, les couches, les variables d’environnement, les ports exposés, etc.

Supprimer des images

Pour libérer de l’espace disque, supprimez les images dont vous n’avez plus besoin :

# Supprimer une image par son nom
docker rmi nginx:1.25-alpine

# Supprimer par ID
docker rmi a6eb2a334a9f

# Supprimer plusieurs images
docker rmi nginx python ubuntu

Si une image est utilisée par un conteneur (même arrêté), Docker refusera de la supprimer. Deux solutions :

# Option 1 : supprimer d'abord le conteneur
docker rm mon-conteneur
docker rmi nginx

# Option 2 : forcer la suppression
docker rmi -f nginx

Pour nettoyer toutes les images non utilisées d’un coup :

docker image prune       # Images « dangling » (sans tag)
docker image prune -a    # Toutes les images non utilisées

Gérer les conteneurs

Un conteneur passe par différents états durant son cycle de vie : créé, en cours d’exécution, arrêté, supprimé. Voyons comment gérer ces états.

Lister les conteneurs

# Conteneurs en cours d'exécution
docker ps

# Tous les conteneurs (y compris arrêtés)
docker ps -a

Exemple de sortie :

CONTAINER ID   IMAGE   COMMAND                  STATUS                     NAMES
a1b2c3d4e5f6   nginx   "/docker-entrypoint.…"   Up 2 hours                 mon-nginx
b2c3d4e5f6a7   ubuntu  "bash"                   Exited (0) 10 minutes ago  hopeful_curie

Les statuts possibles :

Status	Signification
Created	Conteneur créé mais jamais démarré
Up X minutes	En cours d’exécution depuis X minutes
Exited (0)	Arrêté normalement (code retour 0)
Exited (1)	Arrêté avec erreur (code retour non nul)
Paused	Suspendu (processus gelés)

Glissez pour voir

Démarrer, arrêter, redémarrer

# Arrêter un conteneur (envoie SIGTERM, puis SIGKILL après 10s)
docker stop mon-nginx

# Démarrer un conteneur arrêté
docker start mon-nginx

# Redémarrer (stop + start)
docker restart mon-nginx

# Arrêt immédiat (SIGKILL, pas de graceful shutdown)
docker kill mon-nginx

Supprimer des conteneurs

Un conteneur arrêté occupe toujours de l’espace disque. Pour le supprimer définitivement :

# Supprimer un conteneur arrêté
docker rm mon-nginx

# Supprimer plusieurs conteneurs
docker rm container1 container2

# Forcer la suppression d'un conteneur actif (stop + rm)
docker rm -f mon-nginx

# Supprimer tous les conteneurs arrêtés
docker container prune

Conteneurs jetables avec --rm

Si vous lancez des conteneurs temporaires (tests, scripts one-shot), utilisez --rm pour qu’ils soient supprimés automatiquement après exécution :

docker run --rm ubuntu cat /etc/os-release

Consulter les logs

Les logs sont essentiels pour comprendre ce qui se passe dans un conteneur :

# Tous les logs
docker logs mon-nginx

# Suivre les logs en temps réel (comme tail -f)
docker logs -f mon-nginx

# Les 50 dernières lignes
docker logs --tail 50 mon-nginx

# Avec timestamps
docker logs -t mon-nginx

Exécuter une commande dans un conteneur

Pour lancer une commande dans un conteneur en cours d’exécution :

# Ouvrir un shell interactif
docker exec -it mon-nginx bash

# Exécuter une commande simple
docker exec mon-nginx nginx -t    # Tester la config Nginx

# En tant qu'autre utilisateur
docker exec -u www-data mon-nginx whoami

C’est très utile pour le debugging : vous pouvez inspecter les fichiers, lancer des commandes, vérifier les processus sans arrêter le conteneur.

Construire une image Docker

Jusqu’ici, nous avons utilisé des images existantes. Mais la vraie puissance de Docker vient de la capacité à créer vos propres images avec vos applications.

Anatomie d’un Dockerfile

Un Dockerfile est un fichier texte qui décrit, étape par étape, comment construire une image. Voici un exemple commenté :

# Image de base : Python 3.12 sur Alpine Linux (légère)
FROM python:3.12-alpine

# Métadonnées de l'image
LABEL maintainer="vous@example.com"
LABEL description="Mon application Python"

# Définir le répertoire de travail
WORKDIR /app

# Copier le fichier des dépendances
COPY requirements.txt .

# Installer les dépendances Python
RUN pip install --no-cache-dir -r requirements.txt

# Copier le code source
COPY src/ ./src/

# Variable d'environnement
ENV FLASK_ENV=production

# Port exposé (documentation)
EXPOSE 5000

# Commande par défaut au démarrage
CMD ["python", "src/app.py"]

Les instructions principales

Instruction	Description	Exemple
FROM	Image de base (obligatoire, première instruction)	FROM python:3.12-alpine
WORKDIR	Définit le répertoire de travail	WORKDIR /app
COPY	Copie fichiers/dossiers depuis l’hôte	COPY . /app
ADD	Comme COPY, mais peut extraire des archives	ADD app.tar.gz /app
RUN	Exécute une commande (création de couche)	RUN apt-get install -y curl
ENV	Définit une variable d’environnement	ENV NODE_ENV=production
EXPOSE	Documente le port utilisé	EXPOSE 3000
CMD	Commande par défaut au démarrage	CMD ["node", "server.js"]
ENTRYPOINT	Point d’entrée (non modifiable)	ENTRYPOINT ["nginx"]

Glissez pour voir

Construire l’image

Avec le Dockerfile prêt, construisez l’image avec docker build :

docker build -t mon-app:1.0 .

Explication :

• -t mon-app:1.0 : tag l’image avec un nom et une version
• . : contexte de build (le répertoire contenant le Dockerfile)

Docker exécute chaque instruction et crée une couche :

[+] Building 15.2s (10/10) FINISHED
 => [1/6] FROM python:3.12-alpine
 => [2/6] WORKDIR /app
 => [3/6] COPY requirements.txt .
 => [4/6] RUN pip install --no-cache-dir -r requirements.txt
 => [5/6] COPY src/ ./src/
 => [6/6] EXPOSE 5000
 => exporting to image
 => naming to docker.io/library/mon-app:1.0

BuildKit est maintenant le défaut

Depuis Docker 23.0, BuildKit est le moteur de build par défaut. Il offre de meilleures performances et des fonctionnalités avancées. Si vous utilisez une ancienne version, activez-le explicitement :

export DOCKER_BUILDKIT=1
docker build -t mon-app:1.0 .

Plus d’infos : BuildKit

Exemple complet : application Nginx personnalisée

Créons une image Nginx avec une page HTML personnalisée :

FROM nginx:1.25-alpine

# Copier notre page HTML
COPY index.html /usr/share/nginx/html/

# Copier une config personnalisée (optionnel)
COPY nginx.conf /etc/nginx/nginx.conf

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Et le fichier index.html :

<!DOCTYPE html>
<html>
<head><title>Mon site Docker</title></head>
<body>
  <h1>Bienvenue sur mon conteneur Docker !</h1>
</body>
</html>

Construction et test :

docker build -t mon-site:1.0 .
docker run -d -p 8080:80 mon-site:1.0
# Ouvrez http://localhost:8080

Bonnes pratiques pour les Dockerfiles

Quelques règles pour des images légères, sécurisées et rapides à construire :

1. Utilisez des images de base légères

# ✅ Préférez Alpine ou les variantes slim
FROM python:3.12-alpine
FROM node:20-slim

# ❌ Évitez les images complètes si pas nécessaire
FROM ubuntu:22.04

2. Ordonnez les instructions par fréquence de changement

Les couches sont mises en cache. Si une couche change, toutes les suivantes sont reconstruites. Placez les fichiers qui changent souvent en dernier.

# ✅ Les dépendances changent moins souvent que le code
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY src/ ./src/

# ❌ À chaque modif du code, pip install est relancé
COPY . /app
RUN pip install -r requirements.txt

3. Combinez les RUN pour réduire les couches

# ✅ Une seule couche
RUN apt-get update && \
    apt-get install -y curl wget && \
    rm -rf /var/lib/apt/lists/*

# ❌ Trois couches (et le cache apt reste)
RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y wget

4. Ne lancez pas en root

# Créer un utilisateur non-root
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

Gérer les versions d’images

Une fois votre image créée, vous pouvez lui ajouter des tags supplémentaires avec docker tag :

# L'image actuelle
docker images mon-app
# REPOSITORY   TAG    IMAGE ID
# mon-app      1.0    abc123def

# Ajouter le tag "latest"
docker tag mon-app:1.0 mon-app:latest

# Tagger pour un registre distant
docker tag mon-app:1.0 registry.example.com/mon-app:1.0

Gérer les ressources Docker

Docker accumule des ressources (images, conteneurs, volumes, réseaux) qui peuvent occuper beaucoup d’espace disque. La commande docker system permet de gérer tout ça.

Voir l’utilisation disque

docker system df

Résultat :

TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          12        4         3.2GB     1.8GB (56%)
Containers      8         2         150MB     100MB (66%)
Local Volumes   5         3         500MB     200MB (40%)
Build Cache     0         0         0B        0B

Cela vous montre exactement ce qui consomme de l’espace et ce qui peut être nettoyé.

Nettoyer les ressources inutilisées

La commande docker system prune est votre meilleure amie pour faire le ménage :

# Nettoyage de base (conteneurs arrêtés, images dangling, réseaux inutilisés)
docker system prune

# Inclure les images non utilisées (même avec tags)
docker system prune -a

# Inclure les volumes orphelins (attention aux données !)
docker system prune --volumes

# Sans confirmation (pour scripts)
docker system prune -af

Attention avec --volumes

L’option --volumes supprime définitivement les volumes non attachés à un conteneur. Si vous avez des données de base de données ou des fichiers importants dans un volume « orphelin », ils seront perdus.

Informations système

Pour diagnostiquer des problèmes ou comprendre votre configuration Docker :

docker system info

Cette commande affiche :

• Version de Docker
• Nombre de conteneurs/images
• Driver de stockage
• Configuration du réseau
• Ressources système (CPU, mémoire)

Surveiller les événements

Pour voir ce qui se passe en temps réel sur votre installation Docker :

docker system events

Chaque action (création, démarrage, arrêt de conteneur, pull d’image…) génère un événement. Très utile pour le debugging.

Dépannage

Voici les problèmes les plus fréquents et leurs solutions.

Erreurs courantes

Symptôme	Cause probable	Solution
permission denied	Utilisateur pas dans le groupe docker	sudo usermod -aG docker $USER puis reconnexion
Cannot connect to Docker daemon	Docker pas démarré	sudo systemctl start docker (Linux) ou démarrer Docker Desktop
port is already allocated	Port déjà utilisé	Choisir un autre port : -p 8081:80
no space left on device	Disque plein	docker system prune -a
image not found	Mauvais nom d’image ou pas téléchargée	Vérifier le nom, docker pull
OCI runtime create failed	Problème de permissions ou ressources	Vérifier les droits, mémoire disponible

Glissez pour voir

Le conteneur s’arrête immédiatement

Si un conteneur démarre puis s’arrête aussitôt :

# Voir le code de sortie
docker ps -a --filter "name=mon-conteneur"

# Consulter les logs
docker logs mon-conteneur

Causes fréquentes :

• La commande principale a échoué (erreur dans l’application)
• Pas de processus en foreground (tout se lance en background et le conteneur n’a plus rien à faire)
• Fichier de configuration manquant ou incorrect

Impossible de supprimer une image

# Erreur : image used by container
docker rmi nginx
# Error: conflict: unable to remove repository reference "nginx"

# Solution : lister et supprimer les conteneurs qui l'utilisent
docker ps -a --filter ancestor=nginx
docker rm <container_id>
docker rmi nginx

Le build Docker est lent

• Vérifiez le contexte : Docker envoie tout le répertoire courant au daemon. Utilisez un .dockerignore pour exclure node_modules/, .git/, etc.
• Optimisez l’ordre des instructions : mettez les fichiers qui changent souvent en dernier
• Utilisez BuildKit : DOCKER_BUILDKIT=1 docker build

À retenir

Voici les points essentiels de ce guide Docker :

• Docker conteneurise vos applications avec tout leur environnement, garantissant un comportement identique partout

• Image vs Conteneur : l’image est le template immuable, le conteneur est l’instance en exécution

• Commandes essentielles :

  • docker run pour lancer un conteneur
  • docker ps pour voir les conteneurs actifs
  • docker logs pour consulter les logs
  • docker exec pour exécuter des commandes dans un conteneur
  • docker build pour créer une image depuis un Dockerfile

• Bonnes pratiques Dockerfile : images légères (Alpine), ordre des instructions optimisé, pas de root, fichiers .dockerignore

• Maintenance : docker system prune régulièrement pour libérer l’espace disque

Checklist de démarrage

Avant de passer à la suite, vérifiez que vous savez :

• Installer Docker sur votre système
• Lancer un conteneur avec les options -d, -p, --name
• Consulter les logs d’un conteneur
• Lister et supprimer des conteneurs et images
• Écrire un Dockerfile simple
• Construire une image avec docker build
• Nettoyer les ressources inutilisées

Contrôle de connaissances

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

📝 35 questions

⏱️ 10 min.

🎯 80%

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

▶ Démarrer le quiz

Lance le quiz et démarre le chronomètre

Prochaines étapes

Docker Compose Orchestrez plusieurs conteneurs avec un fichier YAML

Volumes Docker Persistez vos données avec les volumes

Optimiser vos images Réduisez la taille et améliorez la sécurité

Sécuriser Docker Bonnes pratiques de sécurité pour la production

Ressources

• Documentation officielle : docs.docker.com
• Docker Hub : hub.docker.com
• BuildKit : Guide BuildKit

FAQ — Questions Fréquemment Posées

Qu'est-ce que Docker ?

Qu'est‑ce qu'un moteur de conteneurs (container engine) ?

Quels sont les principaux moteurs de conteneurs et leurs particularités ?

Quelles sont les bonnes pratiques pour configurer Docker en production ?

Comment sécuriser des déploiements Docker en production ?

Quels types de volumes Docker et plugins utiliser pour persister les données ?

Quelle est la différence entre une image et un conteneur ?

Comment fonctionne le système de réseau Docker ?

Pourquoi utiliser Docker Compose ?

Quelle est la différence entre Docker et Kubernetes ?

Qu’est-ce qu’un Dockerfile et comment l’utiliser ?

×

📖 Voir la documentation →