Docker pour les Débutants : Guide Complet des Conteneurs en 2026
Docker pour les Débutants : Guide Complet des Conteneurs en 2026
Apprenez Docker de zéro. Comprenez les conteneurs, images, Dockerfile et Docker Compose avec des exemples pratiques.
Pourquoi Tout Développeur Devrait Apprendre Docker
"Ça marche sur ma machine" – cette phrase, tout développeur l'a prononcée au moins une fois. Les différences d'environnement, les conflits de dépendances, les configurations incohérentes : ces problèmes handicapent d'innombrables équipes de développement. Docker a fondamentalement résolu ce problème.
En 2026, Docker n'est plus uniquement un outil pour les ingénieurs DevOps – c'est une compétence fondamentale pour tout développeur moderne. Que vous soyez développeur backend, ingénieur full-stack ou data scientist, Docker rend votre travail plus efficace et plus fiable.
Concepts Fondamentaux : Conteneurs vs Machines Virtuelles
Machines Virtuelles (VM)
Les VM émulent un environnement matériel complet et exécutent un système d'exploitation entier. Chaque VM contient :
- Système d'exploitation invité (plusieurs Go)
- Application et dépendances
- Isolation via hyperviseur
Problème : Démarrage lent (en minutes), forte consommation de ressources, volume important.
Conteneurs
Les conteneurs partagent le noyau du système hôte et n'embarquent que l'application et ses dépendances nécessaires :
| Comparatif | Machine Virtuelle | Conteneur |
|---|---|---|
| Temps de démarrage | 1–2 minutes | Quelques secondes |
| Espace disque | En Go | En Mo |
| Surcharge mémoire | Importante | Faible |
| Niveau d'isolation | Isolation complète | Isolation processus |
| Portabilité | Moyenne | Très élevée |
Composants Principaux de Docker
Images
Une image Docker est le modèle d'un conteneur – un système de fichiers en couches en lecture seule. Imaginez une image comme un "snapshot" de l'application, contenant tout le nécessaire pour l'exécuter : code, runtime, bibliothèques, variables d'environnement et fichiers de configuration.
Conteneurs
Un conteneur est une instance en cours d'exécution d'une image. Une image peut démarrer plusieurs conteneurs. Les conteneurs peuvent être démarrés, arrêtés, déplacés et supprimés.
Dockerfile
Le Dockerfile est le script de construction d'images – une série d'instructions indiquant à Docker comment construire l'image.
Docker Registry
Un registry est le lieu de stockage et de distribution des images. Docker Hub est le plus grand registry public ; vous pouvez aussi héberger un registry privé.
Installer Docker
Visitez https://www.docker.com/products/docker-desktop et téléchargez Docker Desktop pour votre système d'exploitation (Mac, Windows ou Linux).
Après l'installation, vérifiez :
docker --version
# Docker version 25.0.3, build 4debf41
docker run hello-world
# Exécuter le premier conteneur, vérifier l'installation
Aide-Mémoire des Commandes Docker
# Opérations sur les images
docker pull nginx # Télécharger une image
docker images # Lister les images locales
docker rmi nginx # Supprimer une image
docker build -t myapp . # Construire une image depuis un Dockerfile
# Opérations sur les conteneurs
docker run nginx # Démarrer un conteneur
docker run -d nginx # Démarrer en arrière-plan
docker run -p 8080:80 nginx # Mapping de ports (hôte:conteneur)
docker run -v /host:/container nginx # Monter un volume
docker ps # Lister les conteneurs actifs
docker ps -a # Lister tous les conteneurs (dont arrêtés)
docker stop <id> # Arrêter un conteneur
docker rm <id> # Supprimer un conteneur
docker logs <id> # Afficher les logs du conteneur
docker exec -it <id> bash # Entrer dans le terminal du conteneur
# Réseau
docker network ls # Lister les réseaux
docker network create mynet # Créer un réseau
Écrire Votre Premier Dockerfile
Exemple avec une application Node.js :
// app.js
const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;
app.get('/', (req, res) => {
res.json({
message: 'Bonjour depuis Docker !',
timestamp: new Date().toISOString()
});
});
app.get('/health', (req, res) => {
res.json({ status: 'healthy' });
});
app.listen(PORT, () => {
console.log(`Serveur démarré sur le port ${PORT}`);
});
{
"name": "docker-demo",
"version": "1.0.0",
"main": "app.js",
"scripts": {
"start": "node app.js"
},
"dependencies": {
"express": "^4.18.2"
}
}
# Dockerfile
# Étape 1 : Choisir l'image de base
FROM node:20-alpine
# Étape 2 : Définir le répertoire de travail
WORKDIR /app
# Étape 3 : Copier les fichiers de dépendances (optimiser le cache Docker)
COPY package*.json ./
# Étape 4 : Installer les dépendances
RUN npm ci --only=production
# Étape 5 : Copier le code applicatif
COPY . .
# Étape 6 : Exposer le port
EXPOSE 3000
# Étape 7 : Définir un utilisateur non-root (bonne pratique de sécurité)
USER node
# Étape 8 : Commande de démarrage
CMD ["node", "app.js"]
Construire et exécuter :
# Construire l'image
docker build -t my-node-app .
# Démarrer le conteneur
docker run -d -p 3000:3000 --name my-app my-node-app
# Tester
curl http://localhost:3000
# {"message":"Bonjour depuis Docker !","timestamp":"2026-03-17T..."}
Fichier .dockerignore
Similaire à .gitignore, il empêche la copie de fichiers inutiles dans l'image :
node_modules
npm-debug.log
.git
.gitignore
README.md
.env
.env.*
Dockerfile
.dockerignore
Docker Compose : Gérer Plusieurs Conteneurs
Les applications réelles nécessitent souvent plusieurs services coordonnés (serveur web + base de données + cache). Docker Compose simplifie cette gestion :
# docker-compose.yml
version: '3.8'
services:
app:
build: .
ports:
- "3000:3000"
environment:
- NODE_ENV=production
- DATABASE_URL=postgresql://user:password@db:5432/mydb
- REDIS_URL=redis://cache:6379
depends_on:
db:
condition: service_healthy
cache:
condition: service_started
restart: unless-stopped
networks:
- app-network
db:
image: postgres:16-alpine
environment:
POSTGRES_USER: user
POSTGRES_PASSWORD: password
POSTGRES_DB: mydb
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U user -d mydb"]
interval: 10s
timeout: 5s
retries: 5
networks:
- app-network
cache:
image: redis:7-alpine
volumes:
- redis_data:/data
networks:
- app-network
nginx:
image: nginx:alpine
ports:
- "80:80"
- "443:443"
volumes:
- ./nginx.conf:/etc/nginx/conf.d/default.conf
depends_on:
- app
networks:
- app-network
volumes:
postgres_data:
redis_data:
networks:
app-network:
driver: bridge
Commandes Docker Compose :
docker-compose up -d # Démarrer tous les services (arrière-plan)
docker-compose down # Arrêter et supprimer les conteneurs
docker-compose down -v # Supprimer aussi les volumes
docker-compose logs -f app # Suivre les logs du service app
docker-compose ps # Afficher l'état des services
docker-compose exec app bash # Entrer dans le conteneur app
docker-compose build # Reconstruire les images
docker-compose restart # Redémarrer tous les services
Builds Multi-Étapes
Les builds multi-étapes réduisent considérablement la taille de l'image finale :
# Build multi-étapes (application Go)
# Étape 1 : Construction
FROM golang:1.22 AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main .
# Étape 2 : Image finale (très légère)
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
CMD ["./main"]
La taille de l'image peut passer de plusieurs centaines de Mo à quelques dizaines de Mo.
Bonnes Pratiques
1. Optimiser le cache des layers
# Bien : copier les fichiers de dépendances d'abord
COPY package*.json ./
RUN npm install
COPY . . # Les changements de code n'invalident pas le cache npm
# Mal : tout copier en une fois
COPY . . # Tout changement réinstalle les dépendances
RUN npm install
2. Utiliser des versions d'images précises
# Bien : version spécifique
FROM node:20.11.1-alpine3.19
# Mal : imprévisible
FROM node:latest
3. Ajouter un Health Check
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
CMD wget -qO- http://localhost:3000/health || exit 1
Conclusion
Docker a une courbe d'apprentissage abordable mais offre des bénéfices considérables. De "ça marche sur ma machine" à "ça fonctionne partout" – Docker aide les équipes à éliminer les différences d'environnement, simplifier le déploiement et améliorer la collaboration.
Avec les concepts fondamentaux présentés dans cet article – images, conteneurs, Dockerfile et Docker Compose – vous avez les bases pour utiliser Docker dans de vrais projets. La prochaine étape est Kubernetes, pour orchestrer et gérer des clusters de conteneurs en production.