🐳 Docker – Installation & Déploiement (Linux & Cloud)

Qu'est-ce que Docker ?

Docker est une plateforme open-source qui permet d'automatiser le déploiement, la mise à l'échelle et la gestion d'applications en utilisant des **conteneurs**.

Un conteneur "emballe" le code d'une application et toutes ses dépendances (libs, binaires, etc.) dans une seule unité exécutable.

Avantages

• Isolation : Les conteneurs sont isolés les uns des autres et du système hôte.
• Portabilité : "Ça marche sur ma machine" devient "Ça marche partout" (dev, test, prod, cloud).
• Légèreté : Partage le noyau (Kernel) de l'OS hôte. Démarre en secondes.
• Reproductibilité : Les builds sont déterministes grâce au Dockerfile.

Conteneur vs. Machine Virtuelle (VM)

Une VM virtualise le matériel (CPU, RAM), un conteneur virtualise l'OS.

VOTRE SERVEUR (OS HÔTE + Matériel)
    │
    ├── 🐳 DOCKER (Daemon)
    │   │  (Partage le Kernel de l'OS Hôte)
    │   ├─ Conteneur A (App A + Libs)
    │   ├─ Conteneur B (App B + Libs)
    │
    └── 🔄 HYPERVISEUR (ex: VMware, VirtualBox)
        │
        ├─ VM 1 (OS Invité 1 + App C + Libs)
        └─ VM 2 (OS Invité 2 + App D + Libs)

Docker est beaucoup plus léger et rapide qu'une VM.

Les 3 composants clés

• Docker Daemon (dockerd) : Le service (processus) qui tourne en arrière-plan. C'est lui qui écoute les commandes de l'API et gère les objets Docker (build, run, ...).
• Client Docker (docker) : L'outil en ligne de commande (CLI) que vous utilisez. Il parle au Daemon.
• Registry (ex: Docker Hub) : Un "stockage" d'images. C'est là que vous pull (téléchargez) et push (envoyez) vos images.

Les 3 objets clés

• Image : Un "template" en lecture seule, comme une "recette" ou un "snapshot" (ex: ubuntu:22.04, python:3.11-slim).
• Conteneur : Une instance exécutable d'une image. C'est l'image qui "prend vie".
• Dockerfile : Un fichier texte qui décrit les étapes pour construire une Image.

Schéma de flux

Vous (Terminal)
    │
    │  [1] docker run nginx
    │
    ▼
    Client Docker (CLI)
    │
    │  (API REST)
    │
    ▼
    Docker Daemon (dockerd)
    │
    │  [2] Image "nginx" locale ?
    │       Non.
    │
    │  [3] Pull de l'image
    │
    ◄───── Registry (Docker Hub)
    │
    │  [4] Création du conteneur
    │
    ▼
    Conteneur "nginx" (actif)

Télécharger (pull)

Télécharge une image depuis un registry (Docker Hub par défaut).

# Télécharge la dernière version (tag "latest")
docker pull nginx

# Télécharge une version spécifique
docker pull python:3.11-slim

Lister les images

docker images
# ou
docker image ls

REPOSITORY   TAG         IMAGE ID       CREATED       SIZE
python       3.11-slim   a1b2c3d4e5f6   2 weeks ago   120MB
nginx        latest      b7c8d9e0f1a2   3 weeks ago   187MB

Supprimer une image (rmi)

Supprime une image localement (par son nom ou ID).

docker rmi nginx
# ou
docker rmi b7c8d9e0f1a2

Note : Vous ne pouvez pas supprimer une image si un conteneur (même arrêté) l'utilise. Il faut d'abord supprimer le conteneur.

Chercher une image

# Cherche sur Docker Hub
docker search postgres

Lancer un conteneur (run)

docker run crée et démarre un conteneur à partir d'une image.

# Lance nginx en arrière-plan (-d) et nomme (-name) le conteneur
docker run -d --name mon-serveur-web nginx

Lister les conteneurs

# Lister les conteneurs ACTIFS
docker ps

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

Voir les logs

# Afficher les logs (stdout/stderr)
docker logs mon-serveur-web

# Suivre les logs en direct (-f = follow)
docker logs -f mon-serveur-web

Arrêter / Démarrer

Pour un conteneur existant (créé avec run).

docker stop mon-serveur-web
docker start mon-serveur-web
docker restart mon-serveur-web

Supprimer un conteneur (rm)

Un conteneur doit être arrêté avant d'être supprimé.

docker stop mon-serveur-web
docker rm mon-serveur-web

# Forcer la suppression (même s'il est actif)
docker rm -f mon-serveur-web

Run & auto-suppression

--rm supprime automatiquement le conteneur lorsqu'il s'arrête. Très utile pour les tests.

docker run --rm hello-world

docker exec

Permet de lancer une commande à l'intérieur d'un conteneur déjà en cours d'exécution. C'est l'outil principal pour le débogage.

Ouvrir un shell interactif

L'utilisation la plus courante est d'ouvrir un shell (comme bash ou sh) dans le conteneur.

# docker exec [options] [nom_conteneur] [commande]
docker exec -it mon-serveur-web /bin/bash

• -i (interactif) : Garde STDIN ouvert.
• -t (TTY) : Alloue un pseudo-terminal (ce qui donne un "prompt").

Si /bin/bash n'existe pas (images minimales type Alpine), essayez /bin/sh.

Exécuter une commande simple

On peut aussi lancer une commande non-interactive.

# Lister les fichiers dans /app d'un conteneur "mon-app"
docker exec mon-app ls /app

# Voir les variables d'environnement
docker exec mon-app env

run vs exec

# 'run' CRÉE un nouveau conteneur
# Lance un shell DANS un NOUVEAU conteneur ubuntu
docker run -it --rm ubuntu /bin/bash

# 'exec' agit sur un conteneur EXISTANT
# Lance un shell DANS le conteneur "mon-serveur-web"
docker exec -it mon-serveur-web /bin/bash

Exemple de Dockerfile (Python)

Un fichier nommé Dockerfile (sans extension) à la racine du projet.

# 1. Image de base
FROM python:3.11-slim

# 2. Répertoire de travail dans le conteneur
WORKDIR /app

# 3. Copier les dépendances
COPY requirements.txt .

# 4. Installer les dépendances
RUN pip install --no-cache-dir -r requirements.txt

# 5. Copier le reste de l'application
COPY . .

# 6. Commande à exécuter au démarrage
CMD ["python", "app.py"]

Instructions principales

• FROM : Toujours la première ligne. Définit l'image de base (ex: node:18, ubuntu:22.04).
• WORKDIR : Change le répertoire courant pour les commandes suivantes (RUN, COPY, CMD).
• COPY : Copie des fichiers/dossiers de l'hôte (PC) vers le conteneur. (COPY [source] [destination])
• RUN : Exécute une commande pendant le build de l'image (ex: apt-get install, pip install).
• CMD : Définit la commande par défaut qui sera exécutée au lancement (run) du conteneur. (Il ne peut y en avoir qu'un seul).
• ENTRYPOINT : Similaire à CMD, mais plus difficile à surcharger.
• EXPOSE : Indique (documente) sur quel port l'application écoute. (Nécessite -p au run).

Commande docker build

Cette commande lit le Dockerfile et construit l'image étape par étape.

# Syntaxe : docker build -t [NOM_IMAGE:TAG] [CONTEXTE]
docker build -t mon-app:1.0 .

• -t mon-app:1.0 : (Tag) Donne un nom (mon-app) et un tag (1.0) à l'image. Si :1.0 est omis, :latest est utilisé.
• . : (Contexte) Le point final est crucial. Il indique à Docker "le répertoire courant". C'est le contexte de build, d'où les fichiers seront copiés (ex: COPY . .).

Build multi-stage

Permet de garder une image finale légère, en séparant la phase de build (avec outils, SDK) de la phase d'exécution (runtime).

# Etape 1: Build (ex: Node.js)
FROM node:18 AS builder
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
RUN npm run build

# Etape 2: Prod (ex: Nginx)
FROM nginx:alpine
# Copie seulement les fichiers buildés de l'étape 1
COPY --from=builder /app/build /usr/share/nginx/html

.dockerignore

Similaire au .gitignore, ce fichier (.dockerignore) exclut des fichiers/dossiers du contexte de build.
Cela accélère le build et évite d'inclure des secrets ou des modules inutiles (ex: node_modules, .git, .env).

# .dockerignore
.git
.vscode
node_modules
*.log
.env

Cache de build

Docker met en cache chaque étape (layer). Si vous ne modifiez pas un fichier, Docker réutilise le cache, rendant les builds suivants quasi-instantanés.

C'est pourquoi on COPY requirements.txt et RUN pip install AVANT COPY . . (cf. 3.1).

Le problème

Les conteneurs sont "stateless" (sans état). Quand vous docker rm un conteneur (ex: base de données), toutes les données écrites à l'intérieur sont perdues.

Bind Mounts (Liaison)

Monte un répertoire de votre machine Hôte (PC) dans le conteneur. Pratique pour le développement.

# -v [CHEMIN_HOTE]:[CHEMIN_CONTENEUR]
docker run -d -v /home/user/projets/mon-site:/usr/share/nginx/html nginx

Inconvénient : lié au chemin absolu de l'hôte, moins portable.

Volumes nommés (La bonne pratique)

Docker gère lui-même le volume. C'est la méthode préférée pour la persistance (ex: BDD).

# Crée un volume (géré par Docker)
docker volume create postgres-data

# Lance le conteneur en attachant le volume
docker run -d --name db \
  -v postgres-data:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  postgres:15

Même si vous faites docker rm db, le volume "postgres-data" et son contenu persistent. Vous pouvez le ré-attacher à un nouveau conteneur.

Gérer les volumes

# Lister les volumes
docker volume ls

# Inspecter un volume (voir où il est sur l'hôte)
docker volume inspect postgres-data

# Supprimer un volume (ATTENTION : données perdues)
docker volume rm postgres-data

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

Volume anonyme

Si vous omettez la source (juste -v /data), Docker crée un volume anonyme (avec un long ID). Difficile à gérer, à éviter.

Exposition de ports (-p)

Par défaut, les conteneurs sont isolés. Pour accéder à un service (ex: serveur web) depuis votre machine hôte, vous devez "mapper" un port.

# -p [PORT_HOTE]:[PORT_CONTENEUR]

# Accède à Nginx sur http://localhost:8080
docker run -d -p 8080:80 nginx

Ceci lie le port 8080 de l'hôte (votre PC) au port 80 du conteneur (où Nginx écoute).

Réseau "bridge" (par défaut)

Docker crée un réseau virtuel (bridge) pour vos conteneurs. Ils peuvent communiquer entre eux en utilisant leur nom, s'ils sont sur le même réseau.

# 1. Créer un réseau
docker network create mon-reseau

# 2. Lancer la BDD sur ce réseau
docker run -d --name db --network mon-reseau postgres

# 3. Lancer l'app sur le même réseau
# L'app peut joindre la BDD via "http://db:5432"
docker run -d --name app --network mon-reseau mon-app-image

Réseau "host"

Le conteneur partage l'interface réseau de l'hôte. Il n'y a pas d'isolation réseau. Si le conteneur écoute sur le port 80, il est accessible sur le port 80 de l'hôte.

docker run -d --network host mon-app-image

Plus performant, mais moins sécurisé et risque de conflits de ports.

Gérer les réseaux

# Lister les réseaux
docker network ls

# Inspecter un réseau (voir les conteneurs dessus)
docker network inspect mon-reseau

# Supprimer un réseau
docker network rm mon-reseau

1. Se connecter (login)

Se connecter à un registry (Docker Hub par défaut).

# Entrez votre identifiant Docker Hub et mot de passe (ou Token)
docker login

Pour d'autres registries (AWS ECR, GCP GCR) :

docker login [URL_REGISTRY]

2. Tagger l'image (tag)

Pour "pusher" une image, elle doit être taggée au format [USERNAME]/[NOM_IMAGE]:[TAG].

# Image locale (cf 3.2)
docker build -t mon-app:1.0 .

# Créer un alias (tag) pour Docker Hub
# Syntaxe: docker tag [IMAGE_LOCALE] [IMAGE_REGISTRY]
docker tag mon-app:1.0 ideolab/mon-app:1.0

3. Envoyer l'image (push)

Envoie l'image taggée vers le registry.

docker push ideolab/mon-app:1.0

# (Enverra aussi le tag "latest" si vous le pushez)
docker tag mon-app:1.0 ideolab/mon-app:latest
docker push ideolab/mon-app:latest

Pull d'une image privée

Une fois connectée (docker login), vous pouvez "pull" des images privées auxquelles vous avez accès.

docker pull ideolab/mon-app-privee:1.2

Qu'est-ce que Docker Compose ?

Docker Compose est un outil pour définir et exécuter des applications Docker multi-conteneurs.
Au lieu de taper de longues commandes docker run avec --network, -v, -p, -e... on décrit toute l'application dans un seul fichier YAML.

Docker Compose gère pour vous :

• La création d'un réseau commun.
• Le démarrage/arrêt des conteneurs dans le bon ordre (depends_on).
• La gestion des volumes et des ports.

Depuis Docker v2, docker compose (avec un espace) est intégré à la CLI Docker.

Exemple : docker-compose.yml

Un site WordPress simple (Web + Base de données).

version: "3.8"

services:
  # Service 1: La base de données
  db:
    image: mysql:8.0
    container_name: wordpress_db
    volumes:
      - db-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root_secret
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wp_user
      MYSQL_PASSWORD: wp_secret
    restart: always

  # Service 2: Le site web
  wordpress:
    image: wordpress:latest
    container_name: wordpress_web
    ports:
      - "8080:80" # Hôte:Conteneur
    environment:
      WORDPRESS_DB_HOST: db # Nom du service DB
      WORDPRESS_DB_USER: wp_user
      WORDPRESS_DB_PASSWORD: wp_secret
      WORDPRESS_DB_NAME: wordpress
    depends_on:
      - db # Attend que le service "db" soit lancé
    restart: always

# Gestion centralisée des volumes
volumes:
  db-data:

Démarrer l'application (up)

Crée et démarre tous les services définis dans docker-compose.yml.

# Démarre en arrière-plan (-d = detached)
docker compose up -d

# Démarre en avant-plan (affiche les logs)
docker compose up

Si les images n'existent pas, up les "pull" automatiquement. Si le docker-compose.yml a changé, up recrée les conteneurs nécessaires.

Arrêter et supprimer (down)

Arrête et supprime les conteneurs, le réseau, mais préserve les volumes.

docker compose down

# Supprime aussi les volumes
docker compose down -v

Autres commandes utiles

# Lister les conteneurs de l'application
docker compose ps

# Voir les logs de tous les services
docker compose logs

# Suivre les logs en direct
docker compose logs -f

# Arrêter les services (sans les supprimer)
docker compose stop

# Démarrer les services (préalablement stoppés)
docker compose start

# Forcer le rebuild des images avant de démarrer
docker compose up -d --build

# Exécuter une commande dans un service (ex: shell)
docker compose exec wordpress /bin/bash

Nettoyage global

Docker peut accumuler beaucoup d'objets (conteneurs arrêtés, images "dangling", cache de build) qui prennent de la place disque.

# Commande magique pour nettoyer
docker system prune

Ceci supprime :

• Tous les conteneurs arrêtés.
• Tous les réseaux non utilisés.
• Toutes les images "dangling" (sans tag, souvent des étapes de build intermédiaires).
• Tout le cache de build.

# Version agressive (supprime aussi les images non utilisées)
docker system prune -a

Nettoyage par objet

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

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

# Supprimer tous les réseaux non utilisés
docker network prune

# Supprimer les images "dangling"
docker image prune

Build & Images

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

# Lister les images
docker images

# Télécharger une image
docker pull ubuntu:22.04

# Supprimer une image
docker rmi ubuntu:22.04

# Tagger une image (pour push)
docker tag mon-app:1.0 user/mon-app:1.0

# Envoyer vers registry
docker push user/mon-app:1.0

# Se connecter
docker login

Conteneurs & Exécution

# Lancer (détaché, port, nom)
docker run -d -p 8080:80 --name web nginx

# Lister les conteneurs actifs
docker ps

# Lister tous les conteneurs
docker ps -a

# Arrêter un conteneur
docker stop web

# Démarrer un conteneur
docker start web

# Supprimer un conteneur (doit être stoppé)
docker rm web

# Supprimer en forçant
docker rm -f web

# Voir les logs (et suivre)
docker logs -f web

# Exécuter un shell dans un conteneur
docker exec -it web /bin/bash

# Nettoyage
docker system prune -a