Comment utiliser la commande docker container run pour gérer des conteneurs

Introduction

Dans ce labo (lab), vous acquerrez une expérience pratique en utilisant la commande docker container run pour gérer efficacement des conteneurs. Vous apprendrez à exécuter des conteneurs en mode détaché (detached mode) pour une exécution en arrière-plan et à leur attribuer des noms personnalisés pour une identification plus facile.

De plus, vous explorerez comment vous attacher à des conteneurs en cours d'exécution tout en gardant STDIN ouvert, publier des ports de conteneurs vers l'hôte pour un accès externe, monter des volumes pour assurer la persistance des données, et configurer des conteneurs en définissant des variables d'environnement et en ajoutant des entrées d'hôte. Ces compétences fondamentales sont essentielles pour construire et gérer des applications conteneurisées (Dockerized).

Skills Graph

Exécuter un conteneur en mode détaché et lui attribuer un nom

Dans cette étape, vous apprendrez comment exécuter un conteneur Docker en mode détaché (detached mode) et lui attribuer un nom personnalisé. L'exécution d'un conteneur en mode détaché signifie que le conteneur fonctionnera en arrière-plan, et vous ne verrez pas directement sa sortie dans votre terminal. L'attribution d'un nom facilite son identification et sa gestion ultérieure.

Tout d'abord, téléchargeons l'image hello-world. Il s'agit d'une image très légère utile pour tester si Docker fonctionne correctement.

docker pull hello-world

Vous devriez voir une sortie indiquant que l'image est en cours de téléchargement, puis un message confirmant son téléchargement réussi.

Maintenant, exécutons le conteneur hello-world en mode détaché. Nous utiliserons l'option -d pour le mode détaché et l'option --name pour attribuer un nom. Nommons ce conteneur my-hello-world.

docker run -d --name my-hello-world hello-world

Après avoir exécuté cette commande, Docker affichera une longue chaîne de caractères, qui correspond à l'ID du conteneur. Cela indique que le conteneur a démarré en arrière-plan.

Pour vérifier que le conteneur est en cours d'exécution, vous pouvez utiliser la commande docker ps. Cette commande liste tous les conteneurs actuellement en cours d'exécution.

docker ps

Vous devriez voir une liste des conteneurs en cours d'exécution, dont l'un devrait s'appeler my-hello-world. La colonne STATUS devrait indiquer que le conteneur s'est terminé il y a quelques secondes. Le conteneur hello-world est conçu pour s'exécuter brièvement, afficher un message, puis se terminer. Même s'il s'est terminé, il est toujours listé par docker ps car il a été exécuté en mode détaché.

Pour voir tous les conteneurs, y compris ceux qui se sont terminés, vous pouvez utiliser la commande docker ps -a.

docker ps -a

Cela affichera my-hello-world dans la liste, ainsi que son statut (Exited).

Se connecter à un conteneur en cours d'exécution et garder STDIN ouvert

Dans cette étape, vous apprendrez comment vous connecter à un conteneur en cours d'exécution tout en gardant l'entrée standard (STDIN) ouverte. Ceci est utile pour interagir avec un conteneur exécutant un processus nécessitant une entrée, comme un shell.

Lors de l'étape précédente, nous avons exécuté le conteneur hello-world qui s'est immédiatement terminé. Pour illustrer la connexion, nous avons besoin d'un conteneur qui reste actif. Une méthode simple consiste à exécuter un shell interactif dans un conteneur.

Commençons par télécharger l'image ubuntu, une image de base couramment utilisée pour de nombreuses applications.

docker pull ubuntu

Nous allons maintenant exécuter un conteneur ubuntu en mode détaché (-d), allouer un pseudo-TTY (-t) et garder STDIN ouvert (-i). Nous lui attribuerons également le nom my-ubuntu. La commande exécutée dans le conteneur sera /bin/bash, le chemin vers le shell Bash.

docker run -itd --name my-ubuntu ubuntu /bin/bash

L'option -i maintient STDIN ouvert, permettant d'envoyer des entrées au conteneur. L'option -t alloue un pseudo-TTY, nécessaire pour les sessions shell interactives. L'option -d exécute le conteneur en arrière-plan.

L'ID du conteneur devrait s'afficher dans votre terminal, indiquant que le conteneur s'exécute en arrière-plan.

Connectons-nous maintenant au conteneur my-ubuntu en cours d'exécution à l'aide de la commande docker attach.

docker attach my-ubuntu

Après exécution, vous devriez voir l'invite du shell Bash à l'intérieur du conteneur Ubuntu. Vous êtes maintenant connecté aux flux d'entrée, de sortie et d'erreur standard du conteneur.

Vous pouvez interagir avec le shell du conteneur. Par exemple, exécutez la commande ls pour lister les fichiers du répertoire courant dans le conteneur.

ls

Vous devriez voir le contenu du répertoire racine (/) du conteneur Ubuntu.

Pour vous déconnecter sans arrêter le conteneur, utilisez la séquence de touches : CTRL+p suivi de CTRL+q. Essayez maintenant d'appuyer sur CTRL+p puis CTRL+q.

Vous devriez revenir à l'invite de votre terminal hôte. Le conteneur continue de s'exécuter en arrière-plan. Vous pouvez le vérifier avec docker ps.

docker ps

Le conteneur my-ubuntu devrait apparaître dans la liste des conteneurs actifs.

Si vous aviez simplement appuyé sur CTRL+c pendant la connexion, cela aurait envoyé un signal au processus interne (le shell Bash), ce qui aurait probablement arrêté le conteneur. La séquence CTRL+p + CTRL+q est la méthode standard pour se déconnecter sans arrêter le conteneur.

Publier les ports d'un conteneur vers l'hôte

Dans cette étape, vous apprendrez comment publier les ports d'un conteneur Docker vers la machine hôte. Cela vous permet d'accéder aux services exécutés dans le conteneur depuis le réseau de votre hôte.

Tout d'abord, arrêtons et supprimons le conteneur my-ubuntu de l'étape précédente pour éviter tout conflit.

docker stop my-ubuntu
docker rm my-ubuntu

Vous devriez voir le nom du conteneur s'afficher après chaque commande, confirmant qu'il a été arrêté puis supprimé.

Nous allons maintenant exécuter un serveur web simple dans un conteneur et publier son port vers l'hôte. Nous utiliserons l'image nginx, un serveur web populaire.

Téléchargeons l'image nginx.

docker pull nginx

Maintenant, exécutons un conteneur nginx en mode détaché (-d) et publions le port 80 du conteneur vers le port 8080 sur la machine hôte. Nous utiliserons l'option -p pour la publication de ports, au format port_hôte:port_conteneur. Nous lui attribuerons également le nom my-nginx.

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

La partie -p 8080:80 mappe le port 80 à l'intérieur du conteneur (où Nginx écoute par défaut) vers le port 8080 sur votre machine hôte.

L'ID du conteneur devrait s'afficher, indiquant qu'il s'exécute en arrière-plan.

Pour vérifier que le port est correctement publié et que le serveur web est accessible, vous pouvez utiliser la commande curl sur votre machine hôte pour accéder à localhost sur le port 8080.

curl http://localhost:8080

Vous devriez voir la page HTML d'accueil par défaut de Nginx dans la sortie de votre terminal. Cela confirme que vous pouvez accéder au serveur web Nginx exécuté dans le conteneur via le port 8080 de votre hôte.

Vous pouvez également utiliser docker ps pour voir le conteneur en cours d'exécution et ses ports publiés.

docker ps

Dans la sortie, vous devriez voir my-nginx listé, et dans la colonne PORTS, l'indication 0.0.0.0:8080->80/tcp, confirmant que le port 80 du conteneur est mappé vers le port 8080 sur toutes les interfaces de l'hôte.

Monter un volume pour persister les données

Dans cette étape, vous apprendrez à utiliser les volumes Docker pour persister les données générées et utilisées par les conteneurs Docker. Par défaut, les données à l'intérieur d'un conteneur sont éphémères ; elles sont perdues lorsque le conteneur est supprimé. Les volumes offrent un moyen de stocker des données en dehors du système de fichiers du conteneur, permettant leur persistance même après l'arrêt ou la suppression du conteneur.

Commençons par arrêter et supprimer le conteneur my-nginx de l'étape précédente.

docker stop my-nginx
docker rm my-nginx

Nous allons maintenant créer un volume Docker. Les volumes sont gérés par Docker et stockés dans une zone dédiée de la machine hôte.

docker volume create my-volume

Vous devriez voir le nom du volume (my-volume) s'afficher, confirmant sa création.

Vous pouvez lister les volumes existants avec la commande docker volume ls.

docker volume ls

Le volume my-volume devrait apparaître dans la liste.

Exécutons maintenant un nouveau conteneur nginx en montant le volume my-volume dans le répertoire webroot par défaut de Nginx (/usr/share/nginx/html). Ainsi, tous les fichiers placés dans /usr/share/nginx/html seront en réalité stockés dans my-volume sur l'hôte.

Nous lancerons le conteneur en mode détaché (-d), publierons le port 80 du conteneur vers le port 8081 de l'hôte (-p 8081:80), lui attribuerons un nom (my-nginx-volume), et utiliserons l'option -v pour monter le volume. Le format pour monter un volume nommé est nom_volume:chemin_conteneur.

docker run -d --name my-nginx-volume -p 8081:80 -v my-volume:/usr/share/nginx/html nginx

L'ID du conteneur devrait s'afficher, indiquant son exécution.

Créons maintenant un fichier HTML simple dans le volume monté. Nous utiliserons docker exec pour exécuter une commande dans le conteneur. Nous créerons un fichier index.html dans /usr/share/nginx/html avec un contenu basique.

docker exec my-nginx-volume sh -c 'echo "<h1>Bonjour depuis le volume !</h1>" > /usr/share/nginx/html/index.html'

Cette commande exécute un shell (sh -c) dans le conteneur my-nginx-volume et utilise la commande echo pour créer le fichier index.html.

Accédons maintenant au serveur web sur le port 8081 pour voir le contenu du fichier créé.

curl http://localhost:8081

Vous devriez voir <h1>Bonjour depuis le volume !</h1> dans la sortie. Cela confirme que le fichier créé dans le conteneur est bien servi par Nginx, et comme il a été écrit dans le volume monté, les données sont persistantes.

Pour démontrer cette persistance, arrêtons et supprimons le conteneur my-nginx-volume.

docker stop my-nginx-volume
docker rm my-nginx-volume

Lançons maintenant un nouveau conteneur en montant le même volume. Nous le nommerons my-nginx-volume-new et publierons son port 80 vers le port 8082 de l'hôte.

docker run -d --name my-nginx-volume-new -p 8082:80 -v my-volume:/usr/share/nginx/html nginx

Le nouveau conteneur utilise le même volume my-volume. Accédons au serveur sur le port 8082.

curl http://localhost:8082

Vous devriez toujours voir <h1>Bonjour depuis le volume !</h1>. Ceci s'explique car le fichier index.html était stocké dans my-volume, qui a persisté malgré la suppression du conteneur original. Le nouveau conteneur, en montant le même volume, a accès aux données précédemment écrites.

Cette démonstration illustre l'utilité des volumes pour persister les données indépendamment du cycle de vie des conteneurs.

Définir des variables d'environnement et ajouter des entrées d'hôte

Dans cette étape, vous apprendrez à définir des variables d'environnement pour un conteneur Docker et à ajouter des entrées personnalisées au fichier /etc/hosts d'un conteneur. Les variables d'environnement sont couramment utilisées pour configurer les applications exécutées dans des conteneurs, tandis que l'ajout d'entrées d'hôte peut être utile pour la découverte de services ou pour remplacer la résolution DNS au sein du conteneur.

Commençons par arrêter et supprimer le conteneur my-nginx-volume-new de l'étape précédente.

docker stop my-nginx-volume-new
docker rm my-nginx-volume-new

Nous allons maintenant exécuter un conteneur simple et définir une variable d'environnement. Nous utiliserons à nouveau l'image ubuntu et exécuterons une commande affichant la valeur d'une variable d'environnement. Nous définirons une variable nommée MY_VARIABLE avec la valeur hello_docker. L'option -e permet de définir des variables d'environnement au format NOM_VARIABLE=valeur.

docker run --rm -e MY_VARIABLE=hello_docker ubuntu env | grep MY_VARIABLE

Dans cette commande :

• --rm supprime automatiquement le conteneur après son exécution
• -e MY_VARIABLE=hello_docker définit la variable d'environnement
• ubuntu est l'image utilisée
• env affiche toutes les variables d'environnement
• | grep MY_VARIABLE filtre l'affichage pour ne montrer que cette variable

Vous devriez voir MY_VARIABLE=hello_docker s'afficher, confirmant que la variable a bien été définie.

Passons maintenant à l'ajout d'entrées personnalisées dans le fichier /etc/hosts du conteneur. Cela permet de résoudre un nom d'hôte spécifique vers une adresse IP sans dépendre du DNS externe. Nous utilisons l'option --add-host au format nom_hôte:adresse_ip.

Nous allons exécuter un autre conteneur ubuntu et ajouter une entrée associant my-service à 192.168.1.100. Nous afficherons ensuite le contenu du fichier /etc/hosts pour vérifier notre entrée.

docker run --rm --add-host my-service:192.168.1.100 ubuntu cat /etc/hosts | grep my-service

Dans cette commande :

• --rm supprime le conteneur après exécution
• --add-host my-service:192.168.1.100 ajoute l'entrée d'hôte
• ubuntu est l'image utilisée
• cat /etc/hosts affiche le fichier hosts
• | grep my-service filtre l'affichage

Vous devriez voir une ligne similaire à 192.168.1.100 my-service, confirmant que l'entrée a bien été ajoutée.

Il est possible de combiner la définition de variables d'environnement et l'ajout d'entrées d'hôte dans une même commande docker run si nécessaire.

Résumé

Dans ce lab, vous avez appris à utiliser la commande docker run pour gérer des conteneurs. Vous avez commencé par exécuter un conteneur en mode détaché à l'aide du flag -d et lui avez attribué un nom personnalisé avec le flag --name, tout en vérifiant son statut avec docker ps et docker ps -a.

Vous avez ensuite exploré comment :

• Vous connecter à un conteneur en cours d'exécution tout en gardant STDIN ouvert
• Publier les ports du conteneur vers l'hôte avec le flag -p pour permettre l'accessibilité réseau
• Monter un volume avec le flag -v pour assurer la persistance des données au-delà du cycle de vie du conteneur
• Configurer l'environnement du conteneur en définissant des variables d'environnement avec le flag -e
• Ajouter des entrées d'hôte en utilisant le flag --add-host