
Le lien vers le PDF: Cheat Sheet Docker
Docker est un outil incontournable pour gérer des conteneurs et leurs applications de manière simple et efficace. Grâce à Docker, tu peux créer, déployer et gérer des environnements isolés pour tes applications, que ce soit sur ton ordinateur ou dans le cloud.
Ce guide propose un cheat sheet complet des commandes essentielles à connaître pour utiliser Docker au quotidien. Il te permettra de gérer facilement tes conteneurs, images, volumes et réseaux.
Tirer, gérer et pousser des images Docker
Section intitulée « Tirer, gérer et pousser des images Docker »Les images Docker sont à la base du fonctionnement des conteneurs. Une image est une sorte de modèle qui contient tout le nécessaire pour exécuter une application (dépendances, bibliothèques, etc.). Voici les principales commandes pour télécharger, gérer et pousser des images dans un registre distant.
Pull des images
Section intitulée « Pull des images »La commande docker pull te permet de télécharger des images depuis un
registre, tel que le Docker Hub. Par exemple, pour télécharger une image de
Nginx, tu peux utiliser cette commande :
docker pull nginxCela récupérera l’image la plus récente de Nginx depuis le Docker Hub. Si tu veux une version spécifique, tu peux la préciser comme ceci :
docker pull nginx:1.21.0Build des images
Section intitulée « Build des images »Si tu souhaites créer ta propre image à partir d’un fichier Dockerfile,
utilise la commande docker build. Par exemple, si ton Dockerfile se trouve
dans le répertoire courant et que tu veux nommer ton image “mon_app”, voici la
commande :
docker build -t mon_app .Lister les images
Section intitulée « Lister les images »Pour afficher toutes les images présentes sur ta machine, utilise docker images :
docker imagesCela te donne un aperçu des images disponibles localement, avec leur taille et la date de création.
Supprimer des images
Section intitulée « Supprimer des images »Si tu as une image dont tu n’as plus besoin, tu peux la supprimer avec la
commande docker rmi. Par exemple, pour supprimer l’image “mon_app” que tu as
créée précédemment :
docker rmi mon_appPush des images vers un registre
Section intitulée « Push des images vers un registre »Une fois ton image construite et prête à être partagée, tu peux la pousser vers un registre, tel que Docker Hub ou un registre privé. Pour cela, tu dois d’abord t’assurer que l’image est correctement taguée avec le nom du registre. Par exemple, si tu veux pousser “mon_app” vers Docker Hub sous l’utilisateur “mon_compte”, voici comment faire :
- D’abord, taguer l’image avec le nom du registre et ton compte Docker Hub :
docker tag mon_app mon_compte/mon_app:latest- Ensuite, pousser l’image vers le registre avec la commande
docker push:
docker push mon_compte/mon_app:latestAprès cette commande, ton image sera disponible sur Docker Hub et tu pourras la partager ou la déployer sur d’autres machines.
Lancer et gérer les conteneurs Docker
Section intitulée « Lancer et gérer les conteneurs Docker »Les conteneurs Docker sont des instances exécutées à partir d’une image. Chaque conteneur fonctionne de manière isolée, ce qui te permet de déployer et exécuter des applications indépendamment du reste de ton système. Voici les commandes clés pour lancer et gérer tes conteneurs Docker.
Lancer un conteneur
Section intitulée « Lancer un conteneur »La commande docker run est la plus couramment utilisée pour démarrer un
nouveau conteneur. Par exemple, pour lancer un conteneur Nginx, tu
utiliserais cette commande :
docker run nginxCela démarrera un conteneur basé sur l’image Nginx que tu as téléchargée précédemment. Le conteneur sera lancé au premier plan, ce qui signifie que tu devras garder la fenêtre de terminal ouverte pour le maintenir en cours d’exécution.
Si tu veux que le conteneur fonctionne en arrière-plan, tu peux utiliser
l’option -d (détaché) :
docker run -d nginxNommer un conteneur
Section intitulée « Nommer un conteneur »Pour faciliter la gestion, tu peux attribuer un nom à ton conteneur avec
l’option --name. Par exemple, pour lancer Nginx avec le nom “mon_nginx” :
docker run -d --name mon_nginx nginxCe nom te permettra de faire référence plus facilement au conteneur dans d’autres commandes.
Lister les conteneurs
Section intitulée « Lister les conteneurs »Pour voir tous les conteneurs en cours d’exécution, utilise docker ps :
docker psCela affichera les conteneurs actifs avec des informations telles que le nom,
l’ID et l’image utilisée. Si tu veux voir tous les conteneurs, même ceux qui
sont arrêtés, ajoute l’option -a :
docker ps -aExécuter une commande dans un conteneur
Section intitulée « Exécuter une commande dans un conteneur »Tu peux exécuter une commande dans un conteneur qui est en cours d’exécution en
utilisant docker exec. Par exemple, pour accéder à un terminal interactif dans
ton conteneur “mon_nginx” et vérifier la configuration du serveur Nginx :
docker exec -it mon_nginx /bin/bashCela te donne accès à un shell dans le conteneur pour effectuer des actions directement dedans.
Arrêter un conteneur
Section intitulée « Arrêter un conteneur »Si tu veux arrêter un conteneur en cours d’exécution, utilise docker stop
suivi du nom ou de l’ID du conteneur. Par exemple, pour arrêter “mon_nginx” :
docker stop mon_nginxSupprimer un conteneur
Section intitulée « Supprimer un conteneur »Si tu as un conteneur dont tu n’as plus besoin, tu peux le supprimer avec
docker rm. Attention, le conteneur doit être arrêté avant de le supprimer. Si
tu souhaites supprimer “mon_nginx” après l’avoir arrêté, voici la commande :
docker rm mon_nginxSi tu veux supprimer plusieurs conteneurs à la fois, tu peux utiliser leurs noms ou ID en les séparant par des espaces, ou utiliser une commande comme celle-ci pour supprimer tous les conteneurs arrêtés :
docker rm $(docker ps -a -q)Redémarrer un conteneur
Section intitulée « Redémarrer un conteneur »Enfin, si tu veux redémarrer un conteneur sans le recréer, utilise docker restart :
docker restart mon_nginxCela arrête et relance le conteneur sans perdre ses données ni sa configuration.
Gérer les volumes Docker
Section intitulée « Gérer les volumes Docker »Les volumes Docker sont utilisés pour stocker des données de manière persistante, même lorsque les conteneurs sont supprimés. Les volumes permettent de sauvegarder des données sur ton disque, ce qui est essentiel pour les applications nécessitant la persistance des informations, comme une base de données. Voici comment créer et gérer des volumes Docker.
Créer un volume
Section intitulée « Créer un volume »Pour créer un volume, utilise la commande docker volume create. Par exemple,
pour créer un volume nommé “mon_volume”, tu peux utiliser cette commande :
docker volume create mon_volumeCela va créer un volume persistant que tu pourras monter dans un ou plusieurs conteneurs.
Utiliser un volume avec un conteneur
Section intitulée « Utiliser un volume avec un conteneur »Pour monter un volume dans un conteneur, utilise l’option -v ou --mount avec
docker run. Par exemple, si tu veux lancer un conteneur Nginx et monter
“mon_volume” dans le dossier /usr/share/nginx/html du conteneur, voici la
commande :
docker run -d --name mon_nginx -v mon_volume:/usr/share/nginx/html nginxDans cet exemple, les fichiers du dossier /usr/share/nginx/html du conteneur
seront stockés dans “mon_volume” et les données resteront disponibles même
après la suppression du conteneur.
Lister les volumes
Section intitulée « Lister les volumes »Pour afficher la liste des volumes existants sur ta machine, utilise la commande
docker volume ls :
docker volume lsCela te montrera tous les volumes, qu’ils soient utilisés ou non par des conteneurs.
Inspecter un volume
Section intitulée « Inspecter un volume »Pour obtenir des détails sur un volume spécifique, utilise la commande docker volume inspect suivie du nom du volume. Par exemple, pour inspecter
“mon_volume” :
docker volume inspect mon_volumeCette commande te fournira des informations sur le volume, comme son chemin de stockage sur ton système.
Supprimer un volume
Section intitulée « Supprimer un volume »Si un volume n’est plus utilisé, tu peux le supprimer avec docker volume rm.
Par exemple, pour supprimer “mon_volume” :
docker volume rm mon_volumeAttention, Docker ne permet pas de supprimer un volume utilisé par un conteneur actif. Il faut donc d’abord arrêter et supprimer tous les conteneurs qui utilisent ce volume.
Nettoyer les volumes inutilisés
Section intitulée « Nettoyer les volumes inutilisés »Pour supprimer tous les volumes non utilisés par des conteneurs actifs, tu peux
utiliser la commande docker volume prune. Cela te permet de libérer de
l’espace disque en supprimant les volumes qui ne sont plus nécessaires :
docker volume pruneGérer les réseaux Docker
Section intitulée « Gérer les réseaux Docker »Les réseaux Docker permettent de connecter plusieurs conteneurs entre eux et avec le monde extérieur. Docker crée automatiquement des réseaux pour que les conteneurs puissent communiquer de manière isolée ou connectée selon les besoins de ton application. Voici comment créer, gérer et supprimer des réseaux Docker.
Créer un réseau
Section intitulée « Créer un réseau »Pour créer un réseau personnalisé, tu peux utiliser la commande docker network create. Par exemple, si tu veux créer un réseau nommé “mon_reseau” :
docker network create mon_reseauCe réseau te permettra de connecter différents conteneurs entre eux afin qu’ils puissent communiquer plus facilement.
Utiliser un réseau avec un conteneur
Section intitulée « Utiliser un réseau avec un conteneur »Lorsque tu lances un conteneur, tu peux le connecter à un réseau spécifique à
l’aide de l’option --network. Par exemple, pour démarrer un conteneur Nginx
sur le réseau “mon_reseau” :
docker run -d --name mon_nginx --network mon_reseau nginxLe conteneur “mon_nginx” sera désormais isolé au sein du réseau “mon_reseau”, et il pourra communiquer avec d’autres conteneurs présents sur ce même réseau.
Lister les réseaux
Section intitulée « Lister les réseaux »Pour voir tous les réseaux disponibles sur ta machine, utilise la commande
docker network ls :
docker network lsCela te montrera les réseaux par défaut de Docker (comme bridge, host, et
none) ainsi que ceux que tu as créés, comme “mon_reseau”.
Inspecter un réseau
Section intitulée « Inspecter un réseau »Si tu veux obtenir des informations détaillées sur un réseau, comme les
conteneurs qui y sont connectés, utilise la commande docker network inspect
suivie du nom du réseau. Par exemple, pour inspecter “mon_reseau” :
docker network inspect mon_reseauCela te donnera une vue détaillée sur la configuration du réseau et ses conteneurs associés.
Déconnecter un conteneur d’un réseau
Section intitulée « Déconnecter un conteneur d’un réseau »Si tu veux déconnecter un conteneur d’un réseau sans l’arrêter, tu peux utiliser
docker network disconnect. Par exemple, pour déconnecter “mon_nginx” de
“mon_reseau” :
docker network disconnect mon_reseau mon_nginxCela permet d’isoler un conteneur sans devoir le supprimer ou l’arrêter.
Supprimer un réseau
Section intitulée « Supprimer un réseau »Une fois que tu n’as plus besoin d’un réseau, tu peux le supprimer avec docker network rm. Par exemple, pour supprimer “mon_reseau” :
docker network rm mon_reseauDocker ne te permettra pas de supprimer un réseau s’il y a encore des conteneurs connectés à celui-ci. Il te faudra donc d’abord arrêter ou déconnecter les conteneurs actifs.
Nettoyer les réseaux inutilisés
Section intitulée « Nettoyer les réseaux inutilisés »Pour supprimer tous les réseaux qui ne sont pas utilisés par des conteneurs
actifs, utilise la commande docker network prune :
docker network pruneCela te permet de faire du nettoyage en supprimant les réseaux superflus qui ne sont plus utilisés.
Nettoyer les ressources inutilisées avec Docker prune
Section intitulée « Nettoyer les ressources inutilisées avec Docker prune »Avec le temps, Docker accumule des ressources inutilisées, telles que des
conteneurs arrêtés, des images non utilisées, des volumes orphelins et des
réseaux non utilisés. Pour éviter de surcharger ton système avec ces fichiers
inutiles, Docker offre une série de commandes prune pour effectuer un
nettoyage rapide et efficace.
La commande la plus générale pour nettoyer toutes les ressources inutilisées est
docker system prune. Elle supprime :
- Les conteneurs arrêtés
- Les images non utilisées par des conteneurs actifs
- Les volumes non montés dans des conteneurs
- Les réseaux inutilisés
Voici comment l’utiliser :
docker system pruneDocker te demandera une confirmation avant de supprimer les ressources inutilisées. Une fois la commande exécutée, tu gagneras de l’espace disque en supprimant tous ces éléments superflus.
Si tu veux spécifiquement supprimer les images non utilisées, tu peux
utiliser l’option -a avec docker system prune. Cela supprimera toutes les
images qui ne sont pas utilisées par un conteneur actif, même celles qui sont
encore présentes localement.
docker system prune -aCette commande est utile si tu souhaites faire un nettoyage en profondeur et supprimer toutes les anciennes versions d’images qui ne sont plus nécessaires.
Voici une version plus détaillée de la commande docker events au format
Markdown, avec quelques explications supplémentaires pour mieux comprendre son
usage :
Surveillance des Événements Docker
Section intitulée « Surveillance des Événements Docker »La commande docker events permet de surveiller en temps réel tous les
événements qui se produisent dans Docker. Cela inclut les événements liés aux
conteneurs, aux images, aux volumes et aux réseaux. C’est un outil très utile
pour le diagnostic et le suivi des activités de votre environnement Docker.
Utilisation de la commande
Section intitulée « Utilisation de la commande »$ docker eventsExemple de sortie
Section intitulée « Exemple de sortie »Lors de l’exécution de la commande, vous verrez des événements en temps réel comme ceux-ci :
2024-10-10T12:00:01.123456789Z container start 123abc456def (image=nginx, name=web-container)2024-10-10T12:00:05.987654321Z container stop 123abc456def (image=nginx, name=web-container)2024-10-10T12:01:10.654321987Z volume create my_volumeOptions courantes
Section intitulée « Options courantes »Vous pouvez filtrer les événements pour ne voir que ceux qui vous intéressent, en utilisant des options telles que :
-
Filtrer par type d’objet :
Par exemple, pour ne voir que les événements liés aux conteneurs :
Fenêtre de terminal $ docker events --filter "type=container" -
Filtrer par action spécifique :
Si vous ne souhaitez voir que les événements de démarrage de conteneurs :
Fenêtre de terminal $ docker events --filter "event=start" -
Filtrer par nom d’image ou de conteneur :
Par exemple, pour ne voir que les événements liés à une image spécifique comme
nginx:Fenêtre de terminal $ docker events --filter "image=nginx"
Applications pratiques
Section intitulée « Applications pratiques »- Débogage : Vous pouvez utiliser cette commande pour observer ce qui se passe lorsqu’un conteneur ne démarre pas correctement ou pour détecter des erreurs dans les volumes ou les réseaux.
- Surveillance : Elle est utile pour suivre l’activité des conteneurs dans un environnement de production afin de voir quels conteneurs démarrent ou s’arrêtent, ainsi que les modifications d’images.
- Audit : Vous pouvez surveiller les événements sur une période donnée pour obtenir un historique des actions qui ont été effectuées dans Docker.
Commandes avancées
Section intitulée « Commandes avancées »-
Surveiller un événement spécifique à un intervalle précis : Si vous souhaitez observer les événements d’une période donnée, utilisez l’option
--since:Fenêtre de terminal $ docker events --since '2024-10-10T12:00:00' --until '2024-10-10T13:00:00'
Cette commande vous permettra de surveiller Docker de manière efficace et de mieux comprendre ce qui se passe sous le capot de votre infrastructure de conteneurs.
Prochaines étapes
Section intitulée « Prochaines étapes »Travaux Pratiques Docker : Passe à l’action !
Section intitulée « Travaux Pratiques Docker : Passe à l’action ! »Tu connais maintenant les commandes essentielles. Mais connaître une commande et savoir l’utiliser au bon moment, ce n’est pas la même chose.
C’est comme apprendre à conduire : tu peux mémoriser le code de la route, mais c’est en prenant le volant que tu deviens vraiment autonome.
Pour t’aider à passer de la théorie à la pratique, j’ai créé une série de travaux pratiques progressifs sur mon dépôt GitHub :
- 🎯 Exercices guidés : chaque TP te donne un objectif clair et des indices
- 🔄 Difficulté progressive : du premier conteneur à l’orchestration multi-services
- ✅ Validation intégrée : tu sais immédiatement si ta solution fonctionne
- 📦 Environnement prêt à l’emploi : clone, lance, apprends
Mon conseil : ouvre ce cheat sheet dans un onglet, le dépôt des TPs dans un autre, et lance-toi. Tu vas voir, une fois que tu auras conteneurisé ta première application, tu ne pourras plus t’en passer !
Approfondir Docker
Section intitulée « Approfondir Docker »Ce cheat sheet t’a donné les commandes essentielles, mais Docker va bien plus loin. Chaque sujet ci-dessous mérite qu’on s’y attarde :
- Tu débutes ? Commence par comprendre les concepts fondamentaux
- Tu veux des images plus légères ? Les Dockerfiles optimisés font la différence
- Tu gères plusieurs services ? Docker Compose va te changer la vie
- Tu passes en production ? Les bonnes pratiques sécurité sont indispensables
Contrôle de connaissances
Section intitulée « Contrôle de connaissances »Tu penses maîtriser les commandes Docker ? Vérifie-le en 5 minutes !
Ce quiz rapide teste ta compréhension des commandes CLI que tu viens de découvrir. Pas de piège, juste l’essentiel : si tu as bien lu ce cheat sheet, tu devrais atteindre les 80% sans difficulté.
Astuce : si tu bloques sur une question, reviens parcourir la section correspondante. C’est comme ça qu’on apprend vraiment.
Contrôle de connaissances
Validez vos connaissances avec ce quiz interactif
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
Lance le quiz et démarre le chronomètre
📋 Récapitulatif de vos réponses
Vérifiez vos réponses avant de soumettre. Cliquez sur une question pour la modifier.
Détail des réponses
Questions fréquentes
Section intitulée « Questions fréquentes »Docker est une plateforme de conteneurisation qui permet d'empaqueter, distribuer et exécuter des applications dans des environnements isolés appelés conteneurs.
Définition
- Conteneur : unité légère et portable qui embarque l'application et toutes ses dépendances
- Image : modèle immuable servant de base aux conteneurs
- Registre : dépôt centralisé d'images (Docker Hub, registres privés)
Avantages clés
- Portabilité : "fonctionne partout" (dev, test, prod)
- Isolation : chaque conteneur a son propre système de fichiers
- Légèreté : partage le noyau de l'hôte (vs machines virtuelles)
- Reproductibilité : même environnement sur tous les systèmes
Architecture
┌─────────────────────────────────┐
│ Applications Docker │
├─────────────────────────────────┤
│ Conteneurs (isolés) │
├─────────────────────────────────┤
│ Docker Engine (démon) │
├─────────────────────────────────┤
│ Système d'exploitation │
└─────────────────────────────────┘
Cas d'usage
- Développement : environnements identiques pour toute l'équipe
- CI/CD : tests automatisés dans des conteneurs jetables
- Microservices : déploiement et mise à l'échelle indépendants
Un moteur de conteneurs (container engine) est le logiciel responsable de la création, du démarrage et de la gestion des conteneurs.
Rôles principaux
| Fonction | Description |
|---|---|
| Build | Créer des images à partir de Dockerfile |
| Run | Démarrer et arrêter les conteneurs |
| Isolation | Namespace, cgroups, capabilities |
| Réseau | Créer des réseaux virtuels entre conteneurs |
| Stockage | Gérer les volumes et bind mounts |
| Sécurité | Appliquer les politiques de sécurité |
Composants Docker Engine
# Vérifier le moteur
docker version
docker info
# Architecture
systemctl status docker # Démon dockerd
docker ps # CLI client
Alternatives à Docker
- Podman : compatible Docker, sans démon (plus sécurisé)
- containerd : runtime bas niveau (utilisé par Kubernetes)
- CRI-O : optimisé pour Kubernetes
Voici un comparatif des principaux moteurs de conteneurs selon leurs particularités :
| Moteur | Type | Particularités | Cas d'usage |
|---|---|---|---|
| Docker | Container engine complet | Écosystème mature, Docker Hub, Compose | Développement, production générale |
| Podman | Compatible Docker, daemonless | Sans démon root, pods, compatible CLI Docker | Sécurité, environnements non-root |
| containerd | Runtime bas niveau | Léger, intégré dans Kubernetes et Docker | Production Kubernetes |
| CRI-O | Runtime Kubernetes | Optimisé pour CRI, images OCI uniquement | Clusters Kubernetes dédiés |
| LXC/Incus | Conteneurs système | Machines virtuelles légères, init complet | Migration VM → conteneurs |
Exemples de commandes
# Docker (avec démon)
sudo docker run -d nginx
# Podman (sans démon)
podman run -d nginx
podman pod create mon-pod # Support natif des pods
# containerd (via ctr)
sudo ctr images pull docker.io/library/nginx:latest
sudo ctr run docker.io/library/nginx:latest nginx-ctr
Comment choisir ?
- Docker : développement, apprentissage, écosystème riche
- Podman : sécurité, CI/CD sans privilèges root
- containerd/CRI-O : clusters Kubernetes en production
Voici les bonnes pratiques essentielles pour une configuration Docker robuste en production :
Configuration système
| Aspect | Configuration | Justification |
|---|---|---|
| Stockage | Partition dédiée /var/lib/docker |
Éviter saturation du système si images/volumes consomment l'espace |
| Logs | Driver json-file avec rotation |
max-size: 10m, max-file: 3 pour limiter la croissance |
| Démon | Fichier /etc/docker/daemon.json |
Centraliser la config (log-driver, storage-driver, etc.) |
Sécurité réseau
{
"icc": false, // Désactiver communication inter-conteneurs par défaut
"userland-proxy": false,
"no-new-privileges": true
}
Limitations de ressources
# Limiter CPU et mémoire
docker run -d \
--memory="512m" \
--memory-swap="1g" \
--cpus="1.5" \
--restart=unless-stopped \
mon-app
Sécurité des conteneurs
# Dans le Dockerfile
USER node # Ne pas exécuter en root
# Images de confiance
FROM node:20-alpine # Images officielles minimales
# Health checks
HEALTHCHECK --interval=30s --timeout=3s \
CMD node healthcheck.js
Monitoring et observabilité
# Métriques Docker
docker stats
# Logs centralisés
# Configurer un driver de logs (syslog, fluentd, splunk)
Gestion des secrets
# Utiliser Docker secrets (Swarm) ou variables d'environnement sécurisées
docker secret create db_password ./password.txt
Checklist production
- ✅ Partition dédiée pour
/var/lib/docker - ✅ Rotation des logs configurée
- ✅ Utilisateurs non-root dans les conteneurs
- ✅ Ressources limitées (CPU/RAM)
- ✅ Images officielles et régulièrement mises à jour
- ✅ Health checks sur tous les services
- ✅ Monitoring actif (Prometheus, Grafana)
- ✅ Backups automatisés des volumes
La sécurisation Docker repose sur le principe du moindre privilège et des couches de défense en profondeur.
Principe du moindre privilège
# Limiter les capabilities Linux
docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE mon-app
# Exécuter en utilisateur non-root
docker run --user 1000:1000 mon-app
# Conteneur en lecture seule
docker run --read-only --tmpfs /tmp mon-app
# Désactiver les nouveaux privilèges
docker run --security-opt=no-new-privileges mon-app
Modules de sécurité (LSM)
# AppArmor (Ubuntu/Debian)
docker run --security-opt apparmor=docker-default nginx
# SELinux (RHEL/CentOS)
docker run --security-opt label=type:svirt_apache_t nginx
Confiance des images
# Activer Docker Content Trust (signatures)
export DOCKER_CONTENT_TRUST=1
docker pull nginx # Vérifie la signature
# Scanner les vulnérabilités avec Trivy
docker run aquasec/trivy image nginx:latest
Sécurité réseau
# Filtrage réseau (réseau personnalisé)
docker network create --internal backend
# Pas d'exposition inutile de ports
# ❌ docker run -p 0.0.0.0:3306:3306 mysql
# ✅ docker run -p 127.0.0.1:3306:3306 mysql
Gestion des secrets
# Docker Swarm secrets
echo "mon_mot_de_passe" | docker secret create db_password -
docker service create --secret db_password mon-api
# Variables d'environnement (fichier séparé)
docker run --env-file .env.production mon-app
Audit et monitoring
# Audit des événements Docker
auditctl -w /var/lib/docker -k docker
auditctl -w /usr/bin/docker -k docker
# Logs centralisés
# Configurer syslog/fluentd dans /etc/docker/daemon.json
Images minimales
# Préférer Alpine ou scratch
FROM alpine:latest # ~5 MB vs debian:latest ~120 MB
# Multi-stage pour exécutables statiques
FROM scratch
COPY --from=builder /app/binary /
ENTRYPOINT ["/binary"]
Checklist sécurité
- ✅ Utilisateur non-root dans tous les conteneurs
- ✅ Capabilities minimales (--cap-drop=ALL)
- ✅ AppArmor/SELinux activés
- ✅ Content Trust activé (DOCKER_CONTENT_TRUST=1)
- ✅ Scan régulier des images (Trivy, Clair)
- ✅ Réseau interne pour services backend
- ✅ Secrets gérés via Docker secrets ou vault
- ✅ Audit actif sur /var/lib/docker
- ✅ Images minimales (Alpine/scratch)
- ✅ Mises à jour régulières des images de base
Docker propose trois types de stockage pour persister les données au-delà de la vie d'un conteneur.
Comparaison des types
| Type | Emplacement | Gestion | Cas d'usage |
|---|---|---|---|
| Volumes | /var/lib/docker/volumes/ |
Docker (recommandé) | Bases de données, données applicatives |
| Bind mounts | Chemin absolu sur l'hôte | Utilisateur | Développement, fichiers de configuration |
| tmpfs | Mémoire RAM uniquement | Éphémère | Secrets, données temporaires sensibles |
Commandes volumes
# Créer un volume
docker volume create mon-volume
# Lister les volumes
docker volume ls
# Inspecter un volume
docker volume inspect mon-volume
# Utiliser un volume
docker run -v mon-volume:/data postgres
# Supprimer un volume
docker volume rm mon-volume
Exemples Docker Compose
services:
db:
image: postgres
volumes:
- db-data:/var/lib/postgresql/data # Volume nommé
- ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro # Bind mount
volumes:
db-data: # Déclaration du volume
Backup et restore
# Sauvegarder un volume
docker run --rm -v mon-volume:/data -v $(pwd):/backup alpine tar czf /backup/data.tar.gz /data
# Restaurer un volume
docker run --rm -v mon-volume:/data -v $(pwd):/backup alpine tar xzf /backup/data.tar.gz -C /
Plugins de stockage
- Local : stockage par défaut sur l'hôte
- NFS : partage réseau entre plusieurs hôtes
- SSHFS : montage distant via SSH
- Cloud : Azure Files, AWS EFS, Google Filestore
Une image Docker est un modèle immuable qui contient tout le nécessaire pour exécuter une application, tandis qu'un conteneur est une instance en cours d'exécution de cette image.
Comparaison
| Aspect | Image | Conteneur |
|---|---|---|
| Nature | Modèle statique, immuable | Instance dynamique, éphémère |
| Stockage | Système de fichiers en couches (layers) | Couche en lecture/écriture au-dessus de l'image |
| État | Aucun état (stateless) | Possède un état (stateful) |
| Partage | Peut servir de base à plusieurs conteneurs | Isolé, ne peut pas être partagé |
| Cycle de vie | Créée une fois, utilisée plusieurs fois | Créé, démarré, arrêté, supprimé |
Analogie
Image = classe en programmation → Conteneur = objet (instance de la classe)
Commandes
# Lister les images
docker images
# Lister les conteneurs en cours d'exécution
docker ps
# Lister tous les conteneurs (actifs et arrêtés)
docker ps -a
# Créer un conteneur à partir d'une image
docker run nginx # Image nginx → Conteneur nginx
Structure en couches
Chaque image est composée de layers (couches) en lecture seule. Le conteneur ajoute une couche en lecture/écriture au-dessus.
Docker propose plusieurs modes réseau pour connecter les conteneurs entre eux ou au monde extérieur.
Modes réseau
| Mode | Description | Cas d'usage |
|---|---|---|
| bridge | Réseau virtuel isolé (par défaut) | Communication entre conteneurs sur un même hôte |
| host | Partage la pile réseau de l'hôte | Performance maximale (pas de NAT) |
| overlay | Réseau multi-hôtes (Swarm/Kubernetes) | Clusters de conteneurs sur plusieurs machines |
| macvlan | Attribution d'adresses MAC virtuelles | Intégration au réseau physique existant |
| none | Aucun réseau | Isolation réseau complète |
Exemple : Réseau bridge personnalisé
# Créer un réseau bridge
docker network create mon-reseau
# Lancer des conteneurs dans ce réseau
docker run -d --name db --network mon-reseau postgres
docker run -d --name api --network mon-reseau -p 3000:3000 mon-api
# Les conteneurs peuvent communiquer par leur nom
# Depuis 'api' : psql -h db -U postgres
Exposition de ports
# Mapper un port hôte → conteneur
docker run -p 8080:80 nginx # localhost:8080 → nginx:80
# Publier tous les ports EXPOSE du Dockerfile
docker run -P nginx
DNS interne
Docker fournit un DNS intégré : les conteneurs se résolvent mutuellement par leur nom sur les réseaux personnalisés (bridge/overlay).
Docker Compose permet de définir et gérer des applications multi-conteneurs à l'aide d'un seul fichier YAML déclaratif.
Avantages
- Simplicité : un fichier
docker-compose.ymlremplace plusieursdocker run - Reproductibilité : toute l'équipe utilise la même stack
- Gestion du cycle de vie : démarrage/arrêt/rebuild de tous les services en une commande
- Environnements multiples : profils dev/test/prod dans le même fichier
Exemple complet
services:
db:
image: postgres:15-alpine
environment:
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
volumes:
- db-data:/var/lib/postgresql/data
networks:
- backend
secrets:
- db_password
healthcheck:
test: ["CMD", "pg_isready", "-U", "postgres"]
interval: 10s
api:
build: ./api
env_file: .env
depends_on:
db:
condition: service_healthy
networks:
- backend
- frontend
web:
image: nginx:alpine
ports:
- "80:80"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf:ro
networks:
- frontend
profiles:
- prod
networks:
backend:
frontend:
volumes:
db-data:
secrets:
db_password:
file: ./db_password.txt
Commandes essentielles
# Démarrer tous les services
docker compose up -d
# Voir les logs en temps réel
docker compose logs -f api
# Lister les conteneurs
docker compose ps
# Exécuter une commande dans un service
docker compose exec api sh
# Arrêter et supprimer
docker compose down
# Activer un profil spécifique
docker compose --profile prod up -d
Variables d'environnement
# Fichier .env
API_PORT=3000
DB_VERSION=15
# Référencées dans docker-compose.yml
ports:
- "${API_PORT}:3000"
Docker et Kubernetes sont complémentaires : Docker conteneurise les applications, Kubernetes les orchestre à grande échelle.
Comparaison
| Aspect | Docker | Kubernetes |
|---|---|---|
| Niveau | Conteneur individuel | Cluster de conteneurs |
| Scope | Machine unique | Multi-machines (cluster) |
| Objectif | Empaqueter et exécuter | Orchestrer et automatiser |
| Scaling | Manuel (docker run x N) |
Automatique (HorizontalPodAutoscaler) |
| Haute disponibilité | Non (conteneur unique) | Oui (réplication, self-healing) |
| Configuration | CLI/docker-compose.yml | Manifestes YAML (Deployment, Service, etc.) |
| Complexité | Simple, facile à apprendre | Courbe d'apprentissage élevée |
Exemples
Docker : exécution simple
# Lancer 3 répliques manuellement
docker run -d --name web1 -p 8001:80 nginx
docker run -d --name web2 -p 8002:80 nginx
docker run -d --name web3 -p 8003:80 nginx
# Pas de load balancing automatique
# Pas de redémarrage automatique si crash
Kubernetes : orchestration automatique
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
replicas: 3 # 3 répliques automatiques
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:latest
ports:
- containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: LoadBalancer
selector:
app: nginx
ports:
- port: 80
targetPort: 80
# Kubernetes gère automatiquement :
kubectl apply -f deployment.yaml
# → 3 pods répartis sur le cluster
# → Load balancing automatique
# → Redémarrage auto si crash (self-healing)
# → Rolling updates sans downtime
Fonctionnalités Kubernetes
- Auto-scaling : ajustement automatique du nombre de pods selon la charge (CPU/RAM)
- Self-healing : redémarrage automatique des pods en échec
- Rolling updates : déploiements sans interruption (A/B testing, canary)
- Service discovery : DNS interne pour communication entre services
- ConfigMaps & Secrets : gestion centralisée de la configuration
- Persistent Volumes : stockage persistant indépendant du cycle de vie des pods
Architecture
Docker :
┌─────────────────┐
│ Machine │
│ ┌───┬───┬───┐ │
│ │C1 │C2 │C3 │ │ (Conteneurs isolés)
│ └───┴───┴───┘ │
│ Docker Engine │
└─────────────────┘
Kubernetes :
┌────────────────────────────────────┐
│ Cluster K8s │
│ ┌─────────┐ ┌─────────┐ │
│ │ Node 1 │ │ Node 2 │ ... │
│ │ ┌─┬─┬─┐ │ │ ┌─┬─┐ │ │
│ │ │P│P│P│ │ │ │P│P│ │ │ (Pods répartis)
│ │ └─┴─┴─┘ │ │ └─┴─┘ │ │
│ └─────────┘ └─────────┘ │
│ Control Plane (API, Scheduler) │
└────────────────────────────────────┘
Quand utiliser quoi ?
| Contexte | Outil recommandé |
|---|---|
| Développement local | Docker + Docker Compose |
| Application simple (1-5 conteneurs) | Docker |
| Production à grande échelle (>10 conteneurs) | Kubernetes |
| Besoin de haute disponibilité | Kubernetes |
| Multi-cloud ou cloud hybride | Kubernetes |
| Équipe sans expertise DevOps | Docker (plus simple) |
Un Dockerfile est un fichier texte contenant les instructions pour construire une image Docker de manière reproductible.
Instructions principales
| Instruction | Rôle | Exemple |
|---|---|---|
| FROM | Image de base | FROM node:20-alpine |
| WORKDIR | Répertoire de travail | WORKDIR /app |
| COPY | Copier des fichiers | COPY package*.json ./ |
| RUN | Exécuter des commandes | RUN npm install |
| EXPOSE | Documenter les ports | EXPOSE 3000 |
| ENV | Variables d'environnement | ENV NODE_ENV=production |
| CMD | Commande par défaut | CMD ["npm", "start"] |
| ENTRYPOINT | Point d'entrée fixe | ENTRYPOINT ["docker-entrypoint.sh"] |
Exemple multi-stage (optimisation)
# Étape 1 : Build
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# Étape 2 : Production
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/index.js"]
Utilisation
# Construire une image
docker build -t mon-app:1.0 .
# Lancer un conteneur
docker run -p 3000:3000 mon-app:1.0
Bonnes pratiques
- Utiliser des images de base officielles et légères (Alpine)
- Créer un fichier .dockerignore (node_modules, .git)
- Minimiser les couches : regrouper les RUN
- Multi-stage builds : images finales plus petites
- Ne pas exécuter en root :
USER node