TP sur Docker
1. Préparatifs
1.1. Mise en place de la VM Linux sous Hyper-V
- Créez une VM Linux (Ubuntu Server, Debian ou CentOS, au choix) sous Hyper-V, avec les ressources suivantes (pouvant varier selon les possibilités de la plateforme) :
- 2 ou 4 vCPU
- 4 Go de RAM
- 20 Go de disque minimum
- Veillez à ce que la VM ait accès à Internet (car il faudra installer et télécharger des images Docker).
1.2. Installation de Docker
Dans la VM Linux, effectuez l'installation de Docker. Par exemple, sous Ubuntu :
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release
# Ajout de la clé GPG Docker
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
# Ajout du dépôt Docker
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
# Mise à jour et installation Docker
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io
Vérifiez que Docker fonctionne correctement :
sudo systemctl status docker
docker version
docker info
Optionnellement, vous pouvez ajouter l'utilisateur courant au groupe docker afin de pouvoir exécuter Docker sans sudo :
sudo usermod -aG docker <votre-utilisateur>
newgrp docker
2. Premiers pas avec Docker
2.1. Docker Hello World
- Lancez une première commande Docker simple pour valider le bon fonctionnement :
- Vous devez obtenir le message de confirmation Hello from Docker!.
- Vérifiez que le conteneur est terminé en listant les conteneurs (en cours et terminés) :
- Nettoyez les conteneurs terminés et les images inutilisées (bonne pratique) :
docker rm $(docker ps -aq)
docker rmi hello-world
(Cette étape est facultative, mais elle permet de garder l'environnement propre.)
2.2. Lancer une application simple depuis Docker Hub
- Lancez un serveur web nginx avec Docker :
docker run -d -p 8080:80 --name mon-serveur-nginx nginx
- Option -d : détaché (en arrière-plan).
- Option -p 8080:80 : publication du port 80 du conteneur sur le port 8080 de l'hôte.
- Option --name mon-serveur-nginx : nom personnalisé du conteneur.
- Ouvrez votre navigateur (depuis le réseau local ou la VM si elle a une interface graphique) et accédez à l'URL http://<IP-VM>:8080.
- Vous devriez voir la page d'accueil par défaut d'Nginx.
- Vérifiez que le conteneur est bien actif :
- Arrêtez le conteneur et supprimez-le :
docker stop mon-serveur-nginx
docker rm mon-serveur-nginx
3. Construction d'une image Docker simple (Dockerfile)
3.1. Créer un répertoire et un fichier de test
- Dans votre répertoire de travail (par exemple ~/tp-docker), créez un sous-répertoire demo-app.
- Créez un fichier index.html :
<!DOCTYPE html>
<html>
<head>
<title>Page Web Demo Docker</title>
</head>
<body>
<h1>Bonjour, Docker !</h1>
<p>Page statique pour la démo.</p>
</body>
</html>
3.2. Créer un Dockerfile
- Toujours dans le répertoire demo-app, créez le fichier Dockerfile suivant :
# Utiliser l'image officielle nginx comme base
FROM nginx:latest
# Supprimer le contenu par défaut de Nginx
RUN rm -rf /usr/share/nginx/html/*
# Copier notre page statique dans le conteneur
COPY index.html /usr/share/nginx/html/
# Exposer le port 80 (informatif pour l'orchestrateur)
EXPOSE 80
# Commande de lancement par défaut (déjà définie dans l'image nginx)
CMD ["nginx", "-g", "daemon off;"]
3.3. Construire et tester l'image
- Depuis le dossier demo-app, construisez l'image :
docker build -t demo-nginx:v1 .
- -t demo-nginx:v1 : indique le nom (demo-nginx) et la balise (v1) de l'image.
- Vérifiez la présence de l'image :
- Lancez un conteneur à partir de cette image :
docker run -d -p 8080:80 --name mon-nginx-demo demo-nginx:v1
- Ouvrez l'URL http://<IP-VM>:8080 : vous devriez voir la page statique personnalisée (Bonjour, Docker !).
- Arrêtez et supprimez le conteneur :
docker stop mon-nginx-demo
docker rm mon-nginx-demo
4. Mise en place d'une application avec docker-compose
Pour illustrer la mise en place de deux services, nous allons configurer :
- Un service web (basé sur notre image demo-nginx:v1 ou sur une application web simple).
- Un service db (une base de données, par exemple MySQL ou PostgreSQL).
4.1. Créer un nouveau répertoire
- Créez un répertoire demo-compose.
- À l'intérieur, créez un fichier docker-compose.yml.
4.2. Exemple de contenu docker-compose.yml
Voici un exemple avec MySQL et notre Nginx :
version: '3.8'
services:
db:
image: mysql:8.0
container_name: demo-mysql
environment:
MYSQL_ROOT_PASSWORD: secret
MYSQL_DATABASE: demo_db
MYSQL_USER: demo_user
MYSQL_PASSWORD: demo_pass
volumes:
- db_data:/var/lib/mysql
networks:
- demo-net
web:
image: demo-nginx:v1
container_name: demo-nginx
ports:
- "8080:80"
depends_on:
- db
networks:
- demo-net
volumes:
db_data:
networks:
demo-net:
Explications
- db :
- Utilise l'image officielle MySQL 8.
- Définit des variables d'environnement pour initialiser la base de données.
- Monte un volume (nommé db_data) pour persister les données de la base en dehors du conteneur.
- Est connecté au réseau demo-net.
- web :
- Utilise l'image que nous avons construite précédemment (demo-nginx:v1).
- Publie le port 80 sur le port 8080 de l'hôte.
- Dépend de db (Docker Compose lance d'abord db, puis web).
- Est également sur le réseau demo-net.
4.3. Démarrer la stack
- Dans le dossier demo-compose, exécutez :
- -d : détaché.
- Vérifiez que les deux conteneurs sont bien créés et démarrés :
ou
- Testez l'accès depuis un navigateur :
- Vous devez voir votre page statique de l'image demo-nginx:v1.
- Connectez-vous au conteneur db en mode interactif (pour constater la présence de la base demo_db, par exemple) :
docker exec -it demo-mysql bash
mysql -u demo_user -p
# Mot de passe : demo_pass
show databases;
- Quittez MySQL puis le bash du conteneur :
5. Options supplémentaires et pistes d'exploration
- Gestion des logs :
Utilisez docker logs pour visualiser la sortie standard d'un conteneur.
Exemple : docker logs demo-nginx.
- Volumes persistants :
Vérifiez que le volume db_data persiste bien d'une exécution à l'autre.
- docker volume ls
- docker volume inspect db_data
- Gestion du réseau :
- Inspectez le réseau créé par Docker Compose : docker network ls puis docker network inspect <nom-réseau>.
- Essayez de "ping" un conteneur depuis un autre pour vérifier la résolution DNS interne :
docker exec -it demo-nginx ping demo-mysql
- Modification de l'application Web :
Vous pouvez modifier le Dockerfile pour inclure un framework ou un langage (Python, Node.js, PHP) et tester un mini-script dynamique qui interroge la base MySQL.
- Sécurité :
- Sensibilisez les stagiaires sur la gestion des mots de passe et les variables d'environnement dans Dockerfiles et docker-compose.yml.
- Montrez éventuellement comment externaliser les secrets via un fichier .env.
- Gestion des images :
- Montrez comment tagger et pousser une image sur un registre Docker privé (ou sur Docker Hub si vous possédez un compte).
- Par exemple :
docker tag demo-nginx:v1 docker.io/<username>/demo-nginx:v1
docker push docker.io/<username>/demo-nginx:v1
- Docker Swarm ou Kubernetes (pour aller plus loin) :
Pour approfondir...
6. Synthèse pédagogique
Objectifs atteints :
- Installation de Docker sous Linux.
- Lancement d'images officielles (hello-world, nginx).
- Création d'une image Docker personnalisée (Dockerfile).
- Exécution et test d'un conteneur personnalisé.
- Mise en place d'une configuration multi-services (web + base de données) avec docker-compose.
- Découverte de la persistance des données (volumes).
- Introduction à la gestion de réseau et de logs Docker.
Compétences visées (TSSR) :
- Maîtriser la virtualisation (Hyper-V pour la VM).
- Configurer et sécuriser un environnement Linux (installation, configuration réseau).
- Déployer et administrer des conteneurs Docker.
- Mettre en place et gérer des services réseau (web, base de données).
- Comprendre l'architecture client/serveur et la façon dont Docker gère l'isolation des services.
- Notions de persistance de données et de bonnes pratiques (logs, networking).
Rapport
- Fournir un compte-rendu documentant les étapes réalisées, avec des captures d'écran ou extraits de console montrant :
- L'installation et la version de Docker.
- Le Dockerfile créé et l'image générée.
- Le conteneur fonctionnel accessible via un navigateur.
- Le docker-compose.yml fonctionnel, avec deux services (web + db).
- Les vérifications de bon fonctionnement (ping entre conteneurs, logs, persistance de données).
- Les manipulations avancées éventuelles (gestion des volumes, variable d'environnement, etc.)