TP : Docker
1) Partie 1 :
Objectif :
L’objectif principal de cette partie est de s’initier à la construction des images Docker. Les étapes
primordiales sont comme suit :
- Exploration de l’image hello-world
- Création et exécution d’une application sur la machine hôte (création d’une application
classique)
- Création d’une image de l'application à partir du fichier Dockerfile : utilisation de la commande
"docker build". Deux méthodes seront proposées
- Création d’une image de l'application à partir d'un conteneur : utilisation de la commande
"docker commit".
- Publication d’une image dans le registre Docker Hub
Travail Demandé :
I. Construction d'une image Docker "Hello"
A. Développement d'une application "hello" sur la machine locale
L’objectif de cette étape est de créer une application hello sur la machine Ubuntu. Cette application
nous servira dans la suite du TP. Pour ce faire, suivez les étapes suivantes :
1- Créez un répertoire "hello_directory" qui va contenir votre dockerfile.
$ mkdir hello_directory
$ cd hello_directory
2- Dans le répertoire hello, créez un fichier "hello.c" qui permet d’afficher le message "Hello
From Docker LAB !".
$ nano hello.c
#include <stdio.h>
int main()
{
printf("Hello From Docker LAB ! \n");
return 0;
}
3- Compilez le code source (hello.c) avec gcc en créant le fichier exécutable "hello"
1
Enseignante : Amina Jandoubi
$ gcc -o hello -static hello.c
- L'option "static" est ajoutée pour creér un fichier exécutable statique sans dépendances
logicielles. En d'autres termes, il ne nécessite pas de dépendance sur les bibliothèques
dynamiques au moment de l'exécution de la commande.
4- Affichez le contenu du dossier hello après compilation : un fichier exécutable "hello" s'est ajouté
après compilation (fichier objet).
$ ls
5- Exécutez le fichier "hello"
$ ./hello
B. Création d'une image Docker "hello" à partir du fichier Dockerfile
L’objectif de cette étape est de créer une image Docker hello à partir du fichier Dockerfile. Pour ce
faire, nous allons créer une image Docker "hello" qui renvoie un message d'accueil sur le terminal
"Hello From Docker LAB !"
Pour créer cette image Docker, nous allons préparer le fichier Dockerfile de l'image. Le fichier
Dockerfile doit aboutir à une image exécutable de l'application. Il doit comporter une description de
toutes les dépendances de l'image ainsi que les commandes nécessaires pour l'exécuter. Pour ce faire,
il faut spécifier dans le fichier Dockerfile, notre plateforme de départ. En d’autres termes, il faut
spécifier le système de fichiers sur lequel nous allons former notre application.
Pour notre application "hello" deux choix sont possibles pour exécuter l'application et afficher le
message d'accueil :
• à partir du fichier code source "hello.c" : image de base ubuntu
• à partir du fichier code objet "hello.o" : image de base machine vide : scratch puisque ce
fichier est indépendant de toute plateforme logicielle et pour exécuter la commande ./hello,
un noyau n'a besoin d'aucune dépendance logicielle : aucune image de base n'est requise.
Méthode 1 : image de base "ubuntu"
2
Enseignante : Amina Jandoubi
Pour éditer le fichier Dockerfile en partant d'un système de fichiers "ubuntu", on doit enchainer avec
ces actions :
• Installer le compilateur gcc
• Copier le code source "hello.c" sur le système de fichiers image
• Compiler le fichier code source
• Exécuter la commande "/hello
Etape 1 : Préparation du fichier Dockerfile
1. Tapez la commande suivante pour créer et éditer le fichier "Dockerfile" : $ nano Dockerfile
2. Ecrivez les lignes de code suivante sur le fichier Dockerfile.
FROM ubuntu
RUN apt-get -y update
RUN apt-get -y install gcc
COPY hello.c /
RUN gcc -o hello hello.c
CMD ["/hello"]
Etape 2 : Création image avec la commande "docker build"
3. Créez une image nommée hello:version1 à partir du Dockerfile. - Noubliez pas d'ajouter le point
en fin de ligne pour indiquer le chemin d'accès du fichier Dockerfile.
$ docker build -t hello:version1 .
4. Vérifiez que l'image est créée
$ docker images
3
Enseignante : Amina Jandoubi
Etape 3 : Exécution d'un conteneur à partir de l'image "hello"
5. Créer et démarrer un conteneur qui utilise l'image "hello"
$ docker run hello:version1
Méthode 2 : image de base "machine vide : scratch"
Il est possible d’utiliser directement le fichier objet "hello" déjà généré pour la construction de
l'image. Ce fichier ne nécessite aucun système de fichiers de base pour s'exécuter : aucune
dépendance. L'image de base est ainsi la machine vide : scratch
Etape 1 : Préparation du fichier Dockerfile
1. Tapez la commande suivante pour créer et éditer le fichier "Dockerfile" :
$ nano Dockerfile
FROM scratch
COPY hello /
CMD ["/hello"]
Etape 2 : Création image avec la commande "docker build"
2. Créez une image nommée hello:version2 à partir du Dockerfile. - Noubliez pas d'ajouter le point
en fin de ligne pour indiquer le chemin d'accès du fichier Dockerfile.
$ docker build -t hello:version2 .
3. Vérifiez que l'image est créée : $ docker images
4
Enseignante : Amina Jandoubi
Etape 3 : Exécution d'un conteneur à partir de l'image "hello"
4. Créez et démarrez un conteneur qui utilise l'image "hello"
$ docker run hello:version2
C. Création d'une image Docker "hello" à partir d'un conteneur
L’objectif de cette partie est de créer l'application précédente « hello » à partir d'un conteneur
ubuntu, ensuite générer l’image à partir de ce conteneur. Pour ce faire, vous êtes chargés de
suivre les étapes suivantes.
Suppression de l'application locale
Supprimez le répertoire de travail de votre application.
$ cd ..
$ rm -r hello_directory
Etape 1 : Création et démarrage d'un conteneur Docker
1. Créez un nouveau conteneur Docker à partir de l'image "ubuntu" en mode interactif et nommez-
le "hello_container" : $ docker create -it --name hello_container ubuntu
2. Démarrez votre conteneur : $ docker start hello_container
Etape 2 : Modification du conteneur-Installation de gcc
3. Faites l'accès à votre conteneur en ouvrant une session bash :
$ docker exec -it hello_container /bin/bash
4. Mettez à jour la liste des packages : apt update
5
Enseignante : Amina Jandoubi
5. Installez gcc : apt install gcc
Etape 3 : Création de l'application
6. Créez un répertoire "hello_directory"
mkdir hello_directory
cd hello_directory
7. Dans le répertoire hello, créez un fichier "hello.c" qui permet d’afficher le message "Hello From
Docker LAB !".
Remarque : Si la commande "nano" est non reconnue, installez "nano" : apt install nano
nano hello.c
#include <stdio.h>
int main()
{
printf("Hello From Docker LAB ! \n");
return 0;
}
6
Enseignante : Amina Jandoubi
8. Compilez le code source (hello.c) avec gcc en créant le fichier exécutable "hello"
$ gcc -o hello hello.c
9. Exécutez le fichier "hello" : $ ./hello
10. Quittez le conteneur : $exit
Etape 4 : Enregistrement des modifications apportées au conteneur à une image- La commande
docker commit
11. Pour enregistrer les modifications apportées sur votre conteneur d'une façon permanente, Créez
une image nommée "hello:version3" à partir du conteneur "hello_container"
$ docker commit hello_container hello:version3
12. Vérifiez que l'image est créée : $ docker images
Etape 5 : Exécution de l'image sur un conteneur
13. L’étape suivante est d’instancier depuis cette image un conteneur.
7
Enseignante : Amina Jandoubi
Remarque : pour lancer l'applcation et afficher le message d'accueil, on doit passer la
commande "/hello_directory/hello" au moment de lancement du conteneur
$ docker run hello:version3 /hello_directory/hello
D. Interprétation et conclusion
Affichez la liste des images disponibles dans le dépôt local Docker et comparez la taille des trois
versions de l'image "hello". Interprétez le résultat.
II. Publication de l'image
L’objectif de cette étape est de publier une image dans le registre Docker Hub. Pour avoir la possibilité
de publier votre image, vous devez créer votre propre compte sur le lien : [Link]
Etape 1 : Docker Hub login
1. Une fois votre compte a été créé, vous pouvez vous connecter à partir du terminal en exécutant
la commande suivante :
$ docker login
Etape 2 : Ajout d'une TAG à l'image
2. Récupérez l’ID de votre image.
8
Enseignante : Amina Jandoubi
3. Ajoutez le tag "latest" à votre image : $ docker tag cb7cdf9c9419 <your_name>/hello:latest
4. Publiez votre image avec la commande : $ docker push <your_name>/hello:latest
5. Visitez [Link] et consultez votre image.
2) Partie 2:
Objectif :
L’objectif principal de cette partie est de faire le déploiement des applications Docker à conteneurs
multiples.
Deux méthodes seront traitées :
- Déploiement d'une pile logicielle LAMP avec Docker.
- Déploiement d'une pile logicielle LAMP avec Docker Compose
Travail Demandé :
I. Description de l’application
Dans ce TP, nous allons considérer une application web de gestion des articles scientifiques qui permet
d'ajouter les nouveaux articles à une base de données.
9
Enseignante : Amina Jandoubi
L'application utilise la pile logicielle LAMP (Linux Apache MySQL PHP)
Code source application
Le code source de l'application web est fourni avec l’énoncé du TP dans un dossier sources. Le
dossier "sources" contient le code web de l'application (dossier app) avec une table de données SQL.
1. Copiez le dossier "sources" sur votre répertoire maison de la machine virtuelle Linux
10
Enseignante : Amina Jandoubi
a. Le fichier de l'application "[Link]" contient les paramètres de configuration
pour l'accès serveur web à la base de données MySQL
b. Les fichiers de l'application "[Link]" et "[Link]" contiennent le code php
de l'application (page d'accueil, interfaces).
c. Le fichier de l'application "[Link]" contient la base de données
III. Préparation des images à déployer sur les conteneurs
A. Préparation de l'application web Docker
Etape 1 : Image de base
On va utiliser l'image officielle Docker "php:7-apache" : Image qui contient apache httpd avec php:
- Visitez le lien : [Link]
- Lisez la description de la variante image de type : php:version-apache
11
Enseignante : Amina Jandoubi
Etape 2 : Configuration
- Le code source de l'application web est fourni avec le TP: dossier "app".
- Le code php de l'application sera copié sur le système de fichiers de l'image à la destination
"/var/www/html"
Dans l’étape suivante, lors de la création du Dockerfile, nous allons copier ce code.
Etape 3 : Edition Dockerfile
1. Placez-vous sur le répertoire "sources" et créez le fichier Dockerfile
$ cd sources
$ nano dockerfile
2. Contenu du fichier Dockerfile
FROM php:7-apache
# Activation des modules php
RUN docker-php-ext-install pdo pdo_mysql
# Configuration
WORKDIR /var/www/html
COPY app/ .
Etape 4 : Création image
3. Créez l'image docker "myweb_app" de votre application web.
$ docker build -t myweb_app .
4. Vérifiez la création de l’image "myweb_app"
12
Enseignante : Amina Jandoubi
$ docker images
B. Préparation de l'application MySQL Docker
Etape 1 : image de base
- On va utiliser une image docker "mysql:5.7"
- Visitez le lien : [Link]
- Lisez la description de l'image : mysql
Etape 2 : Configuration
- Les paramètres suivants seront configurés :
• MYSQL_ROOT_PASSWORD='test'
• MYSQL_DATABASE='test'
• MYSQL_USER='test'
• MYSQL_PASSWORD='test'
• Importation du fichier base de données "[Link]"
Dans l’étape suivante, lors de la création du Dockerfile, nous allons ajouter ces paramètres.
Etape 3 : Edition Dockerfile
1. Placez-vous sur le répertoire "sources" et éditez de nouveau le fichier Dockerfile.
$ nano dockerfile
2. Contenu modifié du fichier Dockerfile
FROM mysql:5.7
ENV MYSQL_DATABASE=test
ENV MYSQL_ROOT_PASSWORD=test
ENV MYSQL_USER=test
ENV MYSQL_PASSWORD=test
### import sql table
ADD [Link] /docker-entrypoint-initdb.d
13
Enseignante : Amina Jandoubi
Etape 4 : Création image
3. Créez l'image docker "mysql_db"
$ docker build -t mysql_db .
4. Vérifiez la création de l’image mysql_db
$ docker images
IV. Déploiement des conteneurs sans docker-compose
Etape 1 : Création du conteneur base de données
Avant de créer le conteneur de base de données, nous allons définir un volume commun (dossier)
sur la machine hôte pour récupérer les modifications apportées sur le conteneur.
1. Créez un dossier "db-volume" sur votre répertoire maison.
$ sudo mkdir /home/$USER/db-volume/
$ ls
2. Créez le conteneur de la base de données "mysql_container" à partir de l'image "mysql_db".
$ docker run -d --name mysql_container --volume /home/$USER/db-volume:/var/lib/mysql mysql_db
- docker run mysql_db : démarrer un nouveau conteneur à partir de l'image "mysql_db" avec
les options suivantes :
• -d : démarrer le conteneur en arriere-plan
• --name mysql_container : nom du conteneur
• --volume /home/db-volume:/var/lib/mysql : définir un volume commun "/home/db-
volume" entre machine hôte et conteneur.
14
Enseignante : Amina Jandoubi
3. Vérifiez le démarrage de conteneur : $ docker ps
4. Consultez le volume partagé "db-volume" et affichez son contenu :
$ ls /home/$USER/db-volume
5. Question : Que représente ce contenu?
Etape 2 : Création du conteneur application web
6. Créez le conteneur de l'application web "myweb_container" à partir de l'image "myweb_app"
$ docker run -d --name myweb_container -p 8080:80 --link mysql_container myweb_app
- docker run myweb_app : démarrer un nouveau conteneur à partir de l'image
"myweb_app" avec les options suivantes :
• -d : démarrer le conteneur en arriere-plan
• --name myweb_container : nom du conteneur
• -p 8080:80 : définir le port d'accès de l'application web sur la machine hôte
• --link mysql_container : permet de connecter /relier le conteneur web au
conteneur base de données pour assurer la communication entre les deux
7. Vérifiez le démarrage du conteneur.
$ docker ps
8. Vérifiez l'accès à l'application à l’aide de votre navigateur Web.
15
Enseignante : Amina Jandoubi
V. Déploiement des conteneurs avec docker-compose
Avant de démarrer cette section, prière de supprimer les conteneurs "mysql_container" et
"myweb_container"
$ docker stop mysql_container myweb_container
$ docker rm mysql_container myweb_container
Installation de docker-compose
1. Tapez la commande suivante pour installer docker-compose.
$ sudo curl -L "[Link]
compose-linux-x86_64" -o /usr/local/bin/docker-compose
2. Donnez le droit d’exécution au répertoire /usr/local/bin/docker-compose.
$ sudo chmod +x /usr/local/bin/docker-compose
3. Vérifiez ensuite votre installation.
$ docker-compose --version
Préparation du fichier docker-compose
Nous allons créer un fichier docker-compose qui liste les besoins en termes d'images et les
configurations nécessaires pour chaque conteneur.
4. Dans le répertoire application (sources), créez un fichier [Link]
$ cd /home/$USER/sources
$ nano [Link]
Nous allons utiliser nos images myweb_app et mysql_db. Les paramètres de configuration sont
déja apportés sur les images.
16
Enseignante : Amina Jandoubi
version: '3.7'
services:
db:
image: mysql_db
container_name: mysql_container
restart: always
volumes:
- /home/$USER/db-volume:/var/lib/mysql
web:
image: myweb_app
container_name: myweb_container
restart: always
ports:
- 8080:80
depends_on:
- mysql_container
Lancement de l’application depuis docker-compose
5. Placez vous au niveau du répertoire qui contient le fichier [Link].
6. Ensuite lancez la commande suivante pour exécuter les services du [Link] :
$ docker-compose up -d
7. Vérifiez le démarrage des conteneurs.
$ docker ps
$ docker-compose ps
8. Vérifiez l'accès à l'application à l’aide de votre navigateur Web : [Link]
17
Enseignante : Amina Jandoubi
9. Ajoutez l'article suivant :
- Titre : Lord of the Flies
- Auteur : William Golding
- Description : Lord of the Flies is a 1954 novel by Nobel Prize-winning British author
William Golding
18
Enseignante : Amina Jandoubi
VI. Gestion de la base de données
Gestion de la base de données : accès conteneur MySQL
1. Pour faire accès à la base de données de l'application, on va utiliser en premier temps la
commande "docker exec"
$ docker exec -it mysql_container /bin/bash
2. A l'intérieur du conteneur, exécutez la ligne de commande suivante :
mysql -uroot -p
3. Pour voir la liste des bases de données, tapez :
mysql> show databases;
4. Pour utiliser la base de données "test", tapez :
mysql> use test;
5. Pour afficher le contenu de la table "articles", tapez :
mysql> SELECT * FROM articles;
19
Enseignante : Amina Jandoubi
. Gestion de la base de données à l'aide de l'application web phpMyAdmin
L'outil phpMyAdmin offre une interface web simple pour gérer une base de données MySQL sur un
serveur PHP. Nous allons utiliser un conteneur phpMyAdmin et le connecter à la base de données
MySQL.
1. Démarrez le conteneur "myphp_container" à partir de l'image officielle "phpmyadmin"
accesible à : [Link] avec les options suivantes :
- Mode d'exécution en arrière plan : -d
- Nom conteneur : --name pma_container
- Port mapping : -p 8081:80
- Variable d'environnement : -e PMA_HOST= mysql_container
- Réseau : --network = sources_default
Vérifier les réseaux existants Vous pouvez d'abord vérifier les réseaux Docker existants en
utilisant la commande suivante :
2. Après ajout de l'option nécessaire, testez l'accès à l'interface phpMyAdmin à travers le lien :
[Link]
20
Enseignante : Amina Jandoubi
3. Modifiez votre fichier [Link] pour ajouter les configurations nécessaires à la
création de conteneur "phpmyadmin_container" à partir de l'image "phpmyadmin".
21
Enseignante : Amina Jandoubi