Images Docker personnalisées

DockerBeginner
Pratiquer maintenant

Introduction

Docker est un outil puissant pour packager et distribuer des applications sous forme de conteneurs. Au cœur de ce processus se trouvent les images Docker : des paquets pré-construits contenant tout le nécessaire pour exécuter une application, y compris le code, les dépendances et la configuration. Dans ce lab, vous apprendrez à créer des images Docker personnalisées pour améliorer vos applications en y intégrant des logiciels, des bibliothèques ou des configurations spécifiques.

Tout au long de ce lab, nous utiliserons WebIDE (VS Code) pour éditer les fichiers. WebIDE offre une interface familière et conviviale pour l'édition de fichiers, facilitant ainsi le travail sur 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 déplacer.

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

  1. Ouvrez un terminal dans WebIDE. Vous pouvez le faire en cliquant sur "Terminal" dans le menu supérieur, puis en sélectionnant "New Terminal".
  2. Dans le terminal, exécutez les commandes suivantes :
mkdir -p ~/project/docker
cd ~/project/docker
Terminal montrant les commandes de création du répertoire de projet

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

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

Vous devriez voir /home/labex/project/docker s'afficher.

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 permet de changer de répertoire.
  • 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.

  1. Dans WebIDE, accédez à l'Explorateur de fichiers (généralement la première icône dans la barre latérale gauche).
  2. 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 de fichier).
  3. Ouvrez le Dockerfile en cliquant dessus. 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 vers 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. Ici, 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.
  1. Créez un nouveau fichier nommé index.html dans le même répertoire. Vous pouvez le faire en cliquant à nouveau avec le bouton droit dans l'Explorateur de fichiers et en sélectionnant "New File".
  2. 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.

  1. Ouvrez un terminal dans WebIDE (Terminal -> New Terminal si vous avez fermé le précédent) et construisez l'image Docker à l'aide de 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 permet de nommer (taguer) notre image my-nginx.
  • . : Cela spécifie que le contexte de construction (le répertoire contenant le Dockerfile) est le répertoire actuel.
  1. 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 la sortie.

Exécuter et tester l'image personnalisée

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

  1. Dans le terminal WebIDE, démarrez un conteneur à l'aide de 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 lance le conteneur en mode détaché (en arrière-plan).
  • -p 8080:80 : Cela mappe le port 8080 de votre hôte vers le port 80 du conteneur.
  • --name my-nginx-container : Cela assigne un nom personnalisé à notre conteneur.
  • my-nginx : C'est le nom de l'image que nous utilisons pour créer le conteneur.
  1. Vérifiez que le conteneur est en cours d'exécution :
docker ps

Vous devriez voir my-nginx-container dans la liste. Cette commande affiche tous les conteneurs actifs.

  1. Pour visualiser 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 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 aller en haut de la VM LabEx, cliquer sur le bouton + pour créer un nouvel accès serveur web, puis saisir le port 8080 pour voir le résultat dans votre navigateur.

Configuration du port du serveur web

Ajouter un logiciel personnalisé à l'image

Modifions maintenant notre image Docker pour inclure un logiciel supplémentaire. Nous allons ajouter l'utilitaire curl à titre d'exemple.

  1. Dans WebIDE, ouvrez le fichier Dockerfile. Vous pouvez le faire en cliquant sur Dockerfile dans le volet de l'Explorateur de fichiers.
  2. 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 via 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). L'option -y répond automatiquement "oui" à toutes les questions durant l'installation.
  1. Enregistrez le fichier dans WebIDE en appuyant sur Ctrl+S (ou Cmd+S sur Mac).
  2. Dans le terminal WebIDE, reconstruisez l'image Docker avec un nouveau tag :
docker build -t my-nginx-curl .

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

  1. Vérifiez que la nouvelle image a été créée :
docker images

Vous devriez voir l'image my-nginx-curl listé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 à l'intérieur.

  1. Dans le terminal WebIDE, démarrez un nouveau conteneur avec la commande suivante :
docker run -d --name curl-container my-nginx-curl

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

  1. 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.

Comprendre cette commande :

  • docker exec : Exécute une commande dans un conteneur actif.
  • -it : Ces options allouent un pseudo-TTY et maintiennent l'entrée standard (STDIN) ouverte, vous permettant d'interagir avec le shell.
  • curl-container : C'est le nom de notre conteneur.
  • bash : C'est la commande que nous lançons dans le conteneur (l'ouverture d'un shell bash).
  1. Vous devriez maintenant voir une nouvelle invite de commande, indiquant que vous êtes à l'intérieur du conteneur. Testez l'utilitaire curl :
curl http://localhost

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

  1. 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 afin de faciliter la personnalisation.

  1. Dans WebIDE, ouvrez à nouveau le Dockerfile.

  2. 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 : 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 : Utilise sed pour remplacer le port par défaut (80) par notre variable d'environnement dans le fichier de configuration de Nginx.
  1. Enregistrez le fichier dans WebIDE.

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

docker build -t my-nginx-env .
  1. Lancez un conteneur basé sur la nouvelle image :
docker run -d -p 9000:9000 --name env-container my-nginx-env

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

  1. Vérifiez que le serveur web fonctionne sur le port spécifié :
curl http://localhost:9000

Vous devriez voir le contenu HTML s'afficher.

Utiliser ENTRYPOINT dans le Dockerfile

Dans cette étape, nous allons apprendre à utiliser l'instruction ENTRYPOINT et à configurer un port différent (9100) via un script.

  1. Dans WebIDE, ouvrez à nouveau le Dockerfile.

  2. 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 fixe et la commande sed directe. À la place, nous gérerons la configuration au moment de l'exécution via un script ENTRYPOINT. Cela rend notre image beaucoup plus flexible.

  1. 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 Nginx au démarrage du conteneur, affiche un message indiquant le port utilisé, puis lance Nginx.

  1. Enregistrez les deux fichiers dans WebIDE.

  2. Dans le terminal WebIDE, reconstruisez l'image Docker :

docker build -t my-nginx-entrypoint .
  1. Lancez un conteneur basé sur cette image en forçant le port à 9100 via une variable d'environnement.
docker run -d -p 9100:9100 -e NGINX_PORT=9100 --name entrypoint-container my-nginx-entrypoint
  1. Consultez les logs 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.

  1. Vérifiez que le serveur web répond correctement sur le nouveau port :
curl http://localhost:9100

Le contenu HTML de index.html devrait s'afficher.

Résumé

Dans ce lab, vous avez appris à créer des images Docker personnalisées pour apporter de la valeur ajoutée à vos applications. Vous avez commencé par créer une image simple avec un serveur web, puis vous avez progressé vers l'ajout de logiciels et l'utilisation de variables d'environnement pour la configuration. Tout au long de l'exercice, l'utilisation de WebIDE (VS Code) a rendu le processus intuitif et fluide.

Voici un récapitulatif de vos accomplissements :

  1. Configuration d'un environnement de projet et apprentissage des commandes de base du terminal.
  2. Création d'une image Docker simple avec Nginx et une page HTML personnalisée.
  3. Construction et exécution de conteneurs Docker, avec apprentissage du mappage de ports et du nommage.
  4. Modification d'une image Docker pour inclure un logiciel supplémentaire (curl).
  5. Utilisation de docker exec pour exécuter des commandes à l'intérieur d'un conteneur.
  6. Intégration de variables d'environnement et de scripts de démarrage pour une configuration flexible.