Docker pour débutants 2025 : Installation, premiers conteneurs et Docker Compose (Guide complet)

Docker en 2025 : pourquoi tous les développeurs doivent le maîtriser

En 2025, 92% des entreprises IT utilisent Docker (contre 80% en 2024). Si tu n'utilises pas encore Docker, tu passes à côté d'un outil qui va révolutionner ta productivité. 🚀

Docker résout un problème universel : "Mais ça marche sur ma machine !" Grâce aux conteneurs, ton application fonctionnera exactement pareil sur ton laptop, sur le serveur de prod, et sur la machine de ton collègue.

Dans ce tutoriel ultra-complet, tu vas apprendre :

• 🐳 Qu'est-ce que Docker et pourquoi l'utiliser
• ⚙️ Installer Docker sur Windows, Mac et Linux
• 🚀 Lancer tes premiers conteneurs
• 📦 Créer tes propres images avec Dockerfile
• 🔗 Docker Compose : gérer plusieurs conteneurs
• ✨ Best practices 2025 : sécurité, performance, production
• 💻 Exemples concrets : Node.js + PostgreSQL + Nginx

Prêt à devenir un pro de Docker ? Let's go ! 💪

Qu'est-ce que Docker ?

Le problème avant Docker

Imagine : tu développes une app Node.js sur ton Mac avec Node v20, PostgreSQL 16, et Redis 7. Ton collègue a Node v18, PostgreSQL 15, et pas Redis. En production, le serveur a Node v21 et PostgreSQL 14.

Résultat : bugs incompréhensibles, heures perdues à débugger des différences d'environnement, déploiements qui plantent...

La solution : les conteneurs Docker

Un conteneur est comme une boîte isolée qui contient :

• Ton application
• Toutes ses dépendances (Node, PostgreSQL, Redis...)
• Les configurations nécessaires

Cette boîte fonctionne exactement pareil partout : dev, staging, prod. Plus de "ça marche chez moi" ! ✅

Docker vs Machine virtuelle

Critère	Docker (conteneur)	VM
Démarrage	⚡ Quelques secondes	🐌 Plusieurs minutes
Taille	📦 Mo (50-500 MB)	💾 Go (plusieurs GB)
Performance	🏆 Quasi-native	⚠️ Overhead significatif
Isolation	Processus	Système complet
Use case	Microservices, apps modernes	OS différents, isolation totale

Installation de Docker en 2025

Windows (Docker Desktop)

Prérequis

• Windows 10/11 (64-bit)
• WSL 2 activé (Windows Subsystem for Linux)
• Virtualisation activée dans le BIOS

Installation pas à pas

1. Télécharge Docker Desktop pour Windows
2. Lance l'installeur Docker Desktop Installer.exe
3. Coche "Use WSL 2 instead of Hyper-V"
4. Redémarre ton PC
5. Lance Docker Desktop

Vérifier l'installation

Ouvre PowerShell ou CMD :

docker --version
# Docker version 27.1.0, build 1234abc

docker run hello-world
# Should download and run a test container

Mac (Docker Desktop)

Prérequis

• macOS 11 ou supérieur
• Mac avec Apple Silicon (M1/M2/M3) OU Intel

Installation

1. Télécharge Docker Desktop pour Mac (choisis Apple Silicon ou Intel)
2. Ouvre le fichier .dmg
3. Glisse Docker dans Applications
4. Lance Docker Desktop depuis Applications
5. Accepte les permissions

Vérifier l'installation

docker --version
docker run hello-world

Linux (Ubuntu/Debian)

Installation via script officiel (recommandé)

# Télécharge et lance le script d'installation
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Ajoute ton user au groupe docker (évite sudo)
sudo usermod -aG docker $USER

# Déconnecte/reconnecte ou applique le groupe
newgrp docker

# Vérifie l'installation
docker --version
docker run hello-world

Installation manuelle (Ubuntu)

# Mise à jour et dépendances
sudo apt update
sudo apt install ca-certificates curl gnupg

# Ajoute la clé GPG officielle Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Ajoute le repository Docker
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installe Docker Engine
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Vérifie
docker --version

Concepts clés Docker

1. Image

Une image est un modèle (template) en lecture seule qui contient tout pour faire tourner une app :

• Code de l'application
• Runtime (Node.js, Python, Java...)
• Dépendances (libraries, packages)
• Configuration

Analogie : l'image est comme un ISO de jeu vidéo.

2. Conteneur

Un conteneur est une instance en cours d'exécution d'une image. Tu peux lancer plusieurs conteneurs de la même image.

Analogie : le conteneur est le jeu qui tourne sur ta console.

3. Dockerfile

Un Dockerfile est un fichier texte qui contient les instructions pour construire une image.

4. Docker Hub

Docker Hub est le "GitHub des images Docker". Tu y trouves des milliers d'images officielles : Node.js, PostgreSQL, Nginx, Redis...

Premiers pas : lancer un conteneur

Exemple 1 : Nginx (serveur web)

# Lance un serveur Nginx
docker run -d -p 8080:80 --name mon-nginx nginx

# Explications :
# -d : détaché (tourne en arrière-plan)
# -p 8080:80 : map le port 80 du conteneur au port 8080 de ton PC
# --name mon-nginx : nomme le conteneur
# nginx : image à utiliser

Ouvre ton navigateur sur http://localhost:8080 → Tu vois la page Nginx ! 🎉

Commandes essentielles

# Voir les conteneurs en cours
docker ps

# Voir TOUS les conteneurs (même arrêtés)
docker ps -a

# Arrêter un conteneur
docker stop mon-nginx

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

# Supprimer un conteneur
docker rm mon-nginx

# Voir les logs d'un conteneur
docker logs mon-nginx

# Entrer dans un conteneur (bash)
docker exec -it mon-nginx bash

Exemple 2 : PostgreSQL

# Lance PostgreSQL
docker run -d \
  --name ma-postgres \
  -e POSTGRES_PASSWORD=monsecret \
  -e POSTGRES_DB=mabase \
  -p 5432:5432 \
  postgres:16

# Explications :
# -e : variables d'environnement
# POSTGRES_PASSWORD : mot de passe du user postgres
# POSTGRES_DB : nom de la DB à créer
# postgres:16 : image PostgreSQL version 16

Connecte-toi avec un client SQL sur localhost:5432 avec user postgres et password monsecret.

Créer sa propre image avec Dockerfile

Exemple : Application Node.js

1. Structure du projet

mon-app/
├── Dockerfile
├── package.json
├── package-lock.json
└── server.js

2. Contenu de server.js

// server.js
const express = require('express');
const app = express();
const PORT = 3000;

app.get('/', (req, res) => {
  res.json({ message: 'Hello from Docker! 🐳' });
});

app.listen(PORT, '0.0.0.0', () => {
  console.log(`Server running on port ${PORT}`);
});

3. Contenu de package.json

{
  "name": "mon-app-docker",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

4. Créer le Dockerfile

# Dockerfile

# 1. Image de base (Node.js 20 Alpine = légère)
FROM node:20-alpine

# 2. Définir le répertoire de travail dans le conteneur
WORKDIR /app

# 3. Copier package.json et package-lock.json
COPY package*.json ./

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

# 5. Copier le code de l'app
COPY . .

# 6. Exposer le port 3000
EXPOSE 3000

# 7. Définir la commande de démarrage
CMD ["npm", "start"]

5. Construire l'image

# Build l'image avec le tag "mon-app:v1"
docker build -t mon-app:v1 .

# Vérifie que l'image existe
docker images | grep mon-app

6. Lancer le conteneur

docker run -d -p 3000:3000 --name mon-app-container mon-app:v1

# Teste l'API
curl http://localhost:3000
# {"message":"Hello from Docker! 🐳"}

Docker Compose : orchestrer plusieurs conteneurs

Problème

Une app moderne utilise souvent plusieurs services :

• Backend Node.js
• Base de données PostgreSQL
• Redis pour le cache
• Nginx pour reverse proxy

Lancer chaque conteneur manuellement avec docker run est fastidieux. 😫

Solution : Docker Compose

Docker Compose permet de définir et gérer plusieurs conteneurs dans un fichier YAML.

Exemple complet : App full-stack

Structure du projet

mon-projet/
├── docker-compose.yml
├── backend/
│   ├── Dockerfile
│   ├── package.json
│   └── server.js
├── frontend/
│   ├── Dockerfile
│   ├── package.json
│   └── index.html
└── nginx/
    └── nginx.conf

Fichier docker-compose.yml

# docker-compose.yml
version: '3.8'

services:
  # Service PostgreSQL
  db:
    image: postgres:16-alpine
    container_name: app-postgres
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret123
      POSTGRES_DB: appdb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U admin"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Service Redis
  cache:
    image: redis:7-alpine
    container_name: app-redis
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 5

  # Service Backend Node.js
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    container_name: app-backend
    environment:
      DATABASE_URL: postgresql://admin:secret123@db:5432/appdb
      REDIS_URL: redis://cache:6379
      NODE_ENV: production
    ports:
      - "3000:3000"
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_healthy
    networks:
      - app-network
    volumes:
      - ./backend:/app
      - /app/node_modules
    restart: unless-stopped

  # Service Nginx (reverse proxy)
  nginx:
    image: nginx:alpine
    container_name: app-nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - backend
    networks:
      - app-network
    restart: unless-stopped

# Réseaux
networks:
  app-network:
    driver: bridge

# Volumes persistants
volumes:
  postgres-data:

Commandes Docker Compose

# Démarrer tous les services
docker compose up -d

# Voir les logs
docker compose logs -f

# Arrêter tous les services
docker compose down

# Redémarrer un service spécifique
docker compose restart backend

# Reconstruire les images
docker compose build

# Démarrer + rebuild si changements
docker compose up -d --build

Configuration Nginx (reverse proxy)

# nginx/nginx.conf
events {
    worker_connections 1024;
}

http {
    upstream backend {
        server backend:3000;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

Best Practices Docker 2025

1. Utiliser des images Alpine (légères)

# ❌ Lourd (1 GB+)
FROM node:20

# ✅ Léger (100 MB)
FROM node:20-alpine

2. Multi-stage builds (optimiser la taille)

# Dockerfile multi-stage
# 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
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package.json ./
EXPOSE 3000
CMD ["node", "dist/server.js"]

Résultat : image finale 3-5x plus petite ! ✨

3. Ne JAMAIS exécuter en root

# ❌ Dangereux (root par défaut)
FROM node:20-alpine
WORKDIR /app
COPY . .
CMD ["node", "server.js"]

# ✅ Sécurisé (user non-root)
FROM node:20-alpine
WORKDIR /app
COPY . .

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

CMD ["node", "server.js"]

4. Utiliser .dockerignore

# .dockerignore
node_modules
npm-debug.log
.git
.env
.DS_Store
*.md
coverage
.vscode

5. Healthchecks (Docker Compose)

services:
  backend:
    image: mon-app:latest
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

6. Variables d'environnement avec .env

# .env (NE PAS COMMITER)
POSTGRES_PASSWORD=super_secret_123
JWT_SECRET=my_jwt_secret
API_KEY=abcd1234

# docker-compose.yml
services:
  db:
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}

  backend:
    env_file:
      - .env

7. Scanner les vulnérabilités

# Docker Scout (intégré à Docker Desktop 2025)
docker scout cves mon-app:v1

# Ou Trivy
trivy image mon-app:v1

8. Limiter les ressources

services:
  backend:
    image: mon-app:latest
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

Nouveautés Docker 2025

1. Docker AI Agent (Gordon) - BETA

Intégré à Docker Desktop 4.38+, l'AI Agent te guide en temps réel :

• ✅ Suggestions pour optimiser tes Dockerfiles
• ✅ Réduction automatique de taille d'images
• ✅ Debug intelligent quand un conteneur crash
• ✅ Réponses contextuelles sur tes images/conteneurs

Pose une question directement dans Docker Desktop CLI :

docker desktop ask "How can I reduce the size of my image?"

2. Docker Hardened Images (DHI)

Images ultra-sécurisées sans vulnérabilités connues :

• ✅ 0 CVE (Common Vulnerabilities and Exposures)
• ✅ Mises à jour automatiques
• ✅ Non-root par défaut
• ✅ Gratuites pour tous

Disponibles sur Docker Hub avec le tag :hardened.

3. Docker Model Runner (AI local)

Lance des modèles IA localement via Docker :

# Exemple : LLaMA 3 local
docker run -d -p 8000:8000 docker/model-runner llama3

4. docker compose watch (live reload)

# docker-compose.yml
services:
  backend:
    build: ./backend
    develop:
      watch:
        - path: ./backend
          action: sync
          target: /app
          ignore:
            - node_modules/

# Lance avec watch
docker compose watch

Chaque modification de fichier recharge automatiquement le conteneur ! 🔥

Workflow complet : dev → prod

Développement local

# docker-compose.dev.yml
services:
  backend:
    build:
      context: ./backend
      target: development
    volumes:
      - ./backend:/app
      - /app/node_modules
    environment:
      NODE_ENV: development
    command: npm run dev # nodemon avec hot-reload

docker compose -f docker-compose.dev.yml up

Tests

# docker-compose.test.yml
services:
  test:
    build:
      context: ./backend
      target: test
    environment:
      NODE_ENV: test
    command: npm test

docker compose -f docker-compose.test.yml run test

Production

# docker-compose.prod.yml
services:
  backend:
    build:
      context: ./backend
      target: production
    environment:
      NODE_ENV: production
    restart: always
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '1'
          memory: 1G

docker compose -f docker-compose.prod.yml up -d

Déploiement en production

Option 1 : Docker Swarm (simple)

# Initialiser Swarm
docker swarm init

# Déployer une stack
docker stack deploy -c docker-compose.prod.yml mon-app

# Scaler un service
docker service scale mon-app_backend=5

Option 2 : Kubernetes (avancé)

Pour projets complexes nécessitant auto-scaling, rolling updates, gestion avancée.

Option 3 : Services cloud managés

• 🔵 AWS ECS (Elastic Container Service)
• 🔵 Azure Container Instances
• 🟠 Google Cloud Run
• 🟣 DigitalOcean App Platform

Troubleshooting : erreurs courantes

Erreur : "Cannot connect to Docker daemon"

Solution :

# Linux : Démarre Docker
sudo systemctl start docker

# Ou ajoute ton user au groupe docker
sudo usermod -aG docker $USER
newgrp docker

# Windows/Mac : Lance Docker Desktop

Erreur : "Port already in use"

Solution : Change le port dans docker-compose.yml

services:
  backend:
    ports:
      - "3001:3000"  # Utilise 3001 au lieu de 3000

Conteneur crash immédiatement

Solution : Regarde les logs

docker logs nom-conteneur

# Ou en temps réel
docker logs -f nom-conteneur

Image trop grande (plusieurs GB)

Solution :

• ✅ Utilise Alpine : FROM node:20-alpine
• ✅ Multi-stage builds
• ✅ .dockerignore configuré
• ✅ npm ci --only=production au lieu de npm install

Ressources pour aller plus loin

• 📚 Documentation officielle Docker
• 📹 YouTube Docker
• 🐙 Docker Hub (images)
• 💬 Docker Forums
• 📖 Awesome Compose (exemples)
• 🎓 Play with Docker (environnement test gratuit)

Checklist : tu es prêt si tu sais

• ✅ Installer Docker sur ton OS
• ✅ Lancer un conteneur depuis Docker Hub
• ✅ Créer un Dockerfile pour ton app
• ✅ Builder une image avec docker build
• ✅ Utiliser Docker Compose pour orchestrer plusieurs services
• ✅ Persister les données avec volumes
• ✅ Configurer des healthchecks
• ✅ Appliquer les best practices 2025 (Alpine, multi-stage, non-root)
• ✅ Débugger un conteneur qui crash
• ✅ Scanner les vulnérabilités avec Docker Scout/Trivy

Conclusion

Docker n'est plus optionnel en 2025. Avec 92% d'adoption dans l'industrie, c'est devenu un standard incontournable du développement moderne.

Ce que tu as appris dans ce tutoriel :

• ✅ Les concepts fondamentaux (images, conteneurs, Dockerfile)
• ✅ Installation sur Windows/Mac/Linux
• ✅ Création d'images custom
• ✅ Orchestration multi-conteneurs avec Docker Compose
• ✅ Best practices 2025 (sécurité, performance, production)
• ✅ Nouveautés 2025 (AI Agent, Hardened Images, Model Runner)

Maintenant, pratique ! Dockerise ton prochain projet, expérimente avec Docker Compose, et tu verras à quel point ça simplifie ton workflow.

Le secret pour maîtriser Docker : dockeriser TOUS tes projets. Même un simple script Python. Au bout de 5-10 projets, Docker deviendra une seconde nature.

À toi de jouer ! 🐳🚀