Docker : conteneurisation pour développeurs

Qu'est-ce que Docker ?

Docker est une plateforme de conteneurisation qui permet d'empaqueter une application et toutes ses dépendances dans un conteneur léger et portable. Les conteneurs garantissent que l'application fonctionne de manière identique sur n'importe quel environnement.

Créé en 2013, Docker a révolutionné le déploiement d'applications en simplifiant la gestion des dépendances et en assurant la cohérence entre les environnements de développement, de test et de production.

🐳 À retenir : Docker n'est pas une machine virtuelle. Les conteneurs partagent le noyau du système hôte, ce qui les rend beaucoup plus légers et rapides.

Installation de Docker

Sur Linux (Ubuntu/Debian)

# Mise à jour des packages
sudo apt-get update

# Installation des dépendances
sudo apt-get install ca-certificates curl gnupg

# Ajout de la clé GPG officielle
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

# 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

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

# Vérification
docker --version
sudo docker run hello-world

Sur Windows et macOS

Téléchargez Docker Desktop depuis docker.com. Docker Desktop inclut Docker Engine, Docker CLI, Docker Compose et Kubernetes.

💡 Astuce : Sur Linux, ajoutez votre utilisateur au groupe docker pour éviter d'utiliser sudo : sudo usermod -aG docker $USER (reconnectez-vous ensuite).

Concepts clés

Image Docker

Une image est un modèle en lecture seule contenant le système de fichiers et les dépendances nécessaires pour exécuter une application. Les images sont construites à partir d'un Dockerfile.

Conteneur Docker

Un conteneur est une instance exécutable d'une image. C'est un environnement isolé qui contient tout ce dont l'application a besoin pour fonctionner.

Registry

Un registry est un dépôt d'images Docker. Le plus connu est Docker Hub, mais vous pouvez aussi héberger votre propre registry privé.

Volume

Un volume permet de persister les données en dehors du cycle de vie des conteneurs. Les données stockées dans un volume survivent à la suppression du conteneur.

Network

Les networks Docker permettent aux conteneurs de communiquer entre eux de manière isolée et sécurisée.

🔑 Relation clé : Une image est comme une classe en programmation, un conteneur est une instance de cette classe.

Commandes essentielles

Gestion des images

# Télécharger une image depuis Docker Hub
docker pull ubuntu:22.04
docker pull nginx:latest

# Lister les images locales
docker images

# Supprimer une image
docker rmi nginx:latest

# Construire une image depuis un Dockerfile
docker build -t mon-app:1.0 .

# Voir l'historique d'une image
docker history mon-app:1.0

Gestion des conteneurs

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

# Lister les conteneurs actifs
docker ps

# Lister tous les conteneurs (actifs et arrêtés)
docker ps -a

# Stopper un conteneur
docker stop mon-nginx

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

# Redémarrer un conteneur
docker restart mon-nginx

# Supprimer un conteneur
docker rm mon-nginx

# Supprimer tous les conteneurs arrêtés
docker container prune

Interaction avec les conteneurs

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

# Exécuter une commande dans un conteneur actif
docker exec -it mon-nginx bash

# Copier des fichiers vers/depuis un conteneur
docker cp fichier.txt mon-nginx:/app/
docker cp mon-nginx:/app/fichier.txt ./

# Voir les stats en temps réel
docker stats mon-nginx

Nettoyage

# Supprimer toutes les images non utilisées
docker image prune -a

# Supprimer tous les volumes non utilisés
docker volume prune

# Nettoyage complet (images, conteneurs, volumes, networks)
docker system prune -a --volumes

Créer un Dockerfile

Un Dockerfile est un fichier texte contenant les instructions pour construire une image Docker.

Exemple : Application Node.js

# Utiliser une image de base officielle
FROM node:18-alpine

# Définir le répertoire de travail
WORKDIR /app

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

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

# Copier le code source
COPY . .

# Exposer le port de l'application
EXPOSE 3000

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

Construire et lancer l'image

# Construire l'image
docker build -t mon-app-node:1.0 .

# Lancer le conteneur
docker run -d -p 3000:3000 --name app mon-app-node:1.0

# Tester
curl http://localhost:3000

Instructions Dockerfile courantes

Instruction	Description
`FROM`	Image de base à utiliser
`WORKDIR`	Répertoire de travail dans le conteneur
`COPY`	Copier des fichiers depuis l'hôte vers le conteneur
`ADD`	Comme COPY mais supporte URLs et extraction d'archives
`RUN`	Exécuter une commande pendant le build
`CMD`	Commande par défaut au démarrage du conteneur
`ENTRYPOINT`	Point d'entrée principal (non écrasable facilement)
`ENV`	Définir des variables d'environnement
`EXPOSE`	Documenter les ports utilisés (informatif)
`VOLUME`	Créer un point de montage pour volume

Docker Compose

Docker Compose permet de définir et gérer des applications multi-conteneurs avec un fichier YAML.

Exemple : Application web + base de données

# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=db
      - DB_USER=admin
      - DB_PASSWORD=secret123
    depends_on:
      - db
    volumes:
      - ./logs:/app/logs
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=admin
      - POSTGRES_PASSWORD=secret123
      - POSTGRES_DB=myapp
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped

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

volumes:
  pgdata:

Commandes Docker Compose

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

# Voir les logs
docker-compose logs -f

# Lister les services
docker-compose ps

# Arrêter tous les services
docker-compose stop

# Arrêter et supprimer les conteneurs
docker-compose down

# Reconstruire les images et redémarrer
docker-compose up -d --build

# Exécuter une commande dans un service
docker-compose exec web bash

🚀 Best practice : Utilisez .env pour stocker les secrets et ne les commitez jamais dans Git. Docker Compose charge automatiquement les variables depuis ce fichier.

Volumes et Networks

Volumes Docker

Les volumes permettent de persister les données en dehors du conteneur.

# Créer un volume
docker volume create mon-volume

# Lister les volumes
docker volume ls

# Inspecter un volume
docker volume inspect mon-volume

# Utiliser un volume
docker run -d -v mon-volume:/data nginx

# Monter un dossier local (bind mount)
docker run -d -v /home/user/data:/data nginx

# Supprimer un volume
docker volume rm mon-volume

Networks Docker

Les networks permettent aux conteneurs de communiquer entre eux.

# Créer un network
docker network create mon-network

# Lister les networks
docker network ls

# Inspecter un network
docker network inspect mon-network

# Lancer des conteneurs sur le même network
docker run -d --name app1 --network mon-network nginx
docker run -d --name app2 --network mon-network nginx

# app1 peut communiquer avec app2 via son nom :
# curl http://app2

# Supprimer un network
docker network rm mon-network

Types de networks

bridge (défaut) : Network isolé pour la communication entre conteneurs sur le même hôte
host : Le conteneur utilise directement le réseau de l'hôte
none : Aucun réseau (conteneur isolé)
overlay : Pour communication multi-hôtes (Docker Swarm)

Bonnes pratiques

Images légères : Préférez les images Alpine (ex: node:18-alpine) pour réduire la taille
Multi-stage builds : Créez des images de production optimisées
.dockerignore : Excluez les fichiers inutiles (node_modules, .git, tests)
Un processus par conteneur : Principe de séparation des responsabilités
Utilisateur non-root : N'exécutez jamais vos apps en tant que root
Variables d'environnement : Externalisez la config avec ENV ou .env
Health checks : Utilisez HEALTHCHECK pour la supervision
Tagging sémantique : Versionnez vos images (1.0.0, 1.0.1, latest)
Scan de sécurité : Utilisez docker scan pour détecter les vulnérabilités

Exemple : Multi-stage build

# Stage 1 : Build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2 : Production
FROM node:18-alpine
RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
WORKDIR /app
COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
USER nodejs
EXPOSE 3000
CMD ["node", "dist/server.js"]

Fichier .dockerignore

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
.vscode
.idea
dist
coverage
*.test.js

🔒 Sécurité : Ne stockez JAMAIS de secrets dans vos images Docker. Utilisez des variables d'environnement, Docker secrets ou un gestionnaire de secrets externe.

Conclusion

Docker est devenu un standard dans le monde du développement et du déploiement d'applications. Sa capacité à créer des environnements reproductibles, légers et portables en fait un outil indispensable pour les développeurs modernes.

Passez à l'étape suivante avec Kubernetes pour orchestrer vos conteneurs Docker à grande échelle en production.

📚 Ressources officielles :