Rapport du Docker 101 Tutorial

Réaliser par: ZEMRANI Othmane

Encadrer par: NATEK Hamza

Introduction
Docker est une plateforme de conteneurisation qui permet de créer, déployer et exécuter des
applications dans des environnements isolés appelés conteneurs.
Il facilite le déploiement des applications en garantissant qu’elles fonctionnent de la même
manière, quel que soit le système sur lequel elles sont exécutées.

L’objectif principal de Docker est de simplifier le développement, améliorer la portabilité et

réduire les problèmes liés aux différences d’environnement.

Getting Started
Lancement du premier conteneur

La première étape du tutoriel consiste à lancer un conteneur Docker afin de vérifier que Docker
fonctionne correctement sur la machine.

Commande utilisée :

docker run -d -p 80:80 docker/getting-started

Explication de la commande :

docker run : crée et démarre un conteneur

-d : exécute le conteneur en arrière-plan (mode détaché)

-p 80:80 : mappe le port 80 de la machine hôte vers le port 80 du conteneur

docker/getting-started : image Docker utilisée

Our Application
L’application utilisée dans ce tutoriel est une application web de gestion de tâches (Todo List)
développée en [Link].
Elle permet :

d’ajouter des tâches

de les marquer comme terminées
de les supprimer

L’objectif est de démontrer comment conteneuriser une application simple pour valider un MVP
(Minimum Viable Product).

Récupération du code source :

Le code est fourni sous forme d’archive ZIP contenant :

[Link]
dossier src
dossier spec

Le projet est ouvert dans un éditeur de code (Visual Studio Code).

Building the App's Container Image

Dockerfile est simplement un script d'instructions basé sur du texte utilisé pour créer une image
de conteneur.

Starting an App Container

Start my container by using the docker run command

docker run -dp 3000:3000 getting-started
Updating our App
Une modification est demandée sur le texte affiché lorsque la liste de tâches est vide.

Modification du fichier :

src/static/js/[Link]

Changement effectué :

- No items yet! Add one above!

+ You have no todo items yet! Add one above!

Après modification du code, l’image Docker doit être reconstruite afin d’intégrer les
changements.

Reconstruction de l’image :

docker build -t getting-started .

Lors du redémarrage, une erreur apparaît car le port 3000 est déjà utilisé par l’ancien conteneur.

Résolution du problème :

docker ps => pour obtenir l’ID du conteneur

docker stop <container-id> => pour arrêter le conteneur

docker rm <container-id> => pour supprimer le conteneur

Puis relancer le conteneur mis à jour :

docker run -dp 3000:3000 getting-started

Sharing our App
Une fois l’image Docker créée, elle peut être partagée via un registre Docker, notamment Docker
Hub.

Cela permet à d’autres utilisateurs ou serveurs de télécharger et d’exécuter l’application.

Étapes principales :

Création d’un dépôt public sur Docker Hub

Connexion au registre
Attribution d’un nouveau tag à l’image

Publication de l’image

Commandes utilisées :

docker login

docker tag getting-started USERNAME/getting-started

docker push USERNAME/getting-started

Persisting our DB
The Container's Filesystem
Container Volumes

Par défaut, toutes les données sont perdues lorsque le conteneur est supprimé.
L’application Todo utilise une base de données SQLite stockée dans le fichier :

/etc/todos/[Link]

Pour conserver les données, Docker fournit les volumes.

Création d’un volume nommé :

docker volume create todo-db

Lancement du conteneur avec persistance :

docker run -dp 3000:3000 -v todo-db:/etc/todos getting-started

Grâce à ce volume :

Les données sont conservées après redémarrage

Les tâches restent disponibles même après suppression du conteneur

Vérification du volume :

docker volume inspect todo-db

Using Bind Mounts
Objectif

Les bind mounts permettent de lier un répertoire de la machine hôte directement à un

répertoire à l’intérieur d’un conteneur Docker.

Cette technique est particulièrement utile lors du développement d’une application.

Les avantages principaux des bind mounts sont :

Les modifications du code effectuées sur la machine hôte sont immédiatement visibles dans le
conteneur.

Il n’est pas nécessaire de reconstruire l’image Docker après chaque changement.

Le développement et le débogage sont plus rapides et plus efficaces.

Commande utilisée

Dans ce tutoriel, le bind mount est utilisé pour monter l’intégralité du code source de
l’application dans le conteneur Docker :

docker run -dp 3000:3000 -w /app -v "$(pwd):/app" node:18-alpine sh -c "yarn install && yarn run
dev"

Explication détaillée de la commande

docker run : Crée et démarre un nouveau conteneur Docker.

-d : Lance le conteneur en arrière-plan (mode détaché).

-p 3000:3000 : Mappe le port 3000 de la machine hôte vers le port 3000 du conteneur afin
d’accéder à l’application via le navigateur.

-w /app : Définit le répertoire de travail à /app à l’intérieur du conteneur.

-v "$(pwd):/app" : Crée un bind mount entre le répertoire courant de la machine hôte (contenant
le code source) et le répertoire /app dans le conteneur.

Toute modification du code local est immédiatement reflétée dans le conteneur.

node:18-alpine : Image Docker utilisée, basée sur [Link] 18 avec une distribution Alpine légère.

sh -c "yarn install && yarn run dev" : yarn install : installe toutes les dépendances du projet

yarn run dev : démarre l’application en mode développement avec nodemon, qui redémarre
automatiquement le serveur en cas de modification des fichiers

Multi-Container Apps
Introduction

Jusqu’à présent, l’application Todo fonctionnait dans un seul conteneur Docker.

Cependant, pour des applications plus réalistes et évolutives, il est nécessaire de séparer les
composants de l’application.

Dans cette étape, une base de données MySQL est ajoutée à l’architecture.

Création du réseau Docker

docker network create todo-app

Ce réseau permettra aux conteneurs de se découvrir et de communiquer entre eux.

Démarrage du conteneur MySQL

Le conteneur MySQL est lancé en étant directement connecté au réseau todo-app.

docker run -d --network todo-app --network-alias mysql -v todo-mysql-data:/var/lib/mysql \

-e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=todos mysql:8.0

Explication des options :

--network todo-app : connecte le conteneur au réseau Docker

--network-alias mysql : donne le nom mysql au conteneur sur le réseau

-v todo-mysql-data:/var/lib/mysql : volume pour persister les données MySQL

MYSQL_ROOT_PASSWORD : mot de passe root

MYSQL_DATABASE : base de données créée automatiquement

mysql:8.0 : image MySQL utilisée

Vérification du fonctionnement de MySQL

Connexion au conteneur MySQL :

docker exec -it <mysql-container-id> mysql -p

Mot de passe: secret

Afficher les bases de données : SHOW DATABASES;

Découverte du conteneur via le réseau (DNS Docker)

Pour vérifier la communication réseau, un conteneur de test est utilisé.

Dans ce conteneur, on teste la résolution DNS :
Using Docker Compose
Docker Compose est un outil qui permet de définir, configurer et exécuter des applications
multi-conteneurs de manière simple et centralisée à l’aide d’un fichier [Link].

Il est particulièrement utile lorsque l’application repose sur plusieurs services, comme une
application web et une base de données.

Dans ce projet, Docker Compose a été utilisé pour gérer une architecture composée de
deux conteneurs distincts :

une application [Link]

une base de données MySQL

Le fichier [Link] permet de décrire l’ensemble de la stack applicative,

notamment :

Les images Docker utilisées pour chaque service

Les ports exposés pour accéder à l’application

Les volumes assurant la persistance des données de la base MySQL

Les variables d’environnement nécessaires à la connexion entre l’application et la base de

données

Docker Compose crée automatiquement un réseau privé pour l’application. Grâce à ce réseau,
les services peuvent communiquer entre eux en utilisant simplement le nom du service (par
exemple mysql), sans avoir besoin de connaître l’adresse IP du conteneur.

Le lancement de l’application complète se fait avec une seule commande :

docker compose up -d

Cette commande démarre simultanément tous les services définis dans le fichier de
configuration.

Les logs de chaque conteneur peuvent être consultés facilement à l’aide de :

docker compose logs -f

Lorsque l’application n’est plus nécessaire, l’arrêt de l’ensemble de la stack se fait

simplement avec :
docker compose down

Les conteneurs et le réseau sont alors supprimés, tandis que les volumes peuvent être
conservés pour préserver les données.

Image Building Best Practices

Analyse de sécurité des images (Security Scanning)

Après la création d’une image Docker, il est recommandé de la scanner pour détecter les
vulnérabilités de sécurité. Docker propose la commande docker scan, basée sur le service Snyk,
qui utilise une base de données de failles constamment mise à jour.

Commande utilisée :

docker scan getting-started

Le résultat du scan affiche :

le niveau de gravité (Low, Medium, High),

la description de la vulnérabilité,
le package concerné,
Et la version corrigée.

Cette étape permet d’anticiper les risques de sécurité avant le déploiement en production. Il est
aussi possible d’activer le scan automatique sur Docker Hub lors du push des images.

Comprendre les couches d’une image Docker (Image Layering)

Chaque instruction du Dockerfile crée une couche (layer) dans l’image. À l’aide de la commande
suivante, on peut visualiser la structure complète de l’image :

docker image history getting-started

Chaque couche correspond à une instruction (FROM, COPY, RUN, etc.) et possède une taille
spécifique. Cette analyse permet d’identifier les couches les plus lourdes et d’optimiser l’image
finale.

Optimisation avec le cache Docker (Layer Caching)

Pour améliorer les performances, le Dockerfile a été restructuré afin de :

Copier d’abord [Link] et [Link],

Installer les dépendances,
Puis copier le reste du code source.

Dockerfile optimisé :

FROM node:18-alpine

WORKDIR /app

COPY [Link] [Link] ./

RUN yarn install --production

COPY . .

CMD ["node", "src/[Link]"]

Un fichier .dockerignore est également utilisé pour exclure node_modules, évitant ainsi des
copies inutiles.

Résultat :

Builds beaucoup plus rapides,

Meilleure utilisation du cache,
Images plus légères.

Multi-Stage Builds

Les multi-stage builds permettent d’utiliser plusieurs images dans un seul Dockerfile afin de :

séparer les dépendances de build et d’exécution,

réduire considérablement la taille finale de l’image,
Améliorer la sécurité.

Exemples abordés :

Java (Maven + Tomcat) : compilation dans une image Maven, exécution dans Tomcat.
React : build avec [Link], puis déploiement des fichiers statiques dans Nginx.

Cette approche est idéale pour les applications modernes.

Conclusion
Après avoir installé et configuré l’ensemble des dépendances pour notre projet [Link], nous
avons procédé à une vérification approfondie de leur sécurité et de leur compatibilité. Les
étapes principales ont été :

Installation des paquets essentiels (mysql2, @babel/traverse, tar, express, sqlite3, uuid, wait-
port) avec leurs versions stables.
Résolution des vulnérabilités de sécurité détectées via npm audit et mise à jour de tar vers
la version sécurisée 7.5.9.
Utilisation des commandes npm audit fix et npm audit fix --force pour corriger
automatiquement les failles sans casser les dépendances critiques.
Vérification finale via npm audit, confirmant qu’aucune vulnérabilité n’est présente et que
toutes les dépendances sont à jour.

Cette gestion rigoureuse des dépendances garantit que le projet est stable, sécurisé et prêt pour
un déploiement ou un développement futur sans risques connus liés aux bibliothèques
externes.