Création et personnalisation d'images Docker : un laboratoire pratique

Introduction

Docker est un outil puissant pour empaqueter et distribuer des applications sous forme de conteneurs. Au cœur de ce processus se trouvent les images Docker, qui sont des paquets préconstruits contenant tout ce dont il faut pour exécuter une application, y compris le code, les dépendances et la configuration. Dans ce laboratoire, vous apprendrez à créer des images Docker personnalisées qui améliorent vos applications en intégrant des logiciels, des bibliothèques ou des configurations supplémentaires.

Tout au long de ce laboratoire, nous utiliserons WebIDE (VS Code) pour éditer les fichiers. WebIDE offre une interface familière et conviviale pour l'édition de fichiers, ce qui facilite la manipulation des fichiers de configuration et du code.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) linux(("Linux")) -.-> linux/FileandDirectoryManagementGroup(["File and Directory Management"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) linux(("Linux")) -.-> linux/PackagesandSoftwaresGroup(["Packages and Softwares"]) docker/ContainerOperationsGroup -.-> docker/run("Run a Container") docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ImageOperationsGroup -.-> docker/images("List Images") linux/FileandDirectoryManagementGroup -.-> linux/cd("Directory Changing") linux/FileandDirectoryManagementGroup -.-> linux/mkdir("Directory Creating") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") linux/PackagesandSoftwaresGroup -.-> linux/curl("URL Data Transferring") subgraph Lab Skills docker/run -.-> lab-389185{{"Images Docker personnalisées"}} docker/exec -.-> lab-389185{{"Images Docker personnalisées"}} docker/images -.-> lab-389185{{"Images Docker personnalisées"}} linux/cd -.-> lab-389185{{"Images Docker personnalisées"}} linux/mkdir -.-> lab-389185{{"Images Docker personnalisées"}} docker/build -.-> lab-389185{{"Images Docker personnalisées"}} linux/curl -.-> lab-389185{{"Images Docker personnalisées"}} end

Configurer l'environnement de projet

Commençons par créer un répertoire de projet et y accéder.

Ouvrez un terminal dans WebIDE. Vous pouvez le faire en cliquant sur "Terminal" dans le menu supérieur, puis en sélectionnant "Nouveau terminal".
Dans le terminal, exécutez les commandes suivantes :

mkdir -p ~/project/docker
cd ~/project/docker

Cela crée un nouveau répertoire appelé docker dans le dossier ~/project et change le répertoire de travail actuel pour celui-ci.

Vérifiez que vous êtes dans le bon répertoire :

pwd

Vous devriez voir /home/labex/project/docker comme sortie.

Comprendre ces commandes :

mkdir -p : Cette commande crée un répertoire. Le flag -p permet de créer les répertoires parents s'ils n'existent pas.
cd : Cette commande change le répertoire actuel.
pwd : Cette commande affiche le répertoire de travail actuel.

Créer une image Docker simple

Maintenant, créons une image Docker simple qui exécute un serveur web Nginx.

Dans WebIDE, accédez à l'Explorateur de fichiers (généralement le premier icône dans la barre latérale gauche).
Cliquez avec le bouton droit dans le panneau de l'Explorateur de fichiers et sélectionnez "Nouveau fichier". Nommez-le Dockerfile (avec un 'D' majuscule et sans extension de fichier).
Ouvrez le Dockerfile en cliquant dessus dans l'Explorateur de fichiers. Ajoutez le contenu suivant :

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

Ce Dockerfile définit une nouvelle image basée sur l'image officielle de Nginx et copie un fichier appelé index.html dans le répertoire racine des documents par défaut de Nginx.

Comprendre le Dockerfile :

FROM nginx : Cette ligne spécifie l'image de base à partir de laquelle nous construisons. Dans ce cas, nous utilisons l'image officielle de Nginx.
COPY index.html /usr/share/nginx/html/ : Cette ligne copie notre fichier index.html dans le répertoire racine web du conteneur.

Créez un nouveau fichier appelé index.html dans le même répertoire. Vous pouvez le faire en cliquant à nouveau avec le bouton droit dans le panneau de l'Explorateur de fichiers et en sélectionnant "Nouveau fichier".
Ouvrez index.html et ajoutez le contenu suivant :

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Hello Docker!</title>
  </head>
  <body>
    <h1>Hello Docker!</h1>
    <p>This is a custom Docker image.</p>
  </body>
</html>

Il s'agit d'une simple page HTML qui sera servie par notre serveur Nginx.

Ouvrez un terminal dans WebIDE (Terminal -> Nouveau terminal si vous avez fermé le précédent) et construisez l'image Docker en utilisant la commande suivante :

docker build -t my-nginx.

Cette commande construit une nouvelle image Docker avec l'étiquette my-nginx.

Comprendre la commande :

docker build : C'est la commande pour construire une image Docker.
-t my-nginx : Le flag -t étiquette notre image avec le nom my-nginx.
. : Cela spécifie le contexte de construction (le répertoire contenant le Dockerfile) comme étant le répertoire actuel.

Une fois la construction terminée, vérifiez que l'image a été créée avec succès :

docker images

Vous devriez voir l'image my-nginx répertoriée dans la sortie.

Exécuter et tester l'image personnalisée

Exécutons un conteneur basé sur notre nouvelle image et testons-le.

Dans le terminal de WebIDE, démarrez un conteneur en utilisant la commande suivante :

docker run -d -p 8080:80 --name my-nginx-container my-nginx

Comprendre cette commande :

docker run : Cette commande crée et démarre un nouveau conteneur.
-d : Ce flag exécute le conteneur en mode détaché (en arrière-plan).
-p 8080:80 : Cela mappe le port 8080 de votre hôte sur le port 80 du conteneur.
--name my-nginx-container : Cela attribue un nom à notre conteneur.
my-nginx : C'est le nom de l'image que nous utilisons pour créer le conteneur.

Vérifiez que le conteneur est en cours d'exécution :

docker ps

Vous devriez voir my-nginx-container répertorié dans la sortie. Cette commande affiche tous les conteneurs en cours d'exécution.

Pour afficher le contenu de la page web, utilisez la commande curl :

curl http://localhost:8080

Vous devriez voir le contenu HTML du fichier index.html affiché dans le terminal.

Si vous vous demandez ce que fait curl, c'est un outil pour transférer des données depuis ou vers un serveur. Dans ce cas, nous l'utilisons pour récupérer le contenu de notre serveur web.

Vous pouvez également accéder au haut de la machine virtuelle LabEx, cliquer sur + pour créer un nouveau serveur web, puis entrer le port 8080 pour afficher le contenu.

Ajouter des logiciels personnalisés à l'image

Maintenant, modifions notre image Docker pour inclure des logiciels supplémentaires. Nous allons ajouter l'utilitaire curl à titre d'exemple.

Dans WebIDE, ouvrez le Dockerfile. Vous pouvez le faire en cliquant sur Dockerfile dans le panneau de l'Explorateur de fichiers.
Modifiez le contenu du Dockerfile comme suit :

FROM nginx
RUN apt-get update && apt-get install -y curl
COPY index.html /usr/share/nginx/html/

Ce Dockerfile ajoute une nouvelle instruction RUN qui met à jour l'index des paquets et installe l'utilitaire curl en utilisant le gestionnaire de paquets apt-get.

Comprendre la nouvelle ligne :

RUN apt-get update && apt-get install -y curl : Cette ligne met à jour la liste des paquets (apt-get update) puis installe curl (apt-get install -y curl). Le flag -y répond automatiquement "oui" à toutes les invitations pendant l'installation.

Enregistrez le fichier dans WebIDE en appuyant sur Ctrl+S (ou Cmd+S sur Mac).
Dans le terminal de WebIDE, reconstruisez l'image Docker avec une nouvelle étiquette :

docker build -t my-nginx-curl.

Cette commande construit une nouvelle image Docker avec l'étiquette my-nginx-curl qui inclut l'utilitaire curl.

Vérifiez que la nouvelle image a été créée :

docker images

Vous devriez voir l'image my-nginx-curl répertoriée dans la sortie.

Tester l'image personnalisée avec Curl

Exécutons un conteneur basé sur notre nouvelle image et testons l'utilitaire curl.

Dans le terminal de WebIDE, démarrez un nouveau conteneur en utilisant la commande suivante :

docker run -d --name curl-container my-nginx-curl

Cette commande démarre un nouveau conteneur basé sur l'image my-nginx-curl et le nomme curl-container.

Exécutez un shell bash dans le conteneur en cours d'exécution :

docker exec -it curl-container bash

Cette commande ouvre un shell bash interactif à l'intérieur du conteneur en cours d'exécution.

Comprendre cette commande :

docker exec : Cela exécute une commande dans un conteneur en cours d'exécution.
-it : Ces flags allouent un pseudo-TTY et maintiennent STDIN ouvert, vous permettant d'interagir avec le shell.
curl-container : C'est le nom de notre conteneur.
bash : C'est la commande que nous exécutons dans le conteneur (ouverture d'un shell bash).

Vous devriez maintenant voir une nouvelle invite, indiquant que vous êtes à l'intérieur du conteneur. À l'intérieur du conteneur, testez l'utilitaire curl :

curl http://localhost

Vous devriez voir le contenu HTML du fichier index.html affiché dans le terminal.

Quittez le shell bash du conteneur :

exit

Cette commande vous ramène au shell de votre système hôte.

Utiliser des variables d'environnement dans l'image

Dans cette étape, nous allons modifier notre image Docker pour utiliser des variables d'environnement pour la personnalisation.

Dans WebIDE, ouvrez à nouveau le Dockerfile.
Modifiez le contenu du Dockerfile comme suit :

FROM nginx
ENV NGINX_PORT 9000
RUN sed -i "s/listen\s*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
COPY index.html /usr/share/nginx/html/

Ce Dockerfile ajoute une instruction ENV qui définit la variable NGINX_PORT à 9000. Il inclut également une instruction RUN qui modifie la configuration de Nginx pour utiliser ce port.

Comprendre les nouvelles lignes :

ENV NGINX_PORT 9000 : Cela définit une variable d'environnement NGINX_PORT avec la valeur 9000.
RUN sed -i "s/listen\s*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf : Cela utilise sed pour remplacer le port par défaut (80) par notre variable d'environnement dans le fichier de configuration de Nginx.

Enregistrez le fichier dans WebIDE.
Dans le terminal de WebIDE, reconstruisez l'image Docker avec une nouvelle étiquette :

docker build -t my-nginx-env.

Exécutez un conteneur basé sur la nouvelle image :

docker run -d -p 9000:9000 -e NGINX_PORT=9000 --name env-container my-nginx-env

Cette commande démarre un nouveau conteneur basé sur l'image my-nginx-env, mappe le port 9000 de l'hôte sur le port 9000 du conteneur et définit la valeur de la variable NGINX_PORT à 9000.

Comprendre les nouvelles parties de cette commande :

-e NGINX_PORT=9000 : Cela définit la variable d'environnement NGINX_PORT à 9000 pour cette exécution spécifique du conteneur.

Vérifiez que le serveur web est en cours d'exécution sur le port spécifié :

curl http://localhost:9000

Vous devriez voir le contenu HTML du fichier index.html affiché dans le terminal.

Utiliser ENTRYPOINT dans le Dockerfile

Dans cette étape, nous allons apprendre à utiliser l'instruction ENTRYPOINT dans un Dockerfile et à utiliser un autre port (9100).

Dans WebIDE, ouvrez à nouveau le Dockerfile.
Modifiez le contenu du Dockerfile comme suit :

FROM nginx
ENV NGINX_PORT 9100
RUN sed -i "s/listen\s*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
COPY index.html /usr/share/nginx/html/
COPY start.sh /start.sh
RUN chmod +x /start.sh
ENTRYPOINT ["/start.sh"]

Ce Dockerfile définit NGINX_PORT à 9100 et ajoute une instruction ENTRYPOINT, qui spécifie la commande à exécuter lorsque le conteneur démarre.

Créez un nouveau fichier nommé start.sh dans le même répertoire avec le contenu suivant :

#!/bin/bash
echo "Starting Nginx on port $NGINX_PORT"
nginx -g 'daemon off;'

Ce script affiche un message indiquant sur quel port Nginx va s'exécuter avant de démarrer Nginx.

Enregistrez les deux fichiers dans WebIDE.
Dans le terminal de WebIDE, reconstruisez l'image Docker avec une nouvelle étiquette :

docker build -t my-nginx-entrypoint.

Exécutez un conteneur basé sur la nouvelle image :

docker run -d -p 9100:9100 -e NGINX_PORT=9100 --name entrypoint-container my-nginx-entrypoint

Vérifiez les journaux du conteneur pour voir le message de démarrage :

docker logs entrypoint-container

Vous devriez voir le message "Starting Nginx on port 9100" dans la sortie.

Vérifiez que le serveur web fonctionne correctement sur le nouveau port :

curl http://localhost:9100

Vous devriez voir le contenu HTML du fichier index.html affiché dans le terminal.

Résumé

Dans ce laboratoire, vous avez appris à créer des images Docker personnalisées qui ajoutent de la valeur à vos applications. Vous avez commencé par créer une image simple avec un serveur web, puis vous avez progressé en ajoutant des logiciels personnalisés et en utilisant des variables d'environnement pour la configuration. Tout au long du laboratoire, vous avez utilisé WebIDE (VS Code) pour éditer les fichiers, rendant le processus plus intuitif et convivial.

Voici un récapitulatif de ce que vous avez accompli :

Configuré un environnement de projet et appris les commandes de base du terminal.
Créé une image Docker simple avec Nginx et une page HTML personnalisée.
Construit et exécuté des conteneurs Docker, en apprenant le mappage de ports et la nomination des conteneurs.
Modifié une image Docker pour inclure des logiciels supplémentaires (curl).
Utilisé Docker exec pour exécuter des commandes à l'intérieur d'un conteneur.
Intégré des variables d'environnement dans votre image Docker pour une configuration plus facile.