Prise en main de Docker

Généralités

Docker est une solution de virtualisation alternative par rapport aux hyperviseurs de type 1 (→ Hyper-V, VMware ESXi, Citrix XenServer…) ou de type 2 (→ VMware Workstation, Oracle VirtualBox, …).

Docker est une application client-serveur.

Elle s’appuie sur les notions d'images et de containers.

Un container contient tout ce qui est nécessaire à l’exécution d’une application dans un environnement isolé du système d’exploitation de la machine hôte (→ Host OS), un peu à la façon d’une machine virtuelle s’exécutant sur un hyperviseur de type 2. Cependant, contrairement à cette dernière, un container ne requiert pas l’installation d’un système d’exploitation invité (→ Guest OS).

Ceci en fait une solution de virtualisation beaucoup plus légère que celle basée sur les hyperviseurs de type 2.

En revanche, elle isole moins les applications les unes par rapport aux autres (⇒ plus de risques de faille de sécurité).

Un container est créé à partir de ce qu’on appelle une image.

On peut assimiler une image Docker au fichier .iso d’installation d’un système d’exploitation et le container au système d’exploitation lui-même, après installation.

On peut construire ses propres images pour déployer des containers d’applications populaires comme des serveurs web (Apache, Nginx…), bases de données (MySQL, Postgres…), langages de programmation (C, Python, PHP, Rust…) etc… mais beaucoup sont déjà disponibles dans le registre dockerhub link présent sur internet.

Ci-dessous, une présentation de Docker en vidéo :

💻 Travail n° 1 Site web statique

Pour vous rendre compte de la relative simplicité de mise en œuvre de Docker, vous allez créer un container embarquant un serveur web qui va exposer un site web simpliste.

🎯 Travail à faire :

Depuis le menu File Import Appliance… de Virtual Box importer l’image au format .ova de la VM Linux fournie par l’enseignant (→ Docker-LAB.ova). Celle-ci contient :
- un système Linux minimal (→ Debian Bookworm) en mode console dans lequel l’application Docker (serveur + client) a été installée
- des images Docker récupérées au préalable sur le Docker Hub pour éviter d’avoir à les télécharger depuis internet durant l’activité
  
  Veillez à bien regénérer les adresses MAC des interfaces réseau.
Une fois lancée, s’y connecter avec l’identifiant “john” et le mot de passe “john” également.
Récupérer l’adresse ip de la VM avec la commande ip addr

L’adresse ip à récupérer est celle de l’interface nommée enp0s3.
Minimiser la fenêtre de la VM dans la barre des tâches (→ +↓+↓).

Vous allez à présent accéder via SSH à la VM depuis Windows avec PuTTY.

Ceci va permettre de faire des copier-coller des commandes depuis le sujet de l’activité et d’avoir une console facilement configurable (taille de la police de caractères par exemple)
Se connecter à la VM via PuTTY en fournissant son adresse ip récupérée précédemment

Lister les images Docker disponibles avec la commande :

docker images

Résultat :

john@docker-lab:~$ docker images
REPOSITORY    TAG               IMAGE ID       CREATED        SIZE
php           apache-bookworm   aa1a7b18157c   12 days ago    503MB
httpd         bookworm          359570977af2   3 weeks ago    168MB
mysql         latest            c138801544a9   2 months ago   577MB
hello-world   latest            9c7a54a9a43c   5 months ago   13.3kB

Lancer le container embarquant le serveur web Apache prêt à l’emploi à partir de l'image httpd “taggée” bookworm.

docker run -d --name apache-server -p 8080:80 httpd:bookworm (1)

On lance (→ run) un container depuis l’image httpd:bookworm auquel on donne le nom apache-server (→ option --name) qui s’exécutera en tâche de fond (→ option -d) et qui exposera son port 80 sur le port 8080 de notre VM Linux (→ option -p 8080:80)

Résultat :

john@docker-lab:~$ docker run -d --name apache-server -p 8080:80 httpd:bookworm
a8ab349c84cf2b9423061c2624a04c8feb3743ba27a8fbe9c5a0e20feec4d5c0

Le nombre renvoyé suite à l’exécution de la commande (→ a8ab349c84c…) identifie de manière unique le container (→ container id). Celui qui vous sera renvoyé sera différent de celui affiché ici.

Ouvrir dans un navigateur internet l’URL http://<ip-vm-linux>:8080 en remplaçant <ip-vm-linux> par l’IP de votre VM.

Ceci doit mener à l’affichage d’un message “It works” dans la fenêtre du navigateur ⇒ Ceci indique que le serveur web est opérationnel.
C’est génial, non ? 😉
Lister les containers actifs avec une des 2 commandes suivantes qui sont équivalentes :
```
docker ps
# ou
docker container ls
```
Résultat :
```
john@docker-lab:~$ docker ps
CONTAINER ID   IMAGE            COMMAND              CREATED         STATUS         PORTS                                   NAMES
a8ab349c84cf   httpd:bookworm   "httpd-foreground"   3 minutes ago   Up 3 minutes   0.0.0.0:8080->80/tcp, :::8080->80/tcp   apache-server
```
On retrouve :
- l’identifiant du container : a8ab349c84cf
- l'image Docker ayant servi pour ce container : httpd:bookworm
- la mise en correspondance du port 80 du container sur le port 8080 de l’hôte : 0.0.0.0:8080→80/tcp, :::8080→80/tcp
- le nom attribué au container : apache-server
On va maintenant ouvrir un shell dans le container afin d’exécuter une commande qui va modifier légèrement le contenu de la page web par défaut du serveur Apache

Lancer un shell dans le container

docker exec -it apache-server bash (1)

1	On lance un shell (→ `bash`) intéractif (→ option `-i`) dans le container `apache-server` avec lequel on va interagir avec un terminal (→ option `-t`). On est placé automatiquement dans le répertoire `/usr/local/apache2` où se trouve le contenu du site web.

Modifier très légèrement le contenu de la page d’accueil du site web du container avec la commande suivante pour qu’elle s’affiche en majuscules :

cat htdocs/index.html | tr [:lower:] [:upper:] | tee ./htdocs/index.html (1)

1	On convertit en majuscules tout le contenu du fichier `index.html` et on affiche aussi le résultat à l’écran (→ pipe vers la commande `tee`)

Résultat :

root@a8ab349c84cf:/usr/local/apache2# cat htdocs/index.html | tr [:lower:] [:upper:] | tee ./htdocs/index.html (1)
<HTML><BODY><H1>IT WORKS!</H1></BODY></HTML>
root@a8ab349c84cf:/usr/local/apache2#

On saisit une séquence de commandes dans le shell du container pour convertir le contenu de index.html en majuscules (noter l’invite de commande qui indique l’utilisateur et l’identifiant du container)

En rafraichissant la page web dans le navigateur, vous devez voir le message “IT WORKS” (plutôt que le “It works” du départ)?

Quitter le shell du container pour revenir dans celui de PuTTY en tapant soit Ctrl+D soit la commande exit
Stopper le container avec la commande :
```
docker stop apache-server (1)
# ou
docker stop a8ab349c84cf (2)
```
1 Arrêt du container à l’aide de son nom
2 Arrêt du container à l’aide de son id

Résultat :

john@docker-lab:~$ docker stop apache-server apache-server

Lister tous les containers, qu’il soient en cours d’exécution ou arrêtés :

docker ps -a
# ou
docker container ls -a

Résultat

john@docker-lab:~$ docker ps -a
CONTAINER ID   IMAGE            COMMAND              CREATED          STATUS                          PORTS     NAMES
a8ab349c84cf   httpd:bookworm   "httpd-foreground"   23 minutes ago   Exited (0) About a minute ago             apache-server (1)

On remarque dans la colonne STATUS que le container est “Exited” donc arrêté

Pour relancer un container arrêté, on peut utiliser la commande docker restart suivi de son nom ou de son id.

On va — à présent qu’il est arrêté — détruire le container que l’on a créé avec :

docker rm apache-server (1)

On peut aussi fournir l’identifiant du container à la place de son nom

Résultat :

john@docker-lab:~$ docker rm apache-server
apache-server

Pour détruire tous les containers arrêtés sans avoir à donner leur nom, on peut saisir la commande : docker container prune

On va à présent créer un volume Docker c’est-à-dire un emplacement sur la VM Debian hôte qui sera “mappé” dans le système de fichiers du container.

Ceci va nous permettre de fournir le code source d’un site web statique servi par le serveur web du container depuis un répertoire de la VM Debian. Cette façon de procéder permettra d’accéder au fichiers du site web même lorsque le container est arrêté.

Dans la VM Debian, créer un répertoire de travail my-static-website/ qui contiendra un sous-répertoire nommé htdocs/ (les noms de répertoire sont arbitraires…)
Résultat :
```
john@docker-lab:~$ mkdir -p my-static-website/htdocs (1)
john@docker-lab:~$ cd my-static-website
john@docker-lab:~/my-static-website$
```
1 Noter l’option -p de mkdir qui permet de créer une arborescence de répertoires en une seule commande.

Cloner un exemple de site web statique glané sur Github dans le répertoire htdocs/ de la VM Debian,

git clone https://github.com/devedium/SimpleClock.git htdocs/ (1)

1	`git` est la commande qui permet d’invoquer le système de contrôle de version Git qui est très largement pour la gestion de projets de développement logiciel, notamment par les forges logicielles telles que Github, GitLab, Framagit ….

Résultat

john@docker-lab:~/my-static-website$ git clone https://github.com/devedium/SimpleClock.git htdocs/
Clonage dans 'htdocs'...
remote: Enumerating objects: 6, done.
remote: Counting objects: 100% (6/6), done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 6 (delta 0), reused 6 (delta 0), pack-reused 0
Réception d'objets: 100% (6/6), fait.

Relancer le container httpd:bookworm mais en mappant cette fois-ci le répertoire htdocs/ de la VM Debian sur le répertoire /usr/local/apache2/htdocs du container

docker run -d --name apache-server -p 8080:80 -v ./htdocs/:/usr/local/apache2/htdocs/ httpd:bookworm (1)

1	C’est l’option `-v` qui permet de mapper les 2 répertoires l’un sur l’autre

Résultat

john@docker-lab:~/my-static-website$ docker run -d --name apache-server -p 8080:80 -v ./htdocs/:/usr/local/apache2/htdocs/ httpd:bookworm
048f36cd3a4153dc59ee3e609817aca649494f619c7bf92771a41b69ac0e1ee0

Rafraichir dans le navigateur la page web servie par le serveur web du container

⇒ Vous devez à présent voir une horloge qui se met à jour toutes les secondes

Suite au “mappage” des volumes, le serveur web du container sert effectivement le site web contenu dans la VM Debian (→ /home/john/my-static-website/htdocs) et non celui présent à l’origine dans le container (→ /usr/local/apache2/htdocs)

Stopper et détruire le container

docker stop apache-server
docker rm apache-server

Résultat :

john@docker-lab:~$ docker stop apache-server
apache-server
john@docker-lab:~$ docker rm apache-server
apache-server

💻 Travail n° 2 Personnalisation d’un container

Docker offre la possibilité de créer ses propres images par personnalisation d'images existantes.

Vous allez à présent construire une nouvelle image Docker qui intègrera d’origine le site web statique qui affiche l’horloge plutôt que de devoir le “mapper” à travers un volume.

🎯 Travail à faire :

Se déplacer dans le répertoire my-static-website de la VM Debian et y créer un fichier Dockerfile (en respectant la casse)
Résultat :
```
john@docker-lab:~$ cd ~/my-static-website/;touch Dockerfile (1)
```
1 enchaînement de commandes qui se déplace dans le répertoire my-static-website puis crée le fichier Dockerfile

L’ouvrir avec l’éditeur de texte nano et y copier le contenu suivant :

FROM httpd:bookworm (1)

COPY ./htdocs /usr/local/apache2/htdocs (2)

1	On spécifie l'image de départ
2	On indique les commandes à exécuter pour personnaliser l'image. Ici, on se contente de copier le contenu du site web statique présent dans le répertoire `./htdocs` de la VM Debian vers le répertoire /usr/local/apache2/htdocs du container

Construire la nouvelle image :

docker build -t my-httpd ~/my-static-website/ (1)

1	la commande s’appuie sur le fichier `Dockerfile` présent dans le répertoire spécifié en fin de commande pour créer une image qui s’appellera `my-httpd` (→ option `-t`, signifiant tag)

Résultat :

john@docker-lab:~/my-static-website$ docker build -t my-httpd ~/my-static-website/
[+] Building 0.3s (7/7) FINISHED                                                                                                           docker:default
 => [internal] load build definition from Dockerfile                                                                                                 0.0s
 => => transferring dockerfile: 98B                                                                                                                  0.0s
 => [internal] load .dockerignore                                                                                                                    0.0s
 => => transferring context: 2B                                                                                                                      0.0s
 => [internal] load metadata for docker.io/library/httpd:bookworm                                                                                    0.0s
 => [internal] load build context                                                                                                                    0.1s
 => => transferring context: 31.68kB                                                                                                                 0.0s
 => CACHED [1/2] FROM docker.io/library/httpd:bookworm                                                                                               0.0s
 => [2/2] COPY ./htdocs /usr/local/apache2/htdocs                                                                                                    0.1s
 => exporting to image                                                                                                                               0.0s
 => => exporting layers                                                                                                                              0.0s
 => => writing image sha256:9f850c7081bd546d70bd8f75a2eccac19a2bcb972b0440485ef539c56b71bf40                                                         0.0s
 => => naming to docker.io/library/my-httpd

Constater la présence d’une nouvelle image avec :

docker images

Résultat :

john@docker-lab:~/my-static-website$ docker images
REPOSITORY    TAG               IMAGE ID       CREATED          SIZE
my-httpd      latest            9f850c7081bd   51 seconds ago   168MB (1)
php           apache-bookworm   aa1a7b18157c   12 days ago      503MB
httpd         bookworm          359570977af2   3 weeks ago      168MB
mysql         latest            c138801544a9   2 months ago     577MB
hello-world   latest            9c7a54a9a43c   5 months ago     13.3kB

1	La nouvelle image créée apparait bien dans la liste des images disponibles

Lancer le container , sans mettre en place de volume, et constater que l’horloge s’affiche bien dans le navigateur après avoir rafraîchi la page :
```
docker run -d --name my-static-website -p 8080:80 my-httpd
```

Ouvrir un terminal dans le container et s’assurer que le code source du site web de l’horloge figure bien dans le répertoire /usr/local/apache2/htdocs

docker exec -it my-static-website bash
ls htdocs

Résultat :

john@docker-lab:~/my-static-website$ docker run -d --name my-static-website -p 8080:80 my-httpd
b7d06abcbd7a8ad42c6985bb2979446310c3363a9d2eaf6d3b7243e6e2dc0c63
john@docker-lab:~/my-static-website$ docker exec -it my-static-website bash
root@b7d06abcbd7a:/usr/local/apache2# ls htdocs/
README.md  index.html  site.css  site.js  (1)

1	le répertoire `/usr/local/apache2/htdocs/` du container contient bien les fichiers du site web qui affiche l’horloge

Quitter le shell du container avec Ctrl+D ou la commande exit

Stopper le container, le détruire ainsi que l'image personnalisée à partir de laquelle il a été créé.

docker stop my-static-website
docker rm my-static-website
docker rmi my-httpd (1)

1	C’est cette commande qui détruit l’image personnalisée

Résultat

john@docker-lab:~$ docker stop my-static-website
my-static-website
john@docker-lab:~$ docker rm my-static-website
my-static-website
john@docker-lab:~$ docker rmi my-httpd
Untagged: my-httpd:latest
Deleted: sha256:9f850c7081bd546d70bd8f75a2eccac19a2bcb972b0440485ef539c56b71bf40
john@docker-lab:~$ docker images (1)
REPOSITORY    TAG               IMAGE ID       CREATED        SIZE
php           apache-bookworm   aa1a7b18157c   12 days ago    503MB
httpd         bookworm          359570977af2   3 weeks ago    168MB
mysql         latest            c138801544a9   2 months ago   577MB
hello-world   latest            9c7a54a9a43c   5 months ago   13.3kB

1	L'image Docker `my-httpd` n’est effectivement plus présente

💻 Travail n° 3 Site web dynamique

Contrairement au 💻 Travail n° 1 Site web statique, vous allez ici mettre en œuvre une solution non pas avec 1 mais 2 containers Docker :

le 1^er container contiendra un serveur web Apache disposant d’un moteur PHP lui permettant d’interpréter les pages web incluant des instructions en langage PHP
le 2^ème proposera un serveur de base de données MySQL qui hébergera une base de données dans laquelle le site web viendra piocher ou écrire des données.

L'“orchestration” de ces 2 containers se fera depuis l’outil Docker Compose qui constitue une solution “simple” de mise en place d’application multi-containers

L’application multi-containers envisagée dans ce travail se résumera à une simple interface web de connexion à un site web fictif. Le code source de cette application sera récupérée sur Github (→ Registration-Login-and-Crud-in-PHP Public link )

L’application propose de s’inscrire sur le site web ou de s’y connecter. Ces 2 opérations occasionneront une consultation de la base de données (→ procédure de connexion) et une écriture dans celle-ci (→ procédure d’inscription).

🎯 Travail à faire :

Créer dans la VM un répertoire my-lamp-website et s’y déplacer. Ce répertoire contiendra lui-même les sous-répertoires app/, build/, build/mysql/ et build/php/

Résultat :

john@docker-lab:~$ mkdir my-lamp-website; cd $_ (1)
john@docker-lab:~/my-lamp-website$ mkdir -p app/ build/mysql build/php
john@docker-lab:~/my-lamp-website$

Noter l’astuce qui consiste à utiliser la variable $_ pour se rendre dans le répertoire qui a été créé par la commande précédente

L’abréviation lamp présente dans le nom du répertoire de travail est couramment utilisée pour désigner un système Linux / Apache / MySQL / PHP.

Créer un fichier docker-compose.yml et y ajouter le contenu suivant :

docker-compose.yml

version: "3.8"
services:
  php:
    ports:
      - "8080:80"
    build:
      context: './build/php'
    container_name: 'my-php-server'
    volumes:
      - ./app:/var/www/html
  mysql:
    ports:
      - "3306:3306"
    build:
      context: './build/mysql'
    container_name: 'my-mysql-server'
    environment:
      MYSQL_ROOT_PASSWORD: "yesUcan"
      MYSQL_DATABASE: "regdb"
    volumes:
      - ./app/db:/tmp/app-db
volumes:
  app:
  regdb:

Ce fichier décrit les containers (→ services) à mettre en place : ports, nom, volumes…

Personnaliser l'image Docker qui servira pour créer le container contenant le serveur Apache et le moteur PHP en créant un fichier Dockerfile dans ./build/php/. Y ajouter le contenu suivant :
./build/php/Dockerfile
```
FROM php:apache-bookworm

RUN apt-get update && \
   docker-php-ext-install mysqli pdo pdo_mysql (1)
```
1 télécharger et installer les modules PHP permettant d’interagir avec les bases de données MySQL
Personnaliser l'image Docker qui servira pour créer le container contenant le serveur MySQL en créant un fichier Dockerfile dans ./build/mysql/. Y ajouter le contenu suivant :
./build/mysql/Dockerfile
```
FROM mysql:latest
USER root
RUN chmod 755 /var/lib/mysql (1)
```
1 Changer les droits de /var/lib/mysql pour permettre à PHP de s’y connecter

Lancer les containers avec la commande docker compose up

La commande va construire les images Docker et les personnaliser. Ceci va mener au téléchargement de quelques fichiers et une procédure de lancement qui occasionne l’affichage d’un ensemble de messages y compris d’avertissements. Ne pas en tenir compte.

Résultat

john@docker-lab:~/my-lamp-website$ docker compose up
[+] Building 0.0s (4/4) FINISHED                                                                                                             docker:default
 => [php internal] load build definition from Dockerfile                                                                                               0.0s
 => => transferring dockerfile: 2B                                                                                                                     0.0s
 => [php internal] load .dockerignore                                                                                                                  0.0s
 => => transferring context: 2B

[...] (1)

my-mysql-server  | 2023-10-12T13:21:02.251098Z 0 [System] [MY-011323] [Server] X Plugin ready for connections. Bind-address: '::' port: 33060, socket: /var/run/mysqld/mysqlx.sock
my-mysql-server  | 2023-10-12T13:21:02.251199Z 0 [System] [MY-010931] [Server] /usr/sbin/mysqld: ready for connections. Version: '8.1.0'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  MySQL Community Server - GPL.

Dupliquer PuTTY afin d’avoir une 2^ème console dans laquelle vous allez pouvoir saisir des commandes : la 1^ère console ne vous a effectivement pas rendu la main car elle affiche des messages d’informations sur les services des containers.
Vous allez dans un 1^er temps vous assurer que le container Apache/PHP fonctionne correctement en vérifiant qu’il arrive à servir une page web simplissime construite avec PHP.

Créer dans le répertoire ./app de la VM Debian un fichier index.php avec le contenu suivant :
./app/index.php
```
<?php

echo 'Bonjour à toi, jeune padawan !';
```
Constater que la page web s’affiche lorsqu’on se rend sur l’URL du site (→ http://<adresse-ip-vm-debian>:8080)

Détruire le répertoire app/ pour le remplacer par le code source PHP/HTML/JS/CSS du site proposant l’interface d’inscription/connexion à un site web.

Ce code source est récupéré, comme dans le travail précédent, depuis un dépôt Github.

rm -rf app/
git clone https://github.com/mohibulkhan786/Registration-Login-and-Crud-in-PHP.git ./app

Résultat :

john@docker-lab:~/my-lamp-website$ rm -Rf app/
john@docker-lab:~/my-lamp-website$ git clone https://github.com/mohibulkhan786/Registration-Login-and-Crud-in-PHP.git ./app
Clonage dans './app'...
remote: Enumerating objects: 53, done.
remote: Counting objects: 100% (53/53), done.
remote: Compressing objects: 100% (47/47), done.
remote: Total 53 (delta 3), reused 53 (delta 3), pack-reused 0
Réception d'objets: 100% (53/53), 1.12 Mio | 2.19 Mio/s, fait.
Résolution des deltas: 100% (3/3), fait.

Se connecter au serveur MySQL depuis un client lancé depuis le shell du container :

docker exec -ti my-mysql-server bash (1)
mysql -uroot -pyesUcan (2)

1	Lancer un shell dans le container
2	lancer le client `mysql` en fournissant les identifiants renseignés dans le fichier `docker-compose.yml` (→ `MYSQL_ROOT_PASSWORD`)

puis…

vérifier la présence d’une base de données nommée regdb (créée à partir des instructions du fichier docker-compose.yml → MYSQL_DATABASE)

show databases; (1)

1	liste les bases de données gérées par `MySQL`

Résultat :

mysql> show databases;  (1)
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| regdb              | (2)
| sys                |
+--------------------+
5 rows in set (0.01 sec)

1	On liste les bases de données
2	La base de données `regdb` est bien présente

créer les tables de cette base de données et les renseigner avec quelques données de départ grâce aux instructions SQL se trouvant dans le fichier ./app/db/db_php_crud.sql

use regdb (1)
source /tmp/app-db/db_php_crud.sql (2)

1	sélectionne la base de données `regdb`
2	joue les commandes SQL présentes dans `/tmp/app-db/db_php_crud.sql` pour intialiser et pré-remplir les tables de la base de données `regdb`

Résultat :

mysql> use regdb  (1)
Database changed

mysql> source /tmp/app-db/db_php_crud.sql  (2)
Query OK, 0 rows affected (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

[...]

Query OK, 0 rows affected (0.00 sec)

mysql> exit  (3)
Bye
bash-4.4# exit
john@docker-lab:~/my-lamp-website$

1	On sélectionne la base de données `regdb`
2	On crée les tables de la bdd et on les pré-remplit
3	On quitte le client `mysql`

Si le peuplement de la base de données avec la commande source échoue avec un message d’erreur indiquant que le fichier db_php_crud.sql est manquant :

Détruire les containers et les réseaux entre ceux-ci : docker compose down
Détruire les images des containers : docker rmi my-lamp-website-mysql:latest my-lamp-website-php:latest
Reprendre la procédure de mise en place des containers c’est-à-dire à partir de l’étape n°5 : docker compose up

Modifier enfin le fichier ./app/config.php pour y mettre à jour les informations de connexion à la base de données

Remplacer :
```
$con=mysqli_connect("localhost", "root", "", "db_php_crud");
```
Par :
```
$con=mysqli_connect("my-mysql-server", "root", "yesUcan", "regdb");
```
Rafraîchir la page du navigateur et constater qu’un formulaire d’inscription s’affiche et qu’il est possible de s’inscrire puis de se connecter au site

On peut alors vérifier que les informations saisies se retrouvent dans la base de données regdb

Résultat :

john@docker-lab:~/my-lamp-website$ docker exec -it my-mysql-server bash (1)
bash-4.4# mysql -uroot -pyesUcan (2)
[...]
mysql> use regdb  (3)
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show tables;  (4)
+-----------------+
| Tables_in_regdb |
+-----------------+
| tbluser         |
| tblusers        |
+-----------------+
2 rows in set (0.00 sec)

mysql> SELECT * FROM tbluser;  (5)
+----+-----------------+--------------+--------------------------+----------------------------------+---------------------+
| ID | FullName        | MobileNumber | Email                    | Password                         | RegDate             |
+----+-----------------+--------------+--------------------------+----------------------------------+---------------------+
|  5 | Armaan khan     |   7007192298 | armaan@gmail.com         | bc11f06afb9b27070673471a23ecc6a9 | 2021-04-24 15:58:30 |
|  6 | mkhan           |   7007192297 | mkhan15992@gmail.com     | bc11f06afb9b27070673471a23ecc6a9 | 2021-04-24 17:30:03 |
|  7 | aaaaa           |   1111111111 | a@gmail.cm               | 3dbe00a167653a1aaee01d93e77e730e | 2021-04-25 18:20:59 |
|  8 | John DOE        |    612345678 | john.doe@acme.com        | 527bd5b5d689e2c32ae974c6229ff785 | 2023-10-12 15:11:27 |  (6)
|  9 | Gérard MANVUSSA |    687654321 | gerard.manvussa@acme.com | 64d8be661d8a79416eb6662db51e7118 | 2023-10-12 15:17:37 |  (6)
+----+-----------------+--------------+--------------------------+----------------------------------+---------------------+
5 rows in set (0.00 sec)

mysql> exit  (7)
Bye
bash-4.4# exit (8)
exit
john@docker-lab:~/my-lamp-website$

1	On lance un shell dans le container MySQL
2	On exécute le client MySQL
3	On sélectionne la base de données `regdb`
4	On liste les tables de de la base de données `regdb`
5	On exécute une requête SQL qui affiche le contenu de la table `tbluser`
6	On vérifie de bien retrouver les utilisateurs que l’on a inscrits
7	On quitte le client `mysql`
8	On quitte le shell du container

💻 Travail n° 4 Évolution du site dynamique

Dans ce travail, on vous demande de faire évoluer l’architecture de l’application du travail précédent pour y intégrer un conteneur phpMyAdmin pour permettre d’administrer la base de données via une interface web.

Pour cela, vous allez devoir :

supprimer les images Docker créées dans le travail précédent
récupérer l’image Docker de phpMyAdmin
modifier le fichier docker-compose.yml pour y spécifier les instructions pour lancer le conteneur phpMyAdmin.
Vous rendrez accessible phpMyAdmin sur le port 8081 de l’hôte.

Une image Docker peut être chargée dans la VM Linux via la commande docker image load. Se référer à la documentation officielle de cette commande pour plus de détails.
Une image de phpMyAdmin est disponible dans le répertoire Docker du NAS du labo dans le fichier phpmyadmin.tar.gz pour éviter d’avoir à la télécharger depuis internet (taille d’environ 500Mo tout de même…)
Se référer à la description de l’image de phpMyAdmin sur le Docker Hub pour déterminer comment l’utiliser.
Vous serez particulièrement attentif à la variable d’environnement PMA_HOST.

🎯 Travail à faire :

Mettre en place les conteneurs en respectant les contraintes exposées dans la présentation de ce travail
Ajouter des nouveaux utilisateurs dans la base données sans passer par le formulaire d’inscription de l’interface web de l’application.

Vous pourrez par exemple utiliser l’application Cyberchef — disponible sur le NAS — pour générer le hash MD5 des mots de passe.
Vérifier que les utilisateurs nouvellement créés peuvent se connecter depuis le formulaire de connexion de l’application web

💻 Travail n° 5 Réinitialisation

Vous allez ici remettre la VM Linux dans son état initial pour permettre si besoin est de reprendre cet atelier de découverte de Docker depuis le début.

🎯 Travail à faire :

Stopper les containers, et le réseau les reliant, puis détruire les images Dockers correspondantes et enfin, détruire les répertoires de la VM Linux créés durant l’atelier pour revenir à l’état initial.
```
john@docker-lab:~/my-lamp-website$ docker compose down (1)
[...]
john@docker-lab:~/my-lamp-website$ docker rmi my-lamp-website-mysql:latest my-lamp-website-php:latest (2)
[...]
john@docker-lab:~/my-lamp-website$ rm -Rf ~/my-lamp-website/ ~/my-static-website/ (3)
```
1 Arrêt des containers

2 Suppression des images Docker

3 Suppression des répertoires de la VM créés durant l’atelier

Conclusion

Dans cette activité, vous avez déployé des containers Docker pour mettre en place :

un site web statique ne nécessitant qu’un seul container
un site web dynamique reposant sur l’utilisation de 2 containers

Par le biais des personnalisations des images Docker, le site web dynamique aurait très bien pu ne reposer que sur un seul container. Sur le terrain, ce choix doit être pris par l’architecte de l’application en fonction des contraintes qui lui sont imposées par le client (performance, occupation mémoire, sécurité…).

Cette activité a illustré mais n’a pas couvert les détails de la communication entre containers. Il y aurait eu trop de choses à dire …

Docker est outil puissant dont vous n’avez survolé que quelques possibilités.

Docker n’est pas la seule application à proposer la “conteneurisation” d’applications (ex. Apache Mesos).

C’est une technologie plutôt récente qui a été largement adoptée dans les entreprises. Il est donc nécessaire d’en avoir connaissance et de savoir, même partiellement, la mettre en œuvre.

🞄 🞄 🞄

1	Arrêt du container à l’aide de son nom
2	Arrêt du container à l’aide de son id Résultat : `john@docker-lab:~$ docker stop apache-server apache-server`

1	Arrêt des containers
2	Suppression des images Docker
3	Suppression des répertoires de la VM créés durant l’atelier