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, des packages pré-construits contenant tout le nécessaire 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 y intégrant des logiciels, des bibliothèques ou des configurations supplémentaires.

Tout au long de ce laboratoire, nous utiliserons WebIDE (VS Code) pour modifier les fichiers. WebIDE offre une interface familière et conviviale pour l'édition de fichiers, facilitant ainsi le travail avec les fichiers de configuration et le code.

Configurer l'environnement du projet

Commençons par créer un répertoire de projet et nous y placer.

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

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

Terminal affichant les commandes de création du répertoire de projet

Ceci crée un nouveau répertoire nommé docker dans le dossier ~/project et définit ce répertoire comme répertoire de travail actuel.

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

pwd

Vous devriez voir /home/labex/project/docker comme résultat.

Comprendre ces commandes :

mkdir -p : Cette commande crée un répertoire. L'option -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 la première icône dans la barre latérale gauche).
Faites un clic droit dans le volet de l'explorateur de fichiers et sélectionnez "New File". Nommez-le Dockerfile (avec un 'D' majuscule et sans extension).
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 Nginx et copie un fichier nommé index.html dans le répertoire racine 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 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 nommé index.html dans le même répertoire. Vous pouvez le faire en faisant un clic droit dans le volet de l'explorateur de fichiers et en sélectionnant "New File".
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 page HTML simple qui sera servie par notre serveur Nginx.

Ouvrez un terminal dans WebIDE (Terminal -> New 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 le tag my-nginx.

Comprendre la commande :

docker build : C'est la commande pour construire une image Docker.
-t my-nginx : L'option -t étiquette (tag) notre image avec le nom my-nginx.
. : Ceci spécifie le contexte de build (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 listée dans le résultat.

Exécuter et tester l'image personnalisée

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

Dans le terminal 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 : Cette option exécute le conteneur en mode détaché (en arrière-plan).
-p 8080:80 : Ceci mappe le port 8080 de votre hôte vers le port 80 du conteneur.
--name my-nginx-container : Ceci 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 listé dans le résultat. Cette commande affiche tous les conteneurs en cours d'exécution.

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

curl http://localhost:8080

Vous devriez voir le contenu HTML du fichier index.html s'afficher dans le terminal.

Si vous êtes curieux de savoir 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 naviguer vers le haut de la machine virtuelle LabEx, cliquer sur + pour créer un nouveau serveur web, puis entrer le port 8080 pour voir le contenu.

Configuration du port du serveur web

Ajouter des logiciels personnalisés à l'image

Dans cette étape, vous allez modifier votre image Docker pour inclure des logiciels supplémentaires. Nous ajouterons l'éditeur de texte nano à titre d'exemple, car il n'est pas inclus dans l'image de base nginx.

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

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

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

Comprendre la nouvelle ligne :

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

Enregistrez le fichier dans WebIDE en appuyant sur Ctrl+S (ou Cmd+S sur Mac).
Dans le terminal WebIDE, reconstruisez l'image Docker avec un nouveau tag :

docker build -t my-nginx-nano .

Cette commande construit une nouvelle image Docker avec le tag my-nginx-nano qui inclut l'éditeur nano.

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

docker images

Vous devriez voir l'image my-nginx-nano listée dans le résultat.

Tester l'image personnalisée avec Nano

Dans cette étape, vous allez exécuter un conteneur basé sur votre nouvelle image et confirmer que le paquet nano est disponible à l'intérieur.

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

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

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

Exécutez la commande suivante pour vérifier la version de nano installée à l'intérieur du conteneur :

docker exec nano-container nano --version

Cette commande exécute nano --version à l'intérieur du conteneur en cours d'exécution afin que vous puissiez confirmer que le paquet est installé.

Comprendre cette commande :

docker exec : Ceci exécute une commande dans un conteneur en cours d'exécution.
nano-container : C'est le nom de notre conteneur.
nano --version : Ceci affiche la version de nano installée depuis l'intérieur du conteneur.

Vous devriez voir un résultat commençant par GNU nano, ce qui confirme que l'image personnalisée inclut désormais l'éditeur.

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[[:space:]]*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 : Ceci définit une variable d'environnement NGINX_PORT avec la valeur 9000.
RUN sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf : Ceci utilise sed pour remplacer le port par défaut (80) par notre variable d'environnement dans le fichier de configuration Nginx.

Enregistrez le fichier dans WebIDE.
Dans le terminal WebIDE, reconstruisez l'image Docker avec un nouveau tag :

docker build -t my-nginx-env .

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

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

Cette commande démarre un nouveau conteneur basé sur l'image my-nginx-env et mappe le port 9000 sur l'hôte vers le port 9000 dans le conteneur. Notez que la variable d'environnement est déjà définie dans le Dockerfile, il n'est donc pas nécessaire de la définir à nouveau dans la commande docker run.

Vérifiez que le serveur web fonctionne sur le port spécifié :

curl http://localhost:9000

Vous devriez voir le contenu HTML du fichier index.html s'afficher dans le terminal.

Utiliser ENTRYPOINT dans le Dockerfile

Dans cette étape, nous apprendrons à utiliser l'instruction ENTRYPOINT dans un Dockerfile et à utiliser un port différent (9100).

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

FROM nginx
COPY index.html /usr/share/nginx/html/
COPY start.sh /start.sh
RUN chmod +x /start.sh
ENTRYPOINT ["/start.sh"]

Ce Dockerfile supprime la variable d'environnement et la commande sed. Au lieu de cela, nous gérerons la configuration au moment de l'exécution en utilisant un script ENTRYPOINT. Cela rend notre image plus flexible.

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

#!/bin/bash
## Set a default port if NGINX_PORT is not set
export NGINX_PORT=${NGINX_PORT:-9100}
## Replace the port in the nginx configuration
sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
echo "Starting Nginx on port $NGINX_PORT"
nginx -g 'daemon off;'

Ce script définit un port par défaut, modifie la configuration de Nginx au démarrage du conteneur, affiche un message indiquant sur quel port Nginx sera exécuté, puis démarre Nginx.

Enregistrez les deux fichiers dans WebIDE.
Dans le terminal WebIDE, reconstruisez l'image Docker avec un nouveau tag :

docker build -t my-nginx-entrypoint .

Exécutez un conteneur basé sur la nouvelle image. Nous définirons le port sur 9100 en utilisant une variable d'environnement.

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 le résultat.

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 s'afficher dans le terminal.

Résumé

Dans ce laboratoire, vous avez appris à créer des images Docker personnalisées qui apportent une valeur ajoutée à 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 modifier les fichiers, rendant le processus plus intuitif et convivial.

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

Configuration d'un environnement de projet et apprentissage des commandes de terminal de base.
Création d'une image Docker simple avec Nginx et une page HTML personnalisée.
Construction et exécution de conteneurs Docker, avec apprentissage du mappage de ports et du nommage des conteneurs.
Modification d'une image Docker pour inclure des logiciels supplémentaires (curl).
Utilisation de docker exec pour exécuter des commandes à l'intérieur d'un conteneur.
Intégration de variables d'environnement dans votre image Docker pour une configuration plus facile.

Images Docker personnalisées

Introduction

Configurer l'environnement du projet

Créer une image Docker simple

Exécuter et tester l'image personnalisée

Ajouter des logiciels personnalisés à l'image

Tester l'image personnalisée avec Nano

Utiliser des variables d'environnement dans l'image

Utiliser ENTRYPOINT dans le Dockerfile

Résumé