Introduction

Dans cette quête, tu vas explorer un des fondements de Docker : La construction d'images. Jusqu'à présent lorsque tu as utilisé Docker, tu t'es servi d'images préexistantes. Cette quête va te permettre de personnaliser ces images pour créer tes propres images à l'aide d'un fichier Dockerfile.

🤓 Objectifs :

✅ Apprendre à créer, gérer et utiliser des images Docker à l'aide de Dockerfile. ✅ Explorer les bonnes pratiques pour la construction des Dockerfiles.

Sommaire

:point_right: Rappel sur les images et les layers

Les images sont les éléments fondamentaux de l'écosystème Docker, servant de blocs de construction pour les conteneurs. Elles encapsulent l'ensemble des dépendances nécessaires à l'exécution d'une application, fournissant ainsi un environnement isolé et reproductible.

Quelques commandes utiles :

wilder@docker1:~$ docker search ubuntu
NAME                             DESCRIPTION                                     STARS     OFFICIAL
ubuntu                           Ubuntu is a Debian-based Linux operating sys…   16978     [OK]
ubuntu-debootstrap               DEPRECATED; use "ubuntu" instead                52        [OK]
open-liberty                     Open Liberty multi-architecture images based…   64        [OK]
neurodebian                      NeuroDebian provides neuroscience research s…   107       [OK]
websphere-liberty                WebSphere Liberty multi-architecture images …   298       [OK]
ubuntu-upstart                   DEPRECATED, as is Upstart (find other proces…   115       [OK]
ubuntu/nginx                     Nginx, a high-performance reverse proxy & we…   112
ubuntu/squid                     Squid is a caching proxy for the Web. Long-t…   88
...

wilder@docker1:~$ docker pull ubuntu
Using default tag: latest
latest: Pulling from library/ubuntu
bccd10f490ab: Pull complete
Digest: sha256:77906da86b60585ce12215807090eb327e7386c8fafb5402369e421f44eff17e
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest

wilder@docker1:~$ docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
alpine_bash           v1.0      e45510103845   18 hours ago    11.6MB
debian-figlet         latest    87e76ac3c1c8   2 weeks ago     138MB
debian                latest    c978d997d5fe   3 weeks ago     117MB
wordpress             latest    1906608f01fe   3 weeks ago     737MB
ubuntu                latest    ca2b0f26964c   5 weeks ago     77.9MB
nginx                 latest    92b11f67642b   7 weeks ago     187MB
alpine                latest    05455a08881e   2 months ago    7.38MB
mysql                 5.7       5107333e08a8   3 months ago    501MB
busybox               latest    ba5dc23f65d4   10 months ago   4.26MB

# Supprimer une image par son nom et sa balise
wilder@docker1:~$ docker rmi ubuntu:latest
Untagged: ubuntu:latest
Untagged: ubuntu@sha256:77906da86b60585ce12215807090eb327e7386c8fafb5402369e421f44eff17e
Deleted: sha256:ca2b0f26964cf2e80ba3e084d5983dab293fdb87485dc6445f3f7bbfc89d7459
Deleted: sha256:5498e8c22f6996f25ef193ee58617d5b37e2a96decf22e72de13c3b34e147591

# Supprimer une image par son ID
wilder@docker1:~$ docker rmi ca2b0f26964c
Untagged: ubuntu:latest
Untagged: ubuntu@sha256:77906da86b60585ce12215807090eb327e7386c8fafb5402369e421f44eff17e
Deleted: sha256:ca2b0f26964cf2e80ba3e084d5983dab293fdb87485dc6445f3f7bbfc89d7459
Deleted: sha256:5498e8c22f6996f25ef193ee58617d5b37e2a96decf22e72de13c3b34e147591

:point_right: Créer une image Docker

L'une des pratiques les plus fondamentales et puissantes avec Docker est la capacité de créer tes propres images personnalisées.

Lorsque tu envisages de créer ta propre image Docker, tu as deux options principales :

• Transformer un conteneur existant en une image Docker
• Rédiger un fichier Dockerfile pour définir les étapes de construction de votre image.

:point_right: Le Dockerfile

Qu'est-ce qu'un Dockerfile

Un Dockerfile est un fichier texte simple qui contient une série d'instructions permettant de décrire les étapes nécessaires à la construction d'une image Docker. Il agit comme un script de construction pour générer automatiquement une image Docker complète et prête à être utilisée.

Tu pourrais partir de zéro pour construire une image (from scratch), mais généralement, tu te base sur une image déjà existante.

Structure d'un Dockerfile

Un Dockerfile est composé d'un ensemble d'instructions, chaque instruction étant une étape distincte dans le processus de construction de l'image. Il est important de noter que chaque instruction est écrite en lettre majuscule, suivie de l'argument en minuscule.

Voici un exemple de structure typique d'un Dockerfile

# Syntaxe de commentaire : tout ce qui suit un '#' est ignoré  
# Étape 1 : Sélection de l'image de base 
FROM ubuntu:latest  
# Étape 2 : Mise à jour des packages et installation des dépendances 
RUN apt-get update && apt-get install -y package1 package2 package3  
# Étape 3 : Copie des fichiers de l'hôte dans l'image 
COPY /chemin/local /chemin/destination  
# Étape 4 : Exécution de commandes lors du lancement du conteneur 
CMD ["commande", "argument1", "argument2"]`

Principales instructions Dockerfile

• FROM : Spécifie l'image de base à utiliser pour construire l'image. Cette instruction est obligatoire et doit figurer en haut du Dockerfile.

• RUN : Exécute des commandes dans l'image en cours de construction. Ces commandes peuvent être des mises à jour du système, des installations de logiciels, etc.

• COPY : Copie des fichiers depuis l'hôte dans l'image. Utile pour inclure des fichiers de configuration, des scripts, etc.

• CMD : Définit la commande par défaut à exécuter lors du lancement du conteneur à partir de l'image. Il ne peut y avoir qu'une seule instruction CMD dans un Dockerfile, bien que tu puisses spécifier plusieurs arguments.

D'autres instructions comme EXPOSE, WORKDIR, ENV, ENTRYPOINT, etc., permettent de définir des ports à exposer, le répertoire de travail par défaut, des variables d'environnement, le programme de base avec lequel sera lancé la commande, etc.

Exemple de Dockerfile

Voici un exemple de Dockerfile pour créer une image Docker d'une base de données PostgreSQL :

# Utiliser l'image officielle PostgreSQL en tant qu'image de base 
FROM postgres:latest  
# Définir les variables d'environnement pour le nom de l'utilisateur PostgreSQL et le mot de passe 
ENV POSTGRES_USER myuser 
ENV POSTGRES_PASSWORD mypassword  
# Créer une base de données par défaut lors du démarrage du conteneur 
ENV POSTGRES_DB mydatabase  
# Exposer le port par défaut de PostgreSQL 
EXPOSE 5432

Dans cet exemple :

• On utilise l'image officielle de PostgreSQL comme image de base, avec la dernière version disponible.
• Nous définissons les variables d'environnement POSTGRES_USER, POSTGRES_PASSWORD et POSTGRES_DB pour spécifier le nom d'utilisateur, le mot de passe et le nom de la base de données à créer par défaut lors du démarrage du conteneur.
• Nous exposons le port par défaut de PostgreSQL, qui est 5432.

Construire une image d'après le Dockerfile

Pour construire une image Docker à partir d'un Dockerfile, utilise la commande docker build.

Voici comment cela fonctionne

1. 1

   Step 1

   Assure toi que tu es dans le répertoire contenant ton Dockerfile.

2. 2

   Step 2

   Utilise la commande docker build avec le chemin vers le répertoire contenant ton Dockerfile.

   Par exemple :

   docker build -t nom_image:tag .

   Dans cette commande :

   • -t nom_image:tag permet de spécifier le nom et la version (tag) de ton image Docker. Tu peux choisir le nom que tu souhaites pour l'image, ainsi qu'une version spécifique si nécessaire.
   • Le . à la fin de la commande indique que le Dockerfile se trouve dans le répertoire actuel, il s'agit du contexte.

   Info

   L'utilisation appropriée des tags lors de la construction d'une image Docker est essentielle pour garantir la cohérence et la traçabilité de tes images dans un environnement professionnel. Les tags permettent d'identifier de manière unique une version spécifique des images, ce qui facilite la gestion des différentes versions des applications ou des services.

3. 3

   Step 3

   Docker va alors lire les instructions du Dockerfile, les exécuter séquentiellement et créer une nouvelle image Docker basée sur ces instructions. Une fois que le processus de construction est terminé, Docker affichera un message indiquant que l'image a été construite avec succès.

Par exemple, pour le Dockerfile suivant :

wilder@docker1:~/mon_projet_docker$ cat Dockerfile
FROM ubuntu:latest
RUN apt update && apt install python3 -y

Voici la sortie que tu peux voir lors de la construction de l'image :

wilder@docker1:~/mon_projet_docker$ docker build -t mon_ubuntu_perso:V1.0 .
[+] Building 25.6s (6/6) FINISHED                                                                docker:default
 => [internal] load build definition from Dockerfile                                                       0.0s
 => => transferring dockerfile: 97B                                                                        0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest                                           0.0s
 => [internal] load .dockerignore                                                                          0.0s
 => => transferring context: 2B                                                                            0.0s
 => CACHED [1/2] FROM docker.io/library/ubuntu:latest                                                      0.0s
 => [2/2] RUN apt update && apt install python3 -y                                                        24.4s
 => exporting to image                                                                                     1.1s
 => => exporting layers                                                                                    1.1s
 => => writing image sha256:74a2de4928f861a5d8d83bb059343ce23bc117d983da3eab6ccd2cd34fe2e2a9               0.0s
 => => naming to docker.io/library/mon_ubuntu_perso:V1.0                                                   0.0s

Une fois que ton image est construite, tu peux la voir répertoriée en utilisant la commande docker images.

wilder@docker1:~/mon_projet_docker$ docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
mon_ubuntu_perso      V1.0      74a2de4928f8   6 seconds ago   158MB
ubuntu                latest    ca2b0f26964c   5 weeks ago     77.9MB

Publier des images vers un registre

Pour partager tes images Docker avec d'autres utilisateurs ou pour les utiliser sur d'autres systèmes, tu peux les publier vers un registre Docker.

Avantages de l'utilisation d'un Dockerfile

• Reproductibilité : En utilisant un Dockerfile, tu peux garantir que chaque membre de ton équipe utilise la même configuration pour construire l'image, assurant ainsi la reproductibilité du processus.

• Transparence : Le Dockerfile agit comme une documentation vivante du processus de construction de l'image, offrant une transparence totale sur les étapes impliquées.

• Flexibilité : Tu peux facilement personnaliser le processus de construction en ajoutant, supprimant ou modifiant des instructions dans le Dockerfile pour répondre aux besoins spécifiques de ton application.

:point_right: Ton premier Dockerfile

Maintenant que nous avons couvert les bases, je te propose de créer ta première image Docker d'un serveur web Nginx. Cette image aura une page d'accueil personnalisée qui sera servie depuis l'hôte Docker.

On pourrait obtenir un conteneur fonctionnel qui répond à notre besoin en utilisant plusieurs commandes ad-hoc, en ayant pris soin préalablement de créer notre fichier à destination du serveur web nginx.

Les commandes pourraient ressembler à ceci :

# Vérification du contenu du fichier index.html de l'hôte :
wilder@docker1:~$ cat index.html
<h1>Bienvenue sur mon serveur Nginx !</h1>

# Création du conteneur :
wilder@docker1:~$ docker run -d -p 80:80 --name mon-nginx nginx:latest
ed78fb64ca1dec6ae66ffb26a8e66221d71f52f0ca3b259cea0e93a1c447e926

# Copie du fichier index.html de l'hôte vers le conteneur :
wilder@docker1:~$ docker cp index.html mon-nginx:/usr/share/nginx/html/index.html

Notre conteneur est bien fonctionnel et joignable sur le port 80 de l'hôte :

wilder@docker1:~$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                               NAMES
ed78fb64ca1d   nginx:latest   "/docker-entrypoint.…"   9 seconds ago   Up 8 seconds   0.0.0.0:80->80/tcp, :::80->80/tcp   mon-nginx

wilder@docker1:~$ curl 127.0.0.1:80
<h1>Bienvenue sur mon serveur Nginx !</h1>

Ces commandes ad-hoc permettent d'arriver à un résultat similaire à ce que l'on souhaite faire, sauf que l'on dispose d'un conteneur, et non pas d'une image.

Nous allons réaliser une image qui réponde à notre besoin.

On peut découper les commandes ad-hoc précédentes en différentes instructions :

• L'image de base utilisée : nginx:latest
• La copie du fichier index.html de l'hôte vers le conteneur
• L'exposition du port 80 du conteneur sur le port 80 de l'hôte Docker

Avant de commencer à écrire ton Dockerfile, tu dois organiser ton projet et créer un dossier dédié pour ton application Docker.

wilder@docker1:~$ mkdir mon_projet_docker
wilder@docker1:~$ cd mon_projet_docker
wilder@docker1:~/mon_projet_docker$ touch Dockerfile

Tu devras aussi créer le fichier index.html à l'intérieur de ton dossier de projet.

wilder@docker1:~/mon_projet_docker$ cat index.html
<h1>Bienvenue sur mon serveur Nginx cree a partir de mon image !!!!</h1>

La structure de ton dossier ressemblera à ceci :

wilder@docker1:~$ tree
.
├── mon_projet_docker
    └── Dockerfile
    └── index.html

Tu es maintenant prêt à commencer à rédiger les instructions de ton Dockerfile pour définir le processus de construction de ton image Docker.

Tu peux ouvrir le fichier Dockerfile dans ton éditeur de texte et commencer à écrire tes instructions Docker.

wilder@docker1:~/mon_projet_docker$ nano Dockerfile

1. 1

   Step 1 - FROM

   Utilisation de l'image officielle Nginx

   bash

   FROM nginx:latest
   

2. 2

   Step 2 - COPY

   Copie du fichier index.html local vers le répertoire de configuration Nginx dans l'image

   bash:2

   COPY index.html /usr/share/nginx/html
   

3. 3

   Step 3

   Exposer le port 80 pour le trafic web

   bash:3

   EXPOSE 80
   

Notre fichier Dockerfile :

# Utilisation de l'image officielle Nginx
FROM nginx:latest

# Copie du fichier index.html local vers le répertoire de configuration Nginx dans l'image
COPY index.html /usr/share/nginx/html

# Exposer le port 80 pour le trafic web
EXPOSE 80

Il ne nous reste plus qu'a créer notre image :

# Build de notre image :
wilder@docker1:~/mon_projet_docker$ docker build -t mon-nginx:v1.0 .
[+] Building 0.1s (7/7) FINISHED                                                                                                                docker:default
 => [internal] load build definition from Dockerfile                                                                                                      0.0s
 => => transferring dockerfile: 282B                                                                                                                      0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                                                           0.0s
 => [internal] load .dockerignore                                                                                                                         0.0s
 => => transferring context: 2B                                                                                                                           0.0s
 => [internal] load build context                                                                                                                         0.0s
 => => transferring context: 495B                                                                                                                         0.0s
 => [1/2] FROM docker.io/library/nginx:latest                                                                                                             0.0s
 => [2/2] COPY index.html /usr/share/nginx/html                                                                                                           0.0s
 => exporting to image                                                                                                                                    0.0s
 => => exporting layers                                                                                                                                   0.0s
 => => writing image sha256:b160a8d1a401f7fbaff10daa3dc06ea44a0945ce0372ead5b8432bde24523e44                                                              0.0s
 => => naming to docker.io/library/mon-nginx:v1.0                                                                                                         0.0s

# Vérification de notre image :
wilder@docker1:~/mon_projet_docker$ docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
mon-nginx             v1.0      b160a8d1a401   6 minutes ago   187MB

Nous allons créér un conteneur à partir de notre image et vérifier la page d'accueil du serveur nginx :

wilder@docker1:~/mon_projet_docker$ docker run -d --name my-nginx  -p 80:80 mon-nginx:v1.0
17ed6a61677f56f97bbf1391657e99cb6f64fb3a255966b5dc88268835cbb851

wilder@docker1:~/mon_projet_docker$ docker ps
CONTAINER ID   IMAGE            COMMAND                  CREATED         STATUS         PORTS                               NAMES
17ed6a61677f   mon-nginx:v1.0   "/docker-entrypoint.…"   2 minutes ago   Up 2 minutes   0.0.0.0:80->80/tcp, :::80->80/tcp   my-nginx

wilder@docker1:~/mon_projet_docker$ curl 127.0.0.1:80
<h1>Bienvenue sur mon serveur Nginx créé à partir de mon image !!!!</h1>

Parfait, tout fonctionne comme prévu :+1:

:point_right: Quelques bonnes pratiques

Avant de clôturer cette quête, voici quelques bonnes pratiques à garder à l'esprit lors de la création d'images Docker et de la rédaction de tes Dockerfile :

1. Minimiser la taille de l'image : Essaye de réduire autant que possible la taille de tes images Docker. Utilise des images de base légères comme Alpine Linux et évite d'inclure des éléments inutiles dans ton conteneur.

2. Utiliser des images de base appropriées : Choisis des images de base adaptées à ton application. Par exemple, si tu développes une application Node.js, utilise une image Node.js officielle comme base.

3. Diviser les commandes RUN : Lorsque tu utilises la commande RUN dans ton Dockerfile, regroupe les commandes similaires en une seule instruction pour réduire le nombre de couches dans l'image finale.

Par exemple, au lieu d'écrire plusieurs commandes RUN séparées pour installer des packages et nettoyer les caches dans un Dockerfile, tu peux les combiner en une seule commande RUN. Cela permet d'éviter la création de couches supplémentaires dans l'image Docker pour chaque commande individuelle, ce qui contribue à réduire la taille de l'image finale.

Exemple :

# Mauvaise pratique : commandes RUN séparées
RUN apt-get update 
RUN apt-get install -y package1 package2 
RUN apt-get clean  

# Bonne pratique : commandes RUN combinées 
RUN apt-get update && apt-get install -y package1 package2 && apt-get clean

4. Éviter les secrets dans le Dockerfile : Ne stocke pas de secrets sensibles tels que les mots de passe ou les clés d'API directement dans ton Dockerfile !!! Utilise plutôt des variables d'environnement ou des volumes secrets pour fournir ces informations de manière sécurisée.

5. Nettoyer les dépendances inutiles : Assure toi de supprimer les dépendances inutiles et les fichiers temporaires après l'installation des packages et la construction de ton application dans le Dockerfile. Cela permet de réduire la taille de l'image finale.

# Supprimer les caches de package :
RUN apt-get clean && rm -rf /var/lib/apt/lists/*
# Supprimer les fichiers temporaires :
RUN rm -rf /tmp/*
# Supprimer les logs :
RUN rm -rf /var/log/*
# Supprimer les caches de langage
RUN apt-get autoremove -y && apt-get clean && rm -rf /var/lib/apt/lists/* \ /var/cache/apt/archives/* /tmp/* /var/tmp/*

6. Utiliser .dockerignore : Crée un fichier .dockerignore pour exclure les fichiers et répertoires non pertinents lors de la construction de l'image. Cela permet d'accélérer le processus de construction et de réduire la taille de l'image. Le fichier .dockerignore est utilisé pour spécifier les fichiers et répertoires à exclure lors de la construction de l'image Docker. Il fonctionne de manière similaire à un fichier .gitignore dans un projet Git, mais au lieu de spécifier les fichiers à ignorer lors de la création d'un dépôt Git, il spécifie les fichiers à ignorer lors de la construction de l'image Docker.

Voici un exemple simple de contenu d'un fichier .dockerignore :

# Ignorer les fichiers et répertoires spécifiques
*secret*  
.git 
*.log  
# Ignorer tous les fichiers d'un type spécifique 
*.tmp  
# Ignorer tous les fichiers dans un répertoire spécifique 
logs/

7. Configurer correctement les variables d'environnement : Utilise des variables d'environnement pour configurer dynamiquement ton application. Cela rend ton image plus flexible et portable entre différents environnements et facilite le déploiement et la configuration de ton application pour les nouveaux utilisateurs ou les membres de l'équipe.

📝 Quiz

true||true|||false
# Quelle commande Docker permet de lister les images téléchargées localement ?
[] docker list 
[x] docker images 
[] docker search 
[] docker pull
# Comment supprimer une image Docker du cache local ?
[] docker remove <image> 
[] docker delete <image> 
[x] docker rmi <image> 
[] docker erase <image>
# Qu'est-ce qu'un Dockerfile ?
[] Un format de fichier pour stocker des images Docker 
[x] Un fichier de configuration pour construire une image Docker 
[] Un fichier de documentation pour les projets Docker 
[] Un fichier de sauvegarde pour les conteneurs Docker
# Quelle est l'utilité d'un Dockerfile ?
[] Il permet de lancer des conteneurs Docker
[] Il permet de lister les images disponibles sur le Docker Hub
[x] Il permet de créer des images Docker personnalisées en décrivant les étapes de construction
[] Il permet de rechercher des images sur le Docker Hub
# Dans un Dockerfile, quelle est l'instruction qui copie des fichiers depuis l'hôte dans l'image Docker ?
[] RUN
[x] COPY
[] CMD
[] EXPOSE
# Dans un Dockerfile, quelle instruction Docker permet d'exposer un port dans une image Docker ?
[] RUN
[] COPY
[] CMD
[x] EXPOSE
# Quelle commande permet de construire une image Docker à partir d'un Dockerfile ?
[] docker start
[] docker run
[] docker create
[x] docker build
# Comment spécifie-t-on la version d'une image Docker lors de sa construction ?
[] Avec l'option -version
[] Avec l'option -tag
[] Avec l'option -v
[x] Avec l'option -t
# Pourquoi est-il recommandé d'utiliser un fichier Dockerfile plutôt que de transformer un conteneur existant en une image Docker ?
[x] Parce que cela garantit une trace claire des étapes de construction de l'image
[] Parce que cela rend le processus de construction plus rapide
[] Parce que cela garantit que les images seront toujours à jour
[] Parce que cela rend les images plus légères
# Quelle est la meilleure pratique pour minimiser la taille des images Docker ?
[] Utiliser des machines virtuelles au lieu de conteneurs 
[] Regrouper plusieurs applications dans une seule image 
[x] Utiliser des images de base légères comme Alpine Linux

💪 Challenge

Dans ce challenge, tu devras mettre en application certains concepts abordés dans cette quête.

:u[Objectif : ] Créer une image Docker contenant un script qui affiche "Hello Wilder from container [nom du container]" lorsqu'un conteneur basé sur cette image est lancé.

:u[Instructions :]

1. Crée un script sur ton hôte Docker nommé hello_wilder.sh qui affiche "Hello Wilder from container [nom du container]". Assure toi que ce script est exécutable et que [nom du container] se rapporte à une variable capable de récupérer le nom du conteneur.

2. Crée un Dockerfile et alimente-le pour répondre à la demande :

   • Image de base
   • Copie du script
   • Commande par défaut qui lance le script hello_wilder.sh

3. Construit ton image personnalisée.

4. Teste ton image en instanciant un conteneur basé sur ton image.

5. Optimise ton image : explore les différents moyens qui permettent de réduire ton image sans compromettre sa fonctionnalité.

6. Poste ton image sur le Docker Hub

:u[Conseils : ]

Explore la documentation Docker pour en savoir plus sur les meilleures pratiques en matière de création d'images Docker optimisées. N'hésite pas à expérimenter et à rechercher des solutions en ligne si tu rencontres des difficultés.

🧐 Critères d'acceptation

• L'image Docker est construite avec succès et répond à la demande
• La taille de l'image est minimisée autant que possible