Comment configurer et exécuter efficacement des conteneurs Docker

Introduction

Ce tutoriel Docker complet s'adresse aux développeurs et aux professionnels de l'informatique pour une exploration approfondie de la technologie des conteneurs. De la compréhension des concepts fondamentaux de Docker aux techniques pratiques d'installation et de gestion, ce guide couvre tout ce qui est nécessaire pour exploiter les puissantes capacités de conteneurisation de Docker pour le développement et le déploiement de logiciels modernes.

Fondamentaux de Docker

Introduction à la technologie des conteneurs

Docker est une plateforme puissante pour la technologie des conteneurs, permettant aux développeurs d'empaqueter, de distribuer et d'exécuter des applications efficacement. Les conteneurs fournissent des environnements légers et portables qui encapsulent le logiciel et ses dépendances.

Concepts fondamentaux de Docker

graph TD
    A[Docker Engine] --> B[Container]
    A --> C[Image]
    A --> D[Dockerfile]

Vérification de l'installation de Docker

Votre environnement LabEx est livré avec Docker pré-installé. Vérifions la version de Docker pour nous assurer qu'elle est prête à l'emploi.

docker --version

La sortie devrait afficher la version de Docker, par exemple, Docker version 20.10.21, build baeda1f. Cela confirme que Docker est correctement installé et accessible.

Téléchargement de votre première image Docker

Une image Docker est un modèle en lecture seule qui contient un ensemble d'instructions pour créer un conteneur. Nous allons télécharger l'image hello-world, qui est une image minimale utilisée pour tester les installations Docker.

docker pull hello-world

Cette commande télécharge l'image hello-world depuis Docker Hub vers votre machine locale. Vous devriez voir une sortie indiquant la progression du téléchargement et la confirmation que l'image a été téléchargée.

Exécution de votre premier conteneur Docker

Maintenant que nous avons une image, exécutons un conteneur à partir de celle-ci. Exécuter un conteneur signifie créer une instance de l'image.

docker run hello-world

Lorsque vous exécutez hello-world, Docker effectue les actions suivantes :

1. Il vérifie si l'image hello-world existe localement. Sinon, il la télécharge (ce que nous avons déjà fait).
2. Il crée un nouveau conteneur à partir de l'image.
3. Il exécute l'exécutable contenu dans le conteneur.
4. Le conteneur affiche un message "Hello from Docker!" puis se termine.

Cela démontre le cycle de vie de base d'un conteneur Docker : télécharger une image, exécuter un conteneur, et le conteneur exécute sa tâche définie.

Listage des images Docker

Pour voir les images que vous avez téléchargées, utilisez la commande docker images.

docker images

Cette commande liste toutes les images Docker stockées sur votre système local, y compris l'image hello-world que nous venons de télécharger. Vous verrez des détails tels que le dépôt (repository), le tag, l'ID de l'image, la date de création et la taille.

Comprendre le cycle de vie des conteneurs

Les conteneurs fournissent des environnements isolés avec leur propre système de fichiers, leurs processus et leurs interfaces réseau. Ils peuvent être démarrés, arrêtés, déplacés et supprimés rapidement, ce qui les rend idéaux pour les microservices et les applications cloud-natives.

Gestion des fichiers Dockerfile

Bases du Dockerfile

Un Dockerfile est un document texte qui contient toutes les commandes qu'un utilisateur peut appeler sur la ligne de commande pour assembler une image. Il définit l'environnement, les dépendances et la configuration des applications conteneurisées.

graph TD
    A[Dockerfile] --> B[Commande de build]
    B --> C[Image Docker]
    C --> D[Conteneur]

Création de votre premier Dockerfile

Naviguez vers le répertoire docker_app, qui a été créé lors de la phase de configuration. Ce sera notre répertoire de travail pour ce laboratoire.

cd /home/labex/project/docker_app

Maintenant, créons un Dockerfile simple nommé Dockerfile dans ce répertoire. Ce Dockerfile créera une image basée sur Ubuntu et y ajoutera un simple fichier texte.

nano Dockerfile

Ajoutez le contenu suivant au Dockerfile :

## Utiliser une image de base Ubuntu officielle
FROM ubuntu:22.04

## Définir le répertoire de travail à l'intérieur du conteneur
WORKDIR /app

## Créer un fichier texte simple
RUN echo "Hello from Dockerfile!" > /app/message.txt

## Commande à exécuter au démarrage du conteneur
CMD ["cat", "/app/message.txt"]

• FROM ubuntu:22.04 : Cette instruction spécifie l'image de base pour notre nouvelle image. Nous utilisons Ubuntu 22.04.
• WORKDIR /app : Ceci définit le répertoire de travail pour toutes les instructions RUN, CMD, ENTRYPOINT, COPY ou ADD qui suivent dans le Dockerfile. Si /app n'existe pas, il sera créé.
• RUN echo "Hello from Dockerfile!" > /app/message.txt : Cette instruction exécute une commande à l'intérieur de l'image pendant le processus de build. Ici, elle crée un fichier nommé message.txt dans le répertoire /app avec le contenu "Hello from Dockerfile!".
• CMD ["cat", "/app/message.txt"] : Cette instruction fournit les commandes par défaut pour un conteneur en cours d'exécution. Lorsqu'un conteneur est lancé à partir de cette image, il exécutera cat /app/message.txt, affichant le contenu de notre fichier message.

Enregistrez le fichier en appuyant sur Ctrl+S et quittez nano en appuyant sur Ctrl+X.

Construction de votre image Docker

Maintenant que nous avons notre Dockerfile, construisons l'image Docker à partir de celui-ci. La commande docker build lit le Dockerfile et crée une image Docker.

docker build -t my-ubuntu-app .

• docker build : La commande pour construire une image Docker.
• -t my-ubuntu-app : Ceci étiquette notre image avec le nom my-ubuntu-app. Vous pouvez choisir le nom que vous souhaitez.
• . : Ceci spécifie le contexte de build, qui est l'ensemble des fichiers au PATH ou à l'URL spécifié. Le . indique que le répertoire courant (/home/labex/project/docker_app) est le contexte de build. Docker recherchera un Dockerfile dans ce répertoire.

Vous verrez une sortie montrant chaque étape du processus de build, correspondant aux instructions de votre Dockerfile.

Exécution de votre conteneur Docker personnalisé

Après avoir construit l'image avec succès, exécutons un conteneur à partir de celle-ci pour voir le contenu de message.txt.

docker run my-ubuntu-app

Cette commande créera et exécutera un nouveau conteneur à partir de votre image my-ubuntu-app. L'instruction CMD de votre Dockerfile sera exécutée, et vous devriez voir "Hello from Dockerfile!" s'afficher dans votre terminal.

Inspection du système de fichiers du conteneur

Pour mieux comprendre comment les fichiers sont gérés dans un conteneur, lançons une session interactive et inspectons le fichier que nous avons créé.

docker run -it my-ubuntu-app /bin/bash

• -it : Ce drapeau alloue un pseudo-TTY et maintient STDIN ouvert, vous permettant d'interagir avec le conteneur.
• my-ubuntu-app : Le nom de l'image que nous voulons exécuter.
• /bin/bash : Ceci remplace l'instruction CMD dans le Dockerfile et exécute plutôt un shell Bash à l'intérieur du conteneur, vous donnant une invite de commande.

Une fois à l'intérieur du conteneur, vous verrez une nouvelle invite de commande (par exemple, root@<container_id>:/app#). Maintenant, vous pouvez lister les fichiers et afficher le contenu de message.txt.

ls -l
cat message.txt

Vous devriez voir message.txt listé et son contenu affiché. Pour quitter le conteneur, tapez simplement exit.

exit

Cette session interactive démontre que le fichier message.txt a été créé avec succès et est accessible dans le système de fichiers du conteneur.

Techniques Docker avancées

Stratégies de build multi-étapes (Multi-Stage Build)

Les builds multi-étapes sont une fonctionnalité puissante qui vous permet d'utiliser plusieurs instructions FROM dans votre Dockerfile. Chaque instruction FROM peut utiliser une image de base différente, et chaque instruction FROM démarre une nouvelle étape de build. Cela permet d'optimiser la complexité des Dockerfiles et de réduire la taille de l'image finale en séparant les environnements de build et d'exécution.

graph TD
    A[Étape de build] --> B[Compilation/Build]
    B --> C[Étape d'exécution]
    C --> D[Image de production minimale]

Préparation pour un build multi-étapes

Pour cet exemple, nous allons simuler une application simple qui nécessite une étape de build. Nous allons créer un fichier build_script.sh et un fichier final_app.txt.

Tout d'abord, assurez-vous d'être dans le répertoire docker_app :

cd /home/labex/project/docker_app

Maintenant, créons un script de build simple :

nano build_script.sh

Ajoutez le contenu suivant à build_script.sh :

#!/bin/bash
echo "Running build process..."
echo "This is the final application output." > /app/output/final_app.txt
echo "Build complete."

Enregistrez le fichier (Ctrl+S) et quittez (Ctrl+X).

Ensuite, créons un espace réservé pour le contenu final de notre application. Dans un scénario réel, cela serait généré par le processus de build.

nano final_app.txt

Ajoutez le contenu suivant à final_app.txt :

This is a placeholder for the final application.

Enregistrez le fichier (Ctrl+S) et quittez (Ctrl+X).

Implémentation d'un Dockerfile multi-étapes

Maintenant, modifions notre Dockerfile pour utiliser un build multi-étapes. Nous aurons une étape "builder" qui exécutera notre build_script.sh, puis une étape "production" qui copiera uniquement la sortie nécessaire de l'étape builder.

nano Dockerfile

Remplacez le contenu existant par le suivant :

## Étape 1 : Étape de build (builder stage)
FROM ubuntu:22.04 AS builder

## Installer bash pour exécuter le script
RUN apt-get update && apt-get install -y bash

## Définir le répertoire de travail pour l'étape de build
WORKDIR /build

## Copier le script de build et le rendre exécutable
COPY build_script.sh .
RUN chmod +x build_script.sh

## Créer un répertoire pour la sortie
RUN mkdir -p /build/output

## Exécuter le script de build
RUN ./build_script.sh

## Étape 2 : Étape de production
FROM ubuntu:22.04

## Définir le répertoire de travail pour l'étape de production
WORKDIR /app

## Copier uniquement l'artefact nécessaire de l'étape de build
COPY --from=builder /build/output/final_app.txt .

## Commande à exécuter au démarrage du conteneur
CMD ["cat", "final_app.txt"]

• FROM ubuntu:22.04 AS builder : Ceci démarre la première étape et la nomme builder.
• RUN apt-get update && apt-get install -y bash : Installe bash dans l'étape de build, nécessaire pour exécuter notre script.
• WORKDIR /build : Définit le répertoire de travail pour l'étape de build.
• COPY build_script.sh . : Copie notre script de build dans l'étape de build.
• RUN chmod +x build_script.sh : Rend le script exécutable.
• RUN mkdir -p /build/output : Crée un répertoire de sortie dans l'étape de build.
• RUN ./build_script.sh : Exécute le script de build, qui génère final_app.txt dans /build/output.
• FROM ubuntu:22.04 : Ceci démarre la deuxième étape (l'étape de production). Elle utilise une image ubuntu:22.04 fraîche, ce qui signifie qu'elle n'hérite par défaut de rien de l'étape builder.
• WORKDIR /app : Définit le répertoire de travail pour l'étape de production.
• COPY --from=builder /build/output/final_app.txt . : C'est l'instruction clé pour les builds multi-étapes. Elle copie final_app.txt du répertoire /build/output de l'étape builder vers le répertoire courant (/app) de l'étape de production. Cela garantit que seul l'artefact final est inclus, gardant ainsi l'image de production petite.
• CMD ["cat", "final_app.txt"] : La commande à exécuter lorsque le conteneur de production démarre, affichant le contenu du fichier copié.

Enregistrez le fichier (Ctrl+S) et quittez (Ctrl+X).

Construction et exécution de l'image multi-étapes

Maintenant, construisons la nouvelle image en utilisant notre Dockerfile multi-étapes.

docker build -t multi-stage-app .

Observez la sortie du build. Vous verrez les étapes pour l'étape builder et l'étape finale.

Une fois le build terminé, exécutez le conteneur pour vérifier que le contenu de final_app.txt est affiché.

docker run multi-stage-app

Vous devriez voir "This is the final application output." s'afficher, confirmant que le build multi-étapes a correctement copié l'artefact de l'étape de build vers l'image finale.

Nettoyage des ressources Docker

Il est de bonne pratique de nettoyer les ressources Docker (conteneurs et images) qui ne sont plus nécessaires afin de libérer de l'espace disque.

Tout d'abord, listez tous les conteneurs (y compris ceux qui sont arrêtés) :

docker ps -a

Vous pouvez supprimer des conteneurs spécifiques par leur ID ou leur nom :

docker rm $(docker ps -aq)

Cette commande supprime tous les conteneurs arrêtés. docker ps -aq liste tous les IDs de conteneurs, et docker rm les supprime.

Ensuite, listez toutes les images :

docker images

Vous pouvez supprimer des images spécifiques par leur ID ou leur nom. Faites attention à ne pas supprimer des images qui sont encore utilisées par des conteneurs en cours d'exécution.

docker rmi my-ubuntu-app multi-stage-app hello-world ubuntu:22.04

Cette commande supprime les images que nous avons créées et utilisées dans ce laboratoire. Si une image est toujours utilisée par un conteneur, vous devrez d'abord supprimer le conteneur.

docker images

Cette commande montrera que les images ont été supprimées.

Ceci conclut le laboratoire sur les fondamentaux de Docker et les techniques avancées. Vous avez appris à créer des Dockerfiles, à construire des images, à exécuter des conteneurs et à optimiser la taille des images à l'aide de builds multi-étapes.

Résumé

En maîtrisant les fondamentaux de Docker, la gestion des Dockerfiles et les techniques avancées, les développeurs peuvent créer des environnements logiciels plus efficaces, portables et évolutifs. Ce tutoriel vous a doté de compétences pratiques en création de conteneurs, gestion d'images et stratégies de déploiement, vous permettant de rationaliser les flux de travail de développement et d'adopter des architectures d'applications cloud-natives.