Je me souviens encore de la première fois où un étudiant m’a demandé : « Madame, pourquoi mon projet marche sur mon PC mais pas sur celui du voisin ? ». Cette question, je l’entends chaque année en BTS SIO. Et chaque année, la réponse tient en un mot : Docker. Ce docker tuto va vous accompagner pas à pas, de l’installation à la maîtrise des conteneurs, avec des exemples concrets que j’utilise en cours et en production.

Que vous soyez étudiant, développeur junior ou simplement curieux, ce guide vous donnera les bases solides pour intégrer Docker dans votre workflow quotidien. Pas de jargon inutile, pas de théorie abstraite : on passe à la pratique.

Qu’est-ce que Docker et pourquoi l’utiliser

Docker est une plateforme de conteneurisation open source qui permet d’empaqueter une application avec toutes ses dépendances dans un conteneur léger et portable. Contrairement à une machine virtuelle qui embarque un système d’exploitation complet, un conteneur Docker partage le noyau de l’hôte et ne pèse que quelques mégaoctets.

Pour bien comprendre, imaginez un conteneur maritime. Peu importe ce qu’il contient, il a toujours la même forme et se transporte de la même façon. Docker fonctionne exactement sur ce principe : votre application, qu’elle soit écrite en Python, Node.js ou PHP, tourne dans un environnement standardisé qui se comporte de manière identique partout.

Les concepts fondamentaux

Avant de plonger dans la pratique, voici les termes que vous rencontrerez constamment :

• Image : un modèle en lecture seule qui contient le code, les bibliothèques et les dépendances de votre application. C’est la recette de cuisine.
• Conteneur : une instance en cours d’exécution d’une image. C’est le plat préparé à partir de la recette.
• Dockerfile : un fichier texte qui décrit les étapes pour construire une image. C’est la liste des ingrédients et des instructions.
• Docker Hub : le registre public où sont stockées des milliers d’images prêtes à l’emploi (comme le registre officiel Docker Hub).
• Volume : un mécanisme de persistance des données en dehors du cycle de vie du conteneur.

Docker expliqué pour les nuls

Si vous débutez complètement, retenez cette analogie. Votre ordinateur est un immeuble. Chaque conteneur Docker est un appartement indépendant : il a sa propre cuisine (runtime), ses propres meubles (dépendances) et son propre locataire (application). Mais tous partagent les fondations et la plomberie (le noyau Linux). C’est plus léger qu’un immeuble séparé (machine virtuelle), mais chaque appartement reste totalement isolé des autres.

En pratique, Docker résout trois problèmes majeurs que je constate quotidiennement en formation et en entreprise : les conflits de versions entre développeurs, les différences entre environnement de développement et production, et la complexité du déploiement d’applications multi-services.

Installer Docker sur Windows, macOS et Linux

L’installation de Docker est devenue très simple grâce à Docker Desktop, l’application graphique officielle disponible sur les trois systèmes d’exploitation principaux. Voici la marche à suivre pour chaque plateforme.

Installation sur Windows

Pour installer Docker sur Windows, vous avez besoin de Windows 10/11 version 1903 ou supérieure avec WSL 2 activé. Voici les étapes :

1. Activez WSL 2 en ouvrant PowerShell en administrateur et en tapant wsl --install
2. Redémarrez votre machine
3. Téléchargez Docker Desktop depuis le site officiel
4. Lancez l’installateur et suivez les instructions
5. Vérifiez l’installation avec docker --version

Si vous suivez un tuto Docker Windows spécifiquement, sachez que WSL 2 offre des performances quasi natives par rapport à l’ancien backend Hyper-V. Je recommande toujours cette option à mes étudiants.

Installation sur macOS

Sur macOS, téléchargez Docker Desktop depuis le site officiel. Choisissez la version Apple Silicon (M1/M2/M3) ou Intel selon votre processeur. L’installation se fait par simple glisser-déposer dans le dossier Applications.

Installation sur Linux (Ubuntu/Debian)

Sur Linux, je préfère installer Docker Engine directement via le terminal. C’est plus léger et plus adapté aux serveurs :

# Mise à jour des paquets
sudo apt update && sudo apt upgrade -y

# Installation des dépendances
sudo apt install ca-certificates curl gnupg lsb-release -y

# Ajout de la clé GPG officielle Docker
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Ajout du dépôt Docker
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installation de Docker Engine
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin -y

# Ajout de l'utilisateur au groupe docker
sudo usermod -aG docker $USER

Déconnectez-vous puis reconnectez-vous pour que le groupe prenne effet. Vérifiez ensuite avec :

docker --version
docker run hello-world

Si le message « Hello from Docker! » s’affiche, félicitations, Docker est opérationnel.

Créer et lancer son premier conteneur

Maintenant que Docker est installé, lançons notre premier conteneur. Je vais utiliser l’exemple que je donne systématiquement à mes étudiants de BTS SIO : un serveur web Nginx.

# Télécharger l'image Nginx depuis Docker Hub
docker pull nginx

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

Décortiquons cette commande :

• -d : lance le conteneur en arrière-plan (mode détaché)
• -p 8080:80 : redirige le port 8080 de votre machine vers le port 80 du conteneur
• --name mon-serveur : donne un nom lisible au conteneur
• nginx : l’image à utiliser

Ouvrez votre navigateur à l’adresse http://localhost:8080. Vous devriez voir la page d’accueil Nginx. Votre premier conteneur tourne. En moins de 30 secondes, vous avez déployé un serveur web complet, sans rien installer sur votre machine hôte.

Pour stopper et supprimer ce conteneur :

docker stop mon-serveur
docker rm mon-serveur

Les commandes Docker essentielles à connaître

Voici les commandes que j’utilise quotidiennement et que je considère comme le socle minimum pour tout développeur. Je les ai regroupées par catégorie pour faciliter la mémorisation.

Mon conseil : ne cherchez pas à tout mémoriser d’un coup. Commencez par docker run, docker ps, docker stop et docker logs. Ces quatre commandes couvrent 80 % de vos interactions avec Docker au quotidien. Vous pouvez aussi télécharger un aide-mémoire des commandes Docker au format PDF pour l’avoir sous la main.

Écrire un Dockerfile efficace

Le Dockerfile est le cœur de Docker. C’est lui qui décrit comment construire votre image personnalisée. Prenons un exemple concret avec une application Node.js, un cas que je rencontre très fréquemment en formation développement web.

Un premier Dockerfile simple

# Image de base
FROM node:20-alpine

# Répertoire de travail dans le conteneur
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 source
COPY . .

# Exposer le port de l'application
EXPOSE 3000

# Commande de démarrage
CMD ["node", "server.js"]

Construisez cette image avec :

docker build -t mon-api-node .
docker run -d -p 3000:3000 mon-api-node

Optimiser avec le multi-stage build

En production, je recommande toujours le multi-stage build. Cette technique permet de séparer l’étape de construction de l’étape d’exécution, ce qui réduit considérablement la taille de l’image finale :

# Étape 1 : construction
FROM node:20-alpine 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 --from=builder /app/node_modules ./node_modules
COPY package*.json ./
EXPOSE 3000
CMD ["node", "dist/server.js"]

Avec cette approche, l’image finale ne contient que le strict nécessaire pour exécuter l’application. J’ai vu des images passer de 1,2 Go à 180 Mo grâce au multi-stage build. C’est un gain énorme en temps de déploiement et en espace disque.

Le fichier .dockerignore

Tout comme .gitignore pour Git et le versioning, le fichier .dockerignore empêche Docker de copier des fichiers inutiles dans l’image :

node_modules
.git
.env
*.md
dist
.dockerignore
Dockerfile

Ce fichier est souvent oublié par les débutants, mais il peut diviser par deux le temps de build en évitant de copier le dossier node_modules local.

Docker Compose : orchestrer plusieurs conteneurs

Dans la vraie vie, une application ne tourne jamais seule. Elle a besoin d’une base de données, d’un cache Redis, parfois d’un serveur de mail. Docker Compose permet de définir et de gérer ces services multiples dans un seul fichier YAML.

Exemple concret : application web + base de données

Voici un fichier docker-compose.yml typique que j’utilise pour mes projets pédagogiques :

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:password@db:5432/mydb
      - NODE_ENV=development
    volumes:
      - .:/app
      - /app/node_modules
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  adminer:
    image: adminer
    ports:
      - "8080:8080"
    depends_on:
      - db

volumes:
  pgdata:

Pour lancer l’ensemble de la stack :

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

# Voir les logs de tous les services
docker compose logs -f

# Arrêter tous les services
docker compose down

# Arrêter et supprimer les volumes
docker compose down -v

Notez la gestion des ports dans Docker Compose : chaque service expose ses ports de manière indépendante. L’application communique avec la base de données via le nom du service (db) grâce au réseau interne créé automatiquement par Compose.

La directive volumes: - .:/app monte votre code source local dans le conteneur. Chaque modification de fichier est immédiatement reflétée sans avoir à reconstruire l’image. C’est ce qu’on appelle le hot reload, indispensable en développement.

Bonnes pratiques et erreurs courantes

Après plusieurs années à enseigner Docker et à l’utiliser en production, voici les erreurs que je vois le plus souvent et les bonnes pratiques que je recommande. Ces conseils vous éviteront des heures de débogage et renforceront la sécurité de vos déploiements.

Les erreurs à éviter absolument

• Utiliser l’image latest en production : toujours épingler une version précise (node:20.11-alpine plutôt que node:latest) pour garantir la reproductibilité
• Lancer les processus en root : créez un utilisateur dédié dans votre Dockerfile avec USER node pour limiter la surface d’attaque
• Stocker des secrets dans le Dockerfile : utilisez des variables d’environnement ou Docker Secrets, jamais de mots de passe en dur dans le code
• Ignorer le fichier .dockerignore : sans lui, vous copiez potentiellement des fichiers sensibles (.env, .git) dans l’image
• Ne pas nettoyer le cache : lancez régulièrement docker system prune pour libérer l’espace disque

Les bonnes pratiques à adopter

• Utilisez des images Alpine comme base : elles pèsent 5 Mo contre 100 Mo pour une image Debian classique
• Regroupez les commandes RUN avec && pour réduire le nombre de couches dans l’image
• Placez les instructions qui changent le moins souvent en haut du Dockerfile pour optimiser le cache
• Scannez vos images avec docker scout cves pour détecter les vulnérabilités connues, une pratique essentielle pour un audit de sécurité efficace
• Documentez vos conteneurs avec des labels (LABEL maintainer="[email protected]")

Gérer les données persistantes

Un conteneur est éphémère par nature. Quand vous le supprimez, toutes les données qu’il contient disparaissent. Pour persister les données (base de données, fichiers uploadés, logs), utilisez les volumes Docker :

# Créer un volume nommé
docker volume create mes-donnees

# Monter le volume dans un conteneur
docker run -d -v mes-donnees:/data mon-image

# Lister les volumes
docker volume ls

# Inspecter un volume
docker volume inspect mes-donnees

Les volumes sont stockés en dehors du conteneur et survivent à sa suppression. C’est la méthode recommandée par la documentation officielle de Docker sur les volumes pour toute donnée qui doit persister.

Aller plus loin avec Docker

Une fois les bases maîtrisées, Docker ouvre la porte à un écosystème complet d’outils et de pratiques DevOps. Voici les prochaines étapes que je recommande à mes étudiants et à toute personne qui souhaite approfondir ce docker tuto.

Docker dans un pipeline CI/CD

Docker s’intègre naturellement dans les pipelines d’intégration et de déploiement continus. Que vous utilisiez GitHub Actions, GitLab CI ou Jenkins, le principe reste le même : construire l’image, la tester, puis la déployer. Voici un exemple simplifié avec GitHub Actions :

name: Build and Deploy
on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Docker image
        run: docker build -t mon-app:${{ github.sha }} .
      - name: Run tests
        run: docker run mon-app:${{ github.sha }} npm test
      - name: Push to registry
        run: |
          docker tag mon-app:${{ github.sha }} registry.example.com/mon-app:latest
          docker push registry.example.com/mon-app:latest

Cette automatisation garantit que chaque commit est testé dans un environnement identique à la production, ce qui constitue un atout considérable pour la fiabilité de vos applications. Cela rejoint les compétences enseignées en formation informatique, où l’automatisation occupe une place centrale.

Orchestration avec Kubernetes

Quand votre application grandit et nécessite de la haute disponibilité, de la mise à l’échelle automatique ou du déploiement sans interruption, Kubernetes (souvent abrégé K8s) prend le relais. Kubernetes orchestre des conteneurs Docker à grande échelle, en gérant le load balancing, les redémarrages automatiques et le scaling horizontal. C’est l’étape suivante naturelle pour les développeurs qui maîtrisent Docker.

Sécurité des conteneurs

La sécurité est un aspect critique de la conteneurisation. Selon l’ANSSI (Agence nationale de la sécurité des systèmes d’information), les recommandations principales incluent : limiter les privilèges des conteneurs, scanner régulièrement les images, utiliser des réseaux isolés et maintenir Docker à jour. Intégrer ces pratiques dès le début de votre apprentissage vous évitera bien des problèmes en production, surtout dans un contexte de conformité RGPD.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.