Comment utiliser la commande docker debug pour déboguer des conteneurs et images

Introduction

Dans ce lab, nous allons explorer comment déboguer efficacement les conteneurs et images Docker en utilisant la commande docker debug et d'autres techniques associées. Nous commencerons par relever le défi du débogage des conteneurs "slim" (allégés) qui ne disposent pas de shell, en démontrant comment exécuter des commandes directement dans leur environnement.

Ensuite, nous apprendrons comment déboguer une image "slim" directement avant même qu'elle ne soit exécutée en tant que conteneur. Nous aborderons également comment modifier des fichiers dans un conteneur en cours d'exécution à des fins de débogage, ainsi que comment gérer la boîte à outils de débogage à l'aide des commandes install et uninstall. Enfin, nous approfondirons notre compréhension des points d'entrée (entrypoints) des conteneurs en utilisant la commande entrypoint.

Skills Graph

Débogage d'un conteneur slim sans shell

Dans cette étape, nous allons apprendre à déboguer un conteneur slim qui ne dispose pas de shell installé. Les conteneurs slim sont souvent utilisés pour réduire la taille de l'image et la surface d'attaque, mais ils peuvent être difficiles à déboguer en cas de problème.

D'abord, lançons un simple conteneur slim qui affiche un message puis se termine. Nous utiliserons l'image alpine, qui est une distribution Linux très légère.

docker run alpine echo "Hello from Alpine!"

Vous devriez voir le message Hello from Alpine! dans votre terminal. Cela confirme que le conteneur s'est exécuté avec succès.

Maintenant, essayons d'exécuter une commande à l'intérieur de ce conteneur en utilisant docker exec. Nous tenterons d'exécuter /bin/sh, un shell couramment disponible.

docker run -d --name slim-container alpine sleep 3600
docker exec -it slim-container /bin/sh

Vous verrez probablement un message d'erreur indiquant que /bin/sh est introuvable. Cela s'explique car l'image alpine, dans sa configuration par défaut, n'inclut pas de shell comme bash ou sh. C'est une caractéristique commune des conteneurs slim.

Pour déboguer un conteneur sans shell, nous pouvons utiliser la commande docker exec pour exécuter une commande spécifique dans l'environnement du conteneur. Cependant, comme il n'y a pas de shell, nous devons exécuter la commande directement.

Essayons de lister les fichiers dans le répertoire racine du conteneur. Nous savons que la commande ls est généralement disponible même dans les environnements minimaux.

docker exec -it slim-container ls /

Vous devriez voir une liste de répertoires et fichiers à la racine du système de fichiers du conteneur, comme bin, etc, lib, etc. Cela démontre que nous pouvons toujours exécuter des commandes directement dans le conteneur même sans shell.

Enfin, nettoyons le conteneur que nous avons créé.

docker stop slim-container
docker rm slim-container

Cette étape nous a montré comment interagir avec un conteneur slim dépourvu de shell en exécutant des commandes directement via docker exec. Dans les prochaines étapes, nous explorerons d'autres techniques de débogage.

Débogage direct d'une image slim

Dans l'étape précédente, nous avons appris à interagir avec un conteneur slim en cours d'exécution. Cependant, il peut être nécessaire d'inspecter le contenu d'une image slim avant de l'exécuter comme conteneur, ou si le conteneur ne parvient pas à démarrer. Dans cette étape, nous allons explorer comment déboguer directement une image slim.

Docker fournit la commande docker run avec la possibilité de remplacer le point d'entrée (entrypoint) et la commande par défaut d'une image. Cela nous permet d'exécuter une commande différente dans un conteneur temporaire créé à partir de l'image, nous offrant ainsi un moyen d'inspecter son contenu.

Utilisons à nouveau l'image alpine. Nous savons qu'il s'agit d'une image slim qui ne contient pas de shell par défaut. Nous pouvons utiliser docker run pour exécuter directement une commande comme ls / sur l'image.

docker run --rm alpine ls /

L'option --rm garantit que le conteneur temporaire est automatiquement supprimé après l'exécution de la commande. Vous devriez voir le même résultat que lorsque nous avons exécuté ls / sur le conteneur en cours d'exécution dans l'étape précédente. Cela confirme que nous pouvons inspecter directement le système de fichiers de l'image.

Maintenant, vérifions si une commande spécifique existe dans l'image. Par exemple, recherchons la présence de la commande ping.

docker run --rm alpine which ping

Vous verrez probablement un message d'erreur comme which: not found. Cela indique que la commande ping n'est pas présente dans l'image alpine par défaut. C'est une autre caractéristique des images slim - elles ne contiennent souvent que les outils strictement nécessaires.

Essayons maintenant avec une commande que nous savons présente, comme cat.

docker run --rm alpine which cat

Cette fois, vous devriez voir le résultat /bin/cat, confirmant que la commande cat est disponible dans l'image.

Cette technique utilisant docker run --rm <image> <commande> est très utile pour :

• Vérifier rapidement le contenu d'une image
• Confirmer la présence de fichiers ou commandes spécifiques
• Comprendre la structure de l'image
  sans avoir besoin d'exécuter un conteneur de longue durée ou de construire une nouvelle image.

Modification de fichiers dans un conteneur en cours d'exécution

Dans cette étape, nous allons apprendre à modifier des fichiers dans un conteneur en cours d'exécution. Cela peut être utile à des fins de débogage, comme modifier des fichiers de configuration ou ajouter des scripts temporaires à un conteneur déjà actif.

Nous commencerons par exécuter un conteneur simple basé sur l'image ubuntu, plus complète que alpine et incluant un shell et des utilitaires courants.

docker run -d --name my-ubuntu ubuntu sleep 3600

Cette commande exécute un conteneur Ubuntu en mode détaché (-d) et le maintient actif pendant une heure avec la commande sleep 3600. Nous avons nommé le conteneur my-ubuntu pour faciliter sa référence.

Maintenant, utilisons docker exec pour obtenir un shell à l'intérieur du conteneur en cours d'exécution.

docker exec -it my-ubuntu /bin/bash

Vous devriez maintenant être dans le shell bash du conteneur my-ubuntu. L'invite de commande changera pour indiquer que vous êtes dans le conteneur.

À l'intérieur du conteneur, créons un nouveau fichier dans le répertoire /tmp.

echo "This is a test file." > /tmp/test_file.txt

Vérifions maintenant que le fichier a bien été créé et contient le bon contenu.

cat /tmp/test_file.txt

Vous devriez voir le message This is a test file.. Cela confirme que nous avons pu créer et écrire dans un fichier à l'intérieur du conteneur en cours d'exécution.

Pour quitter le shell du conteneur, tapez simplement exit.

exit

Vous êtes maintenant de retour dans le terminal de votre VM LabEx.

Nous pouvons également copier des fichiers vers et depuis un conteneur en cours d'exécution en utilisant la commande docker cp. Créons un fichier sur notre VM LabEx et copions-le dans le conteneur.

D'abord, créez un fichier nommé local_file.txt dans votre répertoire ~/project.

echo "This file is from the host." > ~/project/local_file.txt

Maintenant, copiez ce fichier dans le répertoire /tmp du conteneur my-ubuntu.

docker cp ~/project/local_file.txt my-ubuntu:/tmp/

Le format pour docker cp est docker cp <chemin_source> <nom_conteneur>:<chemin_destination> ou docker cp <nom_conteneur>:<chemin_source> <chemin_destination>.

Vérifions que le fichier a bien été copié dans le conteneur. Reconnectez-vous au shell du conteneur.

docker exec -it my-ubuntu /bin/bash

Dans le conteneur, vérifiez la présence de local_file.txt dans /tmp.

ls /tmp/

Vous devriez voir local_file.txt listé avec test_file.txt.

Maintenant, affichons le contenu de local_file.txt dans le conteneur.

cat /tmp/local_file.txt

Vous devriez voir le message This file is from the host..

Quittez à nouveau le shell du conteneur.

exit

Enfin, nettoyons le conteneur.

docker stop my-ubuntu
docker rm my-ubuntu

Cette étape a démontré comment modifier des fichiers dans un conteneur en cours d'exécution en utilisant docker exec pour obtenir un shell et des commandes Linux standard, et comment copier des fichiers entre l'hôte et le conteneur avec docker cp.

Gestion de la boîte à outils de débogage avec installation et désinstallation

Dans cette étape, nous allons explorer comment ajouter et supprimer des outils de débogage dans un conteneur en cours d'exécution. Bien qu'il soit généralement recommandé de garder les images de conteneurs de production minimales, il est parfois nécessaire d'installer temporairement des outils à des fins de débogage.

Nous utiliserons à nouveau l'image ubuntu, car elle dispose d'un gestionnaire de paquets (apt) qui facilite l'installation de logiciels.

D'abord, lançons un nouveau conteneur Ubuntu en mode détaché.

docker run -d --name debug-ubuntu ubuntu sleep 3600

Maintenant, obtenons un shell à l'intérieur du conteneur.

docker exec -it debug-ubuntu /bin/bash

Dans le conteneur, essayons d'utiliser une commande qui n'est pas installée par défaut, comme ping.

ping google.com

Vous verrez probablement une erreur "command not found".

Pour installer ping et d'autres utilitaires réseau, nous pouvons utiliser le gestionnaire de paquets apt. D'abord, il est recommandé de mettre à jour la liste des paquets.

apt update

Cette commande récupère les dernières informations sur les paquets disponibles depuis les dépôts.

Maintenant, installons le paquet iputils-ping, qui fournit la commande ping.

apt install -y iputils-ping

L'option -y confirme automatiquement l'installation sans demande de confirmation.

Une fois l'installation terminée, vous devriez pouvoir utiliser la commande ping.

ping -c 4 google.com

Vous devriez voir la sortie de la commande ping, indiquant qu'elle est maintenant disponible et fonctionnelle dans le conteneur.

Une fois le débogage terminé, il est recommandé de supprimer les outils installés pour garder le conteneur propre et réduire sa taille si vous deviez le commiter comme nouvelle image (bien que modifier des conteneurs en cours d'exécution pour la production soit généralement déconseillé).

Pour supprimer le paquet iputils-ping, utilisez apt remove.

apt remove -y iputils-ping

Vous pouvez vérifier que ping n'est plus disponible.

ping google.com

Vous devriez à nouveau voir l'erreur "command not found".

Quittez le shell du conteneur.

exit

Enfin, nettoyons le conteneur.

docker stop debug-ubuntu
docker rm debug-ubuntu

Cette étape a démontré comment installer et désinstaller temporairement des outils de débogage dans un conteneur en cours d'exécution en utilisant son gestionnaire de paquets. Il s'agit d'une technique puissante pour résoudre des problèmes dans des conteneurs où les outils nécessaires ne sont pas inclus dans l'image de base.

Comprendre les points d'entrée des conteneurs avec la commande entrypoint

Dans cette étape, nous allons étudier l'instruction ENTRYPOINT dans un Dockerfile et son impact sur l'exécution d'un conteneur. Le ENTRYPOINT définit la commande qui sera exécutée au démarrage d'un conteneur. Il est souvent utilisé pour configurer l'exécutable principal du conteneur.

Créons un Dockerfile simple utilisant ENTRYPOINT. Dans votre répertoire ~/project, créez un fichier nommé Dockerfile avec le contenu suivant :

FROM alpine
ENTRYPOINT ["echo", "Hello from the entrypoint!"]
CMD ["default", "command"]

Ce Dockerfile utilise l'image alpine comme base. Le ENTRYPOINT est défini sur ["echo", "Hello from the entrypoint!"]. Le CMD est défini sur ["default", "command"]. Lorsque ENTRYPOINT et CMD sont tous deux spécifiés, les arguments de CMD sont passés comme arguments à la commande ENTRYPOINT.

Maintenant, construisons une image à partir de ce Dockerfile.

docker build -t my-entrypoint-image ~/project

Cette commande construit une image nommée my-entrypoint-image à partir du Dockerfile dans le répertoire ~/project.

Exécutons maintenant un conteneur à partir de cette image sans fournir de commande supplémentaire.

docker run my-entrypoint-image

Vous devriez voir la sortie Hello from the entrypoint! default command. Cela montre que la commande ENTRYPOINT (echo) a été exécutée, et que les arguments de CMD (default command) lui ont été passés.

Maintenant, exécutons le conteneur en fournissant une commande différente dans la ligne docker run. Lorsque vous fournissez une commande dans la ligne docker run, elle remplace l'instruction CMD dans le Dockerfile, mais le ENTRYPOINT est toujours exécuté avec la commande fournie comme arguments.

docker run my-entrypoint-image "override command"

Vous devriez voir la sortie Hello from the entrypoint! override command. Cela démontre que le ENTRYPOINT a toujours été exécuté, mais que les arguments de la commande docker run (override command) ont remplacé les arguments de CMD.

Que faire si vous souhaitez ignorer complètement le ENTRYPOINT et exécuter une commande différente ? Vous pouvez utiliser le flag --entrypoint avec docker run.

docker run --entrypoint /bin/echo my-entrypoint-image "Running a different command"

Vous devriez voir la sortie Running a different command. Dans ce cas, le flag --entrypoint a remplacé le ENTRYPOINT spécifié dans le Dockerfile, et la commande fournie (/bin/echo) a été exécutée avec les arguments (Running a different command).

Comprendre ENTRYPOINT et CMD est crucial pour construire et déboguer des images Docker. ENTRYPOINT définit l'exécutable principal, tandis que CMD fournit des arguments par défaut à cet exécutable ou une commande par défaut si aucun ENTRYPOINT n'est défini.

Résumé

Dans ce lab, nous avons appris à déboguer des conteneurs et images Docker en utilisant la commande docker debug et des techniques associées. Nous avons commencé par explorer comment déboguer un conteneur minimaliste dépourvu de shell, démontrant qu'il est possible d'exécuter des commandes directement dans l'environnement du conteneur via docker exec, même sans shell traditionnel comme bash ou sh. Cette technique s'avère essentielle pour résoudre les problèmes sur des images conteneur minimales.

Bien que le contenu fourni ne couvre que la première étape, la structure globale du lab indique que les étapes suivantes aborderaient :

• Le débogage direct d'images minimales
• La modification de fichiers dans des conteneurs en cours d'exécution
• La gestion de la boîte à outils de débogage avec des commandes d'installation et désinstallation
• La compréhension des points d'entrée des conteneurs via la commande entrypoint

Ces étapes permettraient d'approfondir notre capacité à diagnostiquer et résoudre des problèmes au sein d'applications et d'images conteneurisées.