Docker pour Débutants en 2026 : Guide Complet

Par Lucas M Dev — 28 mars 2026 — 13 min de lecture

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

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

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 :

→ Déployer votre app Docker gratuitement

→ Créer une API REST avec Node.js