Docker repose sur une architecture client‑serveur. Le client Docker (CLI) communique avec le daemon Docker (dockerd) qui gère les conteneurs, images, volumes et réseaux. Les images sont stockées dans des registres (Docker Hub, registres privés). Le daemon peut être local ou distant. ISOSET forme à la mise en place et à l’administration de cette architecture en environnement de production.

• Docker Client – commandes (docker run, build, pull, push).
• Docker Daemon (dockerd) – crée et gère les objets Docker.
• Registre (Registry) – stockage des images (Docker Hub, AWS ECR, GitLab Registry).
• Conteneur – instance d’une image, isolée avec ses propres processus, réseau et montages.

Une image Docker est un modèle immuable, en lecture seule, qui contient le système de fichiers, l’application et ses dépendances. Les images sont construites à partir d’un Dockerfile, un fichier texte contenant des instructions (FROM, RUN, COPY, CMD). Chaque instruction crée une couche (layer) dans l’image, ce qui permet la mise en cache et la réutilisation.

• FROM – image de base (ex: node:18-alpine, python:3.10-slim).
• RUN – exécute des commandes (apt-get, pip install, npm ci).
• COPY / ADD – copie des fichiers de l’hôte vers l’image.
• CMD / ENTRYPOINT – commande par défaut à l’exécution du conteneur.
• Layer caching – ordonner les instructions pour maximiser la réutilisation du cache.

# Exemple de Dockerfile multi‑stage (Node.js)
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm ci --omit=dev
CMD ["node", "dist/server.js"]

ISOSET aide les entreprises à optimiser leurs Dockerfiles (réduction de taille, sécurité, multi‑stage).

Un conteneur est une instance d’une image, avec une couche supplémentaire en lecture‑écriture (la couche du conteneur). Les conteneurs sont éphémères par défaut : les modifications disparaissent à l’arrêt. Commandes courantes : `docker run`, `docker ps`, `docker stop`, `docker rm`, `docker exec`.

• docker run – crée et démarre un conteneur à partir d’une image.
• docker start / stop – arrêt/redémarrage.
• docker exec – exécute une commande dans un conteneur en cours (ex: bash).
• docker logs – affiche les logs du conteneur.

# Commandes de base
docker run -d --name mon-app -p 3000:3000 mon-image
docker exec -it mon-app bash
docker logs mon-app -f

Les conteneurs sont éphémères : les données écrites dans la couche du conteneur disparaissent à sa suppression. Docker propose les volumes (gérés par Docker) et les bind mounts (lien vers un répertoire de l’hôte) pour persister les données. Les volumes sont recommandés pour la production (gérés, sauvegardables, portables).

• Volume nommé – `docker volume create mon_volume` puis `-v mon_volume:/data`.
• Bind mount – `-v /chemin/hote:/chemin/conteneur` (pratique en développement).
• tmpfs mount – données en mémoire, ne persiste pas.

# Utilisation d’un volume nommé avec PostgreSQL
docker volume create pgdata
docker run -d --name postgres -v pgdata:/var/lib/postgresql/data -e POSTGRES_PASSWORD=secret postgres:15

ISOSET enseigne les bonnes pratiques de gestion des volumes pour les bases de données, les fichiers uploadés et les logs persistants.

Docker crée par défaut trois réseaux : bridge (par défaut), host (partage le réseau de l’hôte), none (aucun réseau). Les conteneurs sur le même réseau bridge peuvent communiquer entre eux par leur nom. On peut créer des réseaux personnalisés pour isoler des groupes de conteneurs.

• bridge (par défaut) – réseau privé interne, accès via NAT vers l’extérieur.
• host – le conteneur utilise directement le réseau de l’hôte (pas d’isolation).
• overlay – pour les clusters multi‑hôtes (Docker Swarm, Kubernetes).
• Réseau personnalisé – `docker network create mon-reseau`, puis `–network mon-reseau`.

# Créer un réseau et y connecter des conteneurs
docker network create frontend
docker run -d --name app --network frontend mon-app
docker run -d --name nginx --network frontend -p 80:80 nginx

ISOSET propose des ateliers de mise en réseau Docker (microservices, API gateway).

Docker Compose permet de définir dans un fichier YAML (`docker-compose.yml`) l’ensemble des services, réseaux et volumes d’une application. Une seule commande (`docker compose up`) lance tous les conteneurs avec la configuration appropriée. Idéal pour les environnements de développement et les petites architectures de production.

• Services – chaque conteneur (web, base de données, cache, etc.).
• Réseaux – les services communiquent par défaut sur un réseau dédié.
• Volumes – persistance des données (bases, fichiers uploadés).
• Variables d’environnement – via fichier `.env` ou directement dans le YAML.

# docker-compose.yml pour une stack web + postgres + redis
version: '3.8'
services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/app
    depends_on:
      - db
      - redis
  db:
    image: postgres:15
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=secret
  redis:
    image: redis:alpine
volumes:
  pgdata:

ISOSET initie les jeunes à Docker Compose à travers des projets (blog, jeu multijoueur).

• Images minimales – utiliser des images officielles `-alpine` ou `-slim`.
• Un seul processus par conteneur – séparer base de données, cache, application.
• Ne pas exécuter en root – créer un utilisateur non privilégié dans le Dockerfile.
• Gérer les secrets avec des secrets Docker ou des variables d’environnement sécurisées.
• Labelliser les images – `LABEL version= »1.0″`, `maintainer`.
• Scanner les vulnérabilités – `docker scan` ou `trivy image`.

• Docker Buildx – constructions multi‑architectures (amd64, arm64).
• Docker Swarm – orchestration native (alternatif à Kubernetes).
• Podman – alternative sans daemon, compatible Docker CLI.
• Containerd – moteur de conteneurs utilisé par Docker et Kubernetes.
• Portainer – interface web de gestion des conteneurs et stacks.

Les témoignages d’anciens élèves d’ISOSET confirment l’efficacité de la formation : *« Grâce à la formation Docker, j’ai compris l’architecture en couches, les volumes et les réseaux. Aujourd’hui, je déploie toutes mes applications avec Docker Compose. »*