Introduction à Docker

Déjà abordé dans le cours et la présentation.

Dans cette page, vous allez pouvoir utiliser Docker en étant guidé pas à pas avec des exercices simples.

Technologie de conteneurisation

• Définition : Les conteneurs isolent une application, ses bibliothèques et ses exécutables.
• Différence avec les machines virtuelles :
  • Une VM utilise un hyperviseur pour simuler un OS complet.
  • Un conteneur partage le noyau du système hôte, ce qui le rend plus léger et rapide.

• Analogie : Comme un conteneur de transport, il isole son contenu sans révéler son environnement externe.

• Fonctionnement :

  • Utilise les cgroups (limitation des ressources) et les namespaces (isolation des processus, réseau, utilisateurs).
  • Un conteneur est un processus isolé avec ses propres ressources.

• Avantages :

  • Légèreté (pas de système d’exploitation complet).
  • Portabilité (fonctionne sur tout système compatible).
  • Efficacité (partage des ressources avec l’hôte).

• Compatibilité :

  • Idéal pour Linux.
  • Sous Windows, nécessite une couche de virtualisation (ex: WSL 2) avec Docker Desktop.

---

Les images de conteneurs

• Définition : Une image est un modèle immuable pour créer des conteneurs (comme une classe en POO).
• Système de couches :
  • Chaque image est construite par couches (ex: OS de base –> bibliothèques –> application).
  • Les couches communes sont partagées entre les images (pour une économie d’espace).
• Exemple : Une image Ubuntu + Python + une application personnalisée.

---

Docker : l’outil phare

• Origine : Projet open source issu de dotCloud (2013).
• Atouts :
  • Simplicité d’utilisation.
  • Docker Hub : Répertoire public d’images (5M+ images, dont des officielles comme MySQL, MongoDB, etc.).
  • Partage facile via des Dockerfiles (fichiers de configuration pour créer des images).
  • Intégration avec les solutions cloud (PaaS).
• Éditions :
  • Communauté (gratuite).
  • Entreprise (fonctionnalités avancées).

---

Architecture de Docker

• Client-serveur :
  • Client : Interface en ligne de commande (docker-cli).
  • Serveur : Démon (docker daemon) qui gère les images et conteneurs via une API REST.
• Registries :
  • Docker Hub : Répertoire public par défaut.
  • Registries privés : Pour les entreprises (ex: Docker Trusted Registry).

---

Fonctionnement sous le capot

• Linux : Utilise directement les fonctionnalités du noyau (cgroups, namespaces).
• Windows : Nécessite une couche de virtualisation (ex: WSL 2).

Documentation & installation

Lien vers la page d’installation de Docker Desktop / WSL 2

Lien vers la documentation de Docker

---

Pratique - Manipuler des conteneurs et des images avec Docker (Windows + WSL 2)

Prérequis

• Docker Desktop installé et lancé (avec WSL 2 activé).
• Terminal : Utilise PowerShell ou WSL 2 (Ubuntu par défaut).

Exemple du Docker Desktop

Dans votre terminal, vous pouvez voir la version de votre Docker :

Démarrer avec Docker

Lancer le premier conteneur

1. Ouvrir un terminal (PowerShell ou WSL 2).
2. Exécuter la commande suivante pour tester l’installation :

docker container run hello-world

Résultat attendu :

Hello from Docker!
This message shows that your installation appears to be working correctly.

Docker télécharge automatiquement l’image hello-world depuis Docker Hub (si elle n’est pas déjà locale). Le conteneur s’exécute, affiche un message, puis s’arrête !

Sur le site DockerHub, l’image HelloWorld

Gérer les images

Lister les images locales

docker image ls

Colonnes importantes :

• REPOSITORY : Nom de l’image.
• TAG : Version de l’image (par défaut : latest).
• IMAGE ID : Identifiant unique.

Télécharger une image (sans lancer de conteneur)

docker image pull ubuntu:latest

Ce que vous devez voir :

Lancer et interagir avec un conteneur

Lancer un conteneur Ubuntu en mode interactif

docker container run -it ubuntu:latest bash

Options :

• -it : Mode interactif (accès au terminal).
• bash : Lance un shell Bash dans le conteneur.

J’ai ajouté un ls pour voir les répertoires de mon container Ubuntu actif.

Lister les conteneurs en cours d’exécution

Attention, il faudra ouvrir un autre terminal pour lister votre container actif, sinon, il n’y aura rien. Ensuite pour quitter votre Ubuntu, vous pourrez faire un exit !

docker container ls

Colonnes importantes :

• CONTAINER ID : Identifiant unique.
• STATUS : État du conteneur (Up = en cours d’exécution).

Quitter un conteneur (pour quitter votre Ubuntu comme je l’ai précisé plus haut):

exit

Dans ce cas, le conteneur s’arrête automatiquement.

Gérer les conteneurs

Lister tous les conteneurs (y compris arrêtés)

docker container ls --all

Sur cette copie d’écran vous voyez que la seconde commande permet d’afficher tous les containers y compris ceux qui ne sont pas actifs mais présents. J’ai encadré les noms (NAME) générés pour chaque image car on peut utiliser les ID ou les NAME.

Démarrer un conteneur arrêté

docker container start <NOM_OU_ID>

Exemple :

docker container start practical_murdock

Piège : il faut remplacer practical_murdock par le NAME donné aléatoirement par Docker !

Arrêter un conteneur

docker container stop <NOM_OU_ID>

Supprimer un conteneur

docker container rm <NOM_OU_ID>

Autre exemple en utilisant le NAMES :

---

Options utiles

Option	Description
-it	Mode interactif (accès au terminal).
-d ou --detach	Lance le conteneur en arrière-plan.
--name <NOM>	Donne un nom personnalisé au conteneur.
--rm	Supprime automatiquement le conteneur après son arrêt.
-e "VAR=valeur"	Définit une variable d’environnement.

Exemple avec options combinées :

docker container run -it --rm --name mon_ubuntu -e "MA_VAR=coucou" ubuntu:latest bash

Inspecter un conteneur ou une image

Afficher les détails d’un conteneur :

docker container inspect <NOM_OU_ID>

Affiche un JSON avec toutes les informations (statut, réseau, etc.).

Afficher les détails d’une image

docker image inspect hello-world

Nettoyage

Supprimer les images

Si vous souhaitez supprimer plusieurs images en même temps, vous pouvez écrire les ID d’image ou les noms d’image séparés par des espaces les uns derrière les autres.

docker rmi Image Image

Résumé des commandes importantes utilisées

Commande	Description
docker container run <IMAGE>	Lance un conteneur.
docker image ls	Liste les images locales.
docker container ls	Liste les conteneurs en cours.
docker container ls --all	Liste tous les conteneurs.
docker container stop <NOM>	Arrête un conteneur.
docker container rm <NOM>	Supprime un conteneur.
docker image pull <IMAGE>	Télécharge une image.
docker container inspect <NOM>	Affiche les détails d’un conteneur.

Exercices pratiques

Basique avec image nginx

1. Télécharger l’image nginx:latest
2. Lancer un conteneur nginx en arrière-plan avec le nom mon_nginx.
3. Vérifier que le conteneur est en cours d’exécution.
4. Arrêter et supprime le conteneur.

Remarque : Comme vous êtes sous Windows, vous pouvez aussi utiliser Docker Desktop pour visualiser les conteneurs et images via une interface graphique.

---

Créer une image Docker pour une application Spring Boot

• Créer une image Docker contenant une application Spring Boot basique.
• L’exécuter dans un conteneur.
• Comprendre la structure d’un Dockerfile pour Java.

Ce TP s’effectue sous Windows avec Docker Desktop et WSL2 (Ubuntu) activé.

Préparer le projet Spring Boot

Votre application Spring Boot doit déjà être packagée en .jar (fichier exécutable). Dans IntelliJ, Eclipse, VSC ou Spring Initializr, créez un projet simple que vous nommez demo-docker.

Une fois le projet généré, compilez-le avec Maven ou Gradle :

mvn clean package -DskipTests

Cela devrait créer votre fichier .jar dans le dossier target/, vous devriez voir ceci :

target/demo-docker-0.0.1-SNAPSHOT.jar

Créer le Dockerfile

Il n’y a pas d’extension pour ce fichier. Un Dockerfile, c’est un fichier texte qui décrit comment fabriquer une image Docker.

Il ne lance rien et il construit juste une image, c’est comme une recette de cuisine !

Dans le dossier racine du projet (au même niveau que pom.xml), créez un fichier nommé dockerfile :

nano dockerfile

Vous pouvez aussi utiliser un éditeur différent.

Dans votre fichier dockerFile, insérez les lignes ci-dessous :

# choisir une image Java (OpenJDK ou autre)
FROM openjdk:17-jdk-slim

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

# copier le JAR dans le conteneur
COPY target/demo-docker-0.0.1-SNAPSHOT.jar app.jar

# exposer le port par défaut de Spring Boot (vous pouvez le modifier)
EXPOSE 8080

# définir la commande de démarrage (pour nous c'est le app.jar)
ENTRYPOINT ["java", "-jar", "app.jar"]

Quelques explications :

• FROM : base Java 17 (légère).
• WORKDIR : dossier de travail interne au conteneur.
• COPY : copie le fichier JAR généré par Maven.
• EXPOSE : rend le port 8080 accessible.
• ENTRYPOINT : lance l’application Spring Boot en exécutant le JAR.

Construire l’image Docker

Depuis le terminal WSL ou PowerShell, placez-vous dans le dossier du projet et exécutez :

docker build -t springboot-demo:latest .

• -t permet de donner un nom à l’image (ici springboot-demo).
• . indique que le Dockerfile est dans le dossier courant.

Si vous disposez d’un compte sur DockerHub, vous pouvez y déposer (on dit publier) votre image pour que d’autres la récupère ou tout simplement pour tester. On voit ceci un peu plus loin dans cette page… ;)

docker image ls

Lancer le conteneur

Exécutez le conteneur et redirigez le port :

docker run -p 8080:8080 -d springboot-demo:latest

• -p 8080:8080 connecte le port du conteneur (8080) au port de la machine hôte.
• -d le lance en arrière-plan.

Ensuite, vérifiez que tout fonctionne correctement :

docker ps

Testez sur votre navigateur à l’adresse : http://localhost:8080

Tester et observer les logs

Pour afficher les logs de l’application en cours :

docker logs <nom_du_conteneur>

par exemple : docker logs springboot-demo

Pour arrêter votre conteneur : docker stop <nom_du_conteneur>

Récapitulatif des commandes utilisées

Commande Docker	Description
docker build -t nom_image .	Construit une image à partir du Dockerfile
docker image ls	Liste les images locales
docker run -p 8080:8080 nom_image	Lance un conteneur
docker ps	Liste les conteneurs actifs
docker stop id_conteneur	Arrête un conteneur
docker rm id_conteneur	Supprime un conteneur
docker rmi nom_image	Supprime une image
docker logs id_conteneur	Affiche les logs d’un conteneur

Sauvegarder et partager votre image

Créer une archive .tar :

docker image save -o springboot-demo.tar springboot-demo

Recharger votre image :

docker image load -i springboot-demo.tar

Publier sur DockerHub

Connectez-vous à votre compte DockerHub (en créer un si vous n’en avez pas encore)

docker login

Renommez l’image avec votre nom d’utilisateur :

docker tag springboot-demo:latest moncompte/springboot-demo:latest

Poussez votre image :

docker push moncompte/springboot-demo:latest

Récapitulatif des mots-clés DockerFile

Mot-clé	Utilisation
FROM	Image de base utilisée
COPY	Copie de fichiers depuis l’hôte
WORKDIR	Dossier courant dans le conteneur
EXPOSE	Ouvre un port pour l’extérieur
ENTRYPOINT	Commande principale au démarrage
RUN	Exécute une commande lors du build
ENV	Définit une variable d’environnement

Quelques précisions sur ENTRYPOINT

Docker supporte les syntaxes :

• exec (recommandée car plus propre)
• shell (plus simple mais plus délicate)

Version exec

ENTRYPOINT ["commande", "arg1", "arg2"]

Exemple :

ENTRYPOINT ["java", "-jar", "app.jar"]

Docker lance :

java -jar app.jar

Raisons :

• Pas de shell sh -c implicite
• Arguments passés tels quels (pas d’expansion shell)
• Plus sûre, meilleure pour la prod
• Permet d’écraser les arguments à l’exécution avec docker run myimage arg1 arg2

Autre exemple :

ENTRYPOINT ["python", "app.py"]
CMD ["--port", "8080"]

Docker lance : python app.py --port 8080

Version shell

Moins recommandée, mais utile dans certains cas.

ENTRYPOINT command arg1 arg2

Exemple :

ENTRYPOINT java -jar app.jar

Docker lance :

sh -c "java -jar app.jar"

Avantages : On peut utiliser des variables shell, pipes, redirections >,

, &&, etc.

Inconvénients :

• Expansion shell –> surprises
• Pas de support clair des arguments d’image (CMD)
• Plus fragile (bash non installé dans alpine !)

Autre exemple :

ENTRYPOINT python app.py
CMD --port 8080

Docker lance : sh -c "python app.py"

Ici, vous voyez que le CMD est ignoré ou mal interprété, donc attention !

Pour aller plus loin

Nous verrons comment ajouter un Docker Compose pour lancer à la fois :

• votre application Spring Boot
• une base de données (MySQL ou PostgreSQL)

Un fichier docker-compose.yml sert à lancer plusieurs conteneurs d’un coup, à les configurer, à les mettre en réseau.

Il permet de préciser les éléments suivants :

• quelle image utiliser ?
• combien de conteneurs lancer ?
• quels ports exposer ?
• quels volumes monter ?
• quelles variables d’environnement charger ?
• comment les conteneurs communiquent entre eux ?

Exemple basique :

version: "3.9"
services:
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: demo
      POSTGRES_USER: demo
      POSTGRES_PASSWORD: demo
    ports:
      - "5432:5432"

  app:
    image: registry.gitlab.com/projetspringboot/app:latest
    depends_on:
      - db
    ports:
      - "8080:8080"

Nous verrons que la commande docker-compose up permet d’exécuter les actions du fichier docker-compose.yml

Points clés

• Docker Desktop simplifie la gestion sous Windows (pas besoin de commandes sudo).
• WSL 2 améliore les performances des conteneurs Linux.

Quelques alternatives à Docker

Personnellement, j’utilise Docker et Kubernetes selon les projets, mais même si Docker est le standard de la conteneurisation, il existe d’autres outils répondant à des besoins différents : sécurité, intégration Kubernetes, légèreté ou flexibilité. Certains disent que Docker n’est pas suffisamment sécurisé, ce qui est probable, mais il est simple d’utilisation.

Voici les principales alternatives sous forme de tableaux :

Podman — Exécution sans démon

Caractéristiques	Description
Principe	Fonctionne sans démon Docker, chaque conteneur est lancé comme un simple processus utilisateur.
Avantages	- Exécution sans droits root (plus sûr) - Compatible CLI Docker - Bon isolement réseau
Inconvénients	Écosystème plus petit que Docker
Idéal pour	Développeurs Linux cherchant plus de sécurité et de contrôle

containerd — Moteur standard léger (OCI)

Caractéristiques	Description
Principe	Moteur d’exécution léger respectant le standard OCI (Open Container Initiative).
Avantages	- Très stable et léger - Base utilisée par Docker et Kubernetes - Compatible avec plusieurs orchestrateurs
Inconvénients	Moins de fonctionnalités “grand public” (interface limitée)
Idéal pour	Experts cherchant une solution standardisée et scalable

CRI-O — Exécution native pour Kubernetes

Caractéristiques	Description
Principe	Implémente le Container Runtime Interface (CRI) de Kubernetes.
Avantages	- Performant et optimisé pour Kubernetes - Sécurisé (AppArmor, seccomp) - Léger et rapide
Inconvénients	Limité à Kubernetes uniquement
Idéal pour	Les équipes DevOps travaillant exclusivement sur Kubernetes

LXC / LXD — Virtualisation légère façon (mini-VMs)

Caractéristiques	Description
Principe	Conteneurisation de type “machine complète”, proche d’une virtualisation légère.
Avantages	- Contrôle granulaire sur les ressources - Bonne isolation - Sauvegardes faciles (snapshots)
Inconvénients	Plus complexe à maîtriser Écosystème plus restreint
Idéal pour	Administrateurs Linux ou utilisateurs Ubuntu recherchant un contrôle avancé

runc — Outil minimal conforme OCI

Caractéristiques	Description
Principe	Exécutable en ligne de commande pour lancer des conteneurs conformes OCI.
Avantages	- Ultra-léger - Rapide - Utilisé en interne par Docker et containerd
Inconvénients	Pas d’interface ni de gestion avancée
Idéal pour	Utilisateurs avancés cherchant un runtime minimaliste et performant

rkt (Rocket) — Exécution de pods sécurisée

Caractéristiques	Description
Principe	Exécute plusieurs conteneurs regroupés dans un pod (comme Kubernetes).
Avantages	- Isolation forte des processus - Prend nativement en charge les pods - Conforme OCI
Inconvénients	- Plus complexe à configurer - Moins orienté Kubernetes
Idéal pour	Organisations expérimentées cherchant sécurité et exécution multi-conteneurs sans Kubernetes

tableau récapitulatif

Outil	Sans démon	Compatible Docker	Focalisé sur Kubernetes	Sécurité renforcée	Légèreté	Niveau requis
Podman	Oui	Oui (CLI identique)	Partiel	Ok	Moyen	Facile
containerd	Non	Base de Docker	Oui	Moyen	Ok	Élevé
CRI-O	Non	Non	Oui (exclusif)	Ok	Ok	Élevé
LXC / LXD	Non	Non	Non	Ok	Variable	Élevé
runc	Non	Oui (via Docker)	Oui (OCI)	Basique	Ok	Très élevé
rkt	Oui	Non	Partiel	Ok	Moyen	Élevé

Pour résumé, Docker reste la référence pour l’apprentissage et la simplicité, Podman lui, est considéré comme plus sécurisé (on n’est pas Root), containerd est léger et utilisé par d’autres outils, CRI-O est idéal avec du Kubernetes pur, LXC/LXD est une approche système, proche de la virtualisation, runc/rkt propose des outils bas niveau destinés aux environnements experts.

Voilà, vous avez une vision des alternatives à Docker.

Auteur : Philippe Bouget