Docker pour Débutants en 2026 : Guide Complet

Docker pour Débutants en 2026 : Comprendre et Utiliser les Containers

Docker est devenu incontournable dans le développement modern. En 2026, la quasi-totalité des entreprises utilisent des containers pour déployer leurs applications. Ce guide vous explique Docker de zéro, avec des exemples pratiques.

C'est quoi Docker et pourquoi ça change tout

Docker permet de "containeriser" vos applications : mettre votre code + ses dépendances + sa configuration dans un package portable qui tourne de la même façon partout.

Le problème que Docker résout : "Ça marche sur ma machine mais pas sur le serveur". Avec Docker, votre container contient TOUT ce dont votre app a besoin. Elle tournera exactement pareil en développement, staging, et production.

Différence entre Container et VM

• VM : un OS complet virtualisé (lourd, slow, 1-10 GB)
• Container : partage le kernel de l'OS hôte, isole juste le processus (léger, fast, 10-100 MB)

Installation

# Linux (Ubuntu/Debian)
sudo apt update
sudo apt install docker.io docker-compose-plugin
sudo usermod -aG docker $USER # Utiliser Docker sans sudo
# Déconnectez-vous et reconnectez-vous

# Mac / Windows : Docker Desktop
# https://www.docker.com/products/docker-desktop

# Vérifier l'installation
docker --version
docker run hello-world # Test complet

Concepts fondamentaux

• Image : template en lecture seule (recette de cuisine)
• Container : instance en cours d'exécution d'une image (le plat cuisiné)
• Dockerfile : fichier texte qui décrit comment construire une image
• Registry : dépôt d'images (Docker Hub, GitHub Container Registry)
• Volume : stockage persistant pour les containers

Commandes essentielles

# Lancer un container
docker run nginx # Lance nginx en foreground
docker run -d nginx # En background (detached)
docker run -d -p 8080:80 nginx # Exposer le port 80 → 8080
docker run -d --name mon-nginx nginx # Nommer le container

# Gérer les containers
docker ps # Containers actifs
docker ps -a # Tous (incluant arrêtés)
docker stop mon-nginx # Arrêter
docker start mon-nginx # Démarrer
docker rm mon-nginx # Supprimer
docker rm -f mon-nginx # Force stop + delete

# Gérer les images
docker images # Lister les images
docker pull node:20 # Télécharger une image
docker rmi node:20 # Supprimer une image

# Logs et debug
docker logs mon-nginx # Voir les logs
docker logs -f mon-nginx # Suivre les logs en live
docker exec -it mon-nginx bash # Shell dans un container actif

# Nettoyage
docker system prune # Supprimer tout ce qui est inutilisé

Votre premier Dockerfile

# Dockerfile pour une app Node.js
FROM node:20-alpine

# Créer le dossier de travail
WORKDIR /app

# Copier les fichiers de dépendances
COPY package*.json ./

# Installer les dépendances
RUN npm ci --only=production

# Copier le reste du code
COPY . .

# Builder TypeScript (si applicable)
RUN npm run build

# Exposer le port
EXPOSE 3000

# Commande de démarrage
CMD ["node", "dist/index.js"]

# Construire l'image
docker build -t mon-app:latest .
docker build -t mon-app:v1.0 .

# Lancer le container
docker run -d -p 3000:3000 --name mon-app mon-app:latest

# Tester
curl http://localhost:3000/health

Optimiser le Dockerfile

# Dockerfile optimisé avec multi-stage build
# Stage 1 : Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2 : Production (image finale plus petite)
FROM node:20-alpine AS production
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY --from=builder /app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/index.js"]

# .dockerignore — équivalent du .gitignore
node_modules/
.env
dist/
*.log
.git/

Docker Compose — Orchestrer plusieurs services

Docker Compose permet de définir et démarrer plusieurs containers en une commande. Parfait pour une stack complète (app + base de données + cache).

# docker-compose.yml
version: '3.9'

services:
 app:
 build: .
 ports:
 - "3000:3000"
 environment:
 - NODE_ENV=production
 - DATABASE_URL=postgresql://user:password@db:5432/mydb
 depends_on:
 - db
 - redis
 restart: unless-stopped

 db:
 image: postgres:16-alpine
 volumes:
 - postgres_data:/var/lib/postgresql/data
 environment:
 - POSTGRES_USER=user
 - POSTGRES_PASSWORD=password
 - POSTGRES_DB=mydb
 restart: unless-stopped

 redis:
 image: redis:7-alpine
 restart: unless-stopped

volumes:
 postgres_data:

# Commandes Docker Compose
docker compose up -d # Démarrer tous les services en background
docker compose down # Arrêter et supprimer les containers
docker compose logs -f # Voir les logs de tous les services
docker compose ps # État des services
docker compose restart app # Redémarrer un service
docker compose exec app bash # Shell dans un service

Workflow de développement avec Docker

# docker-compose.dev.yml
version: '3.9'

services:
 app:
 build:
 context: .
 target: development
 ports:
 - "3000:3000"
 volumes:
 - .:/app # Hot reload : votre code local monté
 - /app/node_modules # Exclure node_modules du montage
 command: npm run dev
 environment:
 - NODE_ENV=development

 db:
 image: postgres:16-alpine
 ports:
 - "5432:5432" # Accessible depuis votre machine
 environment:
 - POSTGRES_PASSWORD=dev

Pour aller plus loin

Une fois les bases maîtrisées, explorez :

• Kubernetes (K8s) : orchestration de containers à grande échelle
• Docker Hub : partager vos images publiquement
• GitHub Container Registry (GHCR) : images privées liées à votre repo
• Fly.io, Railway, Render : plateformes qui déploient directement depuis Docker

→ Déployer votre app Docker gratuitement
→ Créer une API REST avec Node.js