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

Ouvrir un terminal (PowerShell ou WSL 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 actif mais présents. J’ai encadré les noms (NAME) généré 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

Télécharger l’image nginx:latest
Lancer un conteneur nginx en arrière-plan avec le nom mon_nginx.
Vérifier que le conteneur est en cours d’exécution.
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

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 Docker Hub

Connectez-vous à votre compte Docker Hub (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

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)

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, 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 tableau :

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 idée des principales alternatives à Docker.