Dans cette partie de la documentation nous allons voir quelques commandes qui peuvent être effectuées sur les conteneurs.
Pour arrêter un conteneur il suffira d’utiliser la commande suivante
docker container stop "nom_du_conteneur"
ou alors
docker container stop "ID_du_conteneur"
Pour démarrer un conteneur il suffira d’utiliser la commande suivante
docker container start "nom_du_conteneur"
ou alors
docker container start "ID_du_conteneur"
Attention : Cette commande démarrera le conteneur avec toutes les options qui lui avait été passés lors de sa création (les volumes, la redirection de ports, etc.)
Pour supprimer un conteneur il suffira d’utiliser la commande suivante
docker container rm "nom_du_conteneur"
ou alors
docker container rm "ID_du_conteneur"
Pour mettre en pause un conteneur il suffira d’utiliser la commande suivante
docker container pause "nom_du_conteneur"
ou alors
docker container pause "ID_du_conteneur"
Si l’on vérifie l’état du conteneur à l’aide de la commande « docker ps -a » il sera effectivement indiqué comme étant en pause.
Dans cet exemple, le conteneur étant un serveur Web, le site ne sera plus joignable.
Pour retirer la pause un conteneur il suffira d’utiliser la commande suivante
docker container unpause "nom_du_conteneur"
ou alors
docker container unpause "ID_du_conteneur"
Vérification de l’état du conteneur
Le serveur Web est de nouveau joignable.
Pour arrêter de manière « brutale » un conteneur il suffira d’utiliser la commande suivante
docker container kill "nom_du_conteneur"
ou alors
docker container kill "ID_du_conteneur"
Attention : Si on veut effectuer une comparaison de la brutalité de ce type d’arrêt, c’est un peu comme si on débranchait le câble d’un ordinateur alors qu’il est allumé. Ce n’est pas conseillé et il ne va pas apprécier
Dans cette partie de la documentation nous allons voir comment récupérer les informations d’un conteneur et les filtrer pour pouvoir avoir des informations sur les conteneurs.
Pour cela nous utiliserons la commande « docker inspect ». Elle va permettre d’avoir des informations au format JSON sur
Pour commencer nous allons exécuter la commande « docker ps » afin de voir quelles sont les conteneurs à disposition
Nous allons prendre par exemple le conteneur « apache »
Pour voir les informations sur ce conteneur il faudra effectuer la commande suivante
docker inspect "nom_du_conteneur" | more
ou alors
docker inspect "ID_du_conteneur" | more
Attention : le fait d’ajouter « |more » va permettre de faire défiler informations page par page et non tout d’un coup.
Le résultat est le suivant :
Attention : la capture d’écran ne reflète pas l’étendue des informations car il y a plusieurs pages.
Parmi les différentes information on va pouvoir retrouver
Nous venons de voir comment récupérer toutes les informations d’un conteneur.
Celles-ci sont très nombreuses et il n’est pas forcément utile de tout afficher lorsqu’on souhaite avoir des informations bien précises. L’idée est de filtrer les informations que l’on recherche lors de l’exécution de la commande.
Pour cela il faudra utiliser l’option « --format » lors de la saisie de la commande « docker inspect ». Voici quelques exemples
docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "ID_du_conteneur"
ou alors
docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "nom_du_conteneur"
docker inspect --format='{{range .NetworkSettings.Networks}}{{.MacAddress}}{{end}}' "ID_du_conteneur"
ou alors
docker inspect --format='{{range .NetworkSettings.Networks}}{{.MacAddress}}{{end}}' "nom_du_conteneur"
docker inspect --format='{{.LogPath}}' "ID_du_conteneur"
ou
docker inspect --format='{{.LogPath}}' "nom_du_conteneur"
docker inspect --format='{{.Config.Image}}' "ID_du_conteneur"
ou
docker inspect --format='{{.Config.Image}}' "nom_du_conteneur"
docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}} {{$p}} -> {{(index $conf 0).HostPort}} {{end}}' "ID_du_conteneur"
ou
docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}} {{$p}} -> {{(index $conf 0).HostPort}} {{end}}' "nom_du_conteneur"
Attention si aucun mappage de ports n’est présent une erreur s’affichera
docker inspect --format='{{(index (index .NetworkSettings.Ports "N°_de_port_du_conteneur/tcp_ou_udp") 0).HostPort}}' "ID_du_conteneur"
ou
docker inspect --format='{{(index (index .NetworkSettings.Ports "N°_de_port_du_conteneur/tcp_ou_udp ") 0).HostPort}}' "nom_du_conteneur"
Attention : dans la commande il faut spécifier le numéro de port du conteneur
docker inspect --format='{{json .Config}}' "ID_du_conteneur"
Ou
docker inspect --format='{{json .Config}}' "nom_du_conteneur"
docker inspect --format='{{.Name}}' "ID_du_conteneur"
Ou
docker inspect --format='{{.Name}}' "nom_du_conteneur"
La commande « docker attach » permet de se connecter à un conteneur en cours d'exécution à l'aide de son ID ou de son nom pour afficher sa sortie en cours ou pour la contrôler de manière interactive.
Il est possible d’utiliser cette commande plusieurs fois simultanément.
Cette commande est utilisée pour se connecter à un conteneur existant et en cours d’exécution. Lorsque l’on quitte le conteneur avec CTRL-C, on quitte également le processus existant fermant ainsi le conteneur.
Cependant il est possible de se « détacher » d’un conteneur et le laisser fonctionner à l'aide de la séquence de touches « CTRL-P » puis Q si celui-ci a été créé avec une commande permettant d’avoir un bash telle que « /bin/bash ».
« Docker attach » ne sert pas à exécuter une tâche supplémentaire dans un conteneur, mais à se connecter au processus en cours d'exécution.
Regardons les différents conteneurs que nous avons à disposition
Nous avons deux conteneur créés à partir de l’image de Ubuntu qui sont actif.
L’un exécute la commande « top » et l’autre a été créé avec la commande « /bin/bash »
Prenons en premier exemple celui qui exécute la commande top et connectons-nous à celui-ci avec la commande suivante :
docker attach "ID_du_conteneur"
Ou
docker attach "Nom_du_conteneur"
Nous avons donc la vue sur le conteneur et le processus en cours sur ce dernier.
Effectivement ce que nous voyons est la commande « top » qui tourne. Nous ne pouvons cependant pas effectuer de nouvelles commande ni même le quitter à l’aide de « CTRL-Q » puis Q.
En effet, le seul moyen de quitter le conteneur est de faire « CRTL-C », ce qui mettra fin au processus en cours et par la même occasion fermera le conteneur.
Si l’on souhaite que le conteneur redémarre il faudra alors exécuter la commande « docker start ».
Prenons maintenant en deuxième exemple, le deuxième conteneur unbuntu2 qui lui a été créé avec comme argument la commande « /bin/bash ».
Attention : pour qu’il puisse tourner de manière permanente sans s’arrêter lors de l’exécution de la commande « /bin/bash », il a également été créé avec l’option « -it » puis nous l’avons quitté avec « CTRL-P puis Q ».
Comme la commande qui lui a été passée lors de la création est un Shell nous arrivons effectivement sur le Shell du conteneur
Il sera également possible d’y effectuer des commandes
Cette fois-ci, pour quitter le conteneur il sera possible d’effectuer « CTRL-P puis Q » sans arrêter le conteneur.
Attention cependant à la manière dont on quitte le conteneur. En effet si on le quitte en effectuant un « exit », le processus en cours sera arrêté et le conteneur avec lui
« docker exec » est spécialement conçu pour exécuter de nouvelles commandes dans un conteneur déjà démarré, que ce soit un Shell ou un autre processus.
La commande démarrée à l'aide de « docker exec » ne s'exécute que lorsque le processus principal du conteneur (PID 1) est en cours d'exécution, c’est-à-dire qu’elle ne sera pas redémarrée si le conteneur est arrêté puis redémarré.
Evidemment, la commande « docker exec » fonctionne que sur les conteneurs déjà en cours d'exécution.
Si le conteneur est actuellement arrêté, vous devez d'abord le redémarrer et seulement après il sera possible d’exécuter de nouvelles commandes dans un conteneur.
La commande à utiliser est la suivante :
docker exec "ID_du_conteneur"
Ou
docker exec "ID_du_conteneur"
Reprenons en exemple les deux conteneurs précédent : Ubuntu et Ubuntu2
Pour commencer nous allons essayer de se connecter au conteneur Ubuntu avec un Shell. Pour rappel ce dernier d’exécute que la commande « top » et si l’on s’y connecte avec la commande « attach » il ne sera pas possible d’interagir avec lui ni de quitter l’affichage sans l’arrêter.
Il ne s’est rien passé. Tout simplement parce que la commande « /bin/bash » créant le Shell n’a pas été lancée de manière interactive.
Essayons de nouveau mais cette fois de manière interactive comme nous l’avons vu précédemment
Cette fois-ci nous pouvons interagir avec le conteneur et même y exécuter des commandes par l’intermédiaire du Shell que nous venons de lancer.
Pour quitter le conteneur il suffira de faire la combinaison de touches « CTRL-P puis Q »
Que se passerait-il si on quitte cette fois ci le Shell avec la commande « exit »
C’est le Shell que nous avons créé avec le commande « docker exec » qui a été arrêté et non pas la commande « top » qui a été passée lors de la création du conteneur.
De ce fait, nous perdons la main sur le conteneur et son Shell mais celui-ci tourne toujours en exécutant la commande « top »
De la même manière si l’on exécute une commande qui s’arrêtera automatiquement, le conteneur ne s’arrêtera pas.
Essayons avec le conteneur ubuntu2 qui lui a été créé avec la commande « /bin/bash » permettant d’avoir un Shell actif.
La commande « apt upgrade -y » s’est correctement exécutée puis arrêtée mais pas le conteneur.
Le « commit » de conteneur consiste à créer une nouvelle image à partir d’un conteneur.
En effet, il peut être utile parfois de créer une nouvelle image afin de valider les modifications ou les paramètres d’un conteneur permettant ainsi d’éviter de recommencer ces manipulations dans les prochains conteneurs. Dans ce cas précis on peut assimiler l’image à un Template qui servira de base pour les prochains conteneurs du même type.
Cette manipulation n’inclue aucune données contenues dans des volumes montés à l'intérieur du conteneur.
Le conteneur devra être arrêté pendant la création de l'image ce qui réduit le risque de corruption des données pendant le processus de création du commit.
Nous allons prendre comme exemple, le conteneur d’un serveur Web Nginx.
Ce dernier a été créé à l’aide de la commande suivante :
Et il est actuellement en cours d’exécution
Nous allons modifier le fichier index.html de ce conteneur à l’aide de la commande « docker exec »
Nous pouvons vérifier l’affichage de la page Web depuis une autre machine en tapant l’adresse IP de l’hôte et le port de redirection indiqué à la création du conteneur Nginx.
Supposons que nos modifications soient correctes et correspondent à la page d’accueil du site Web que nous voulons avoir.
Dans ce cas nous allons pouvoir effectuer un « commit » du conteneur pour en faire une image qui aura les modifications apportées. Cela permettra de pouvoir redéployer notre site Web sans avoir à effectuer de nouveau les modifications.
Pour cela nous utiliserons la commande suivante :
docker commit "ID_du_conteneur" "Tag_du_conteneur"
ou
docker commit "nom_du_conteneur" "Tag_du_conteneur"
Attention : dans cet exemple le Tag correspond au registre local que nous avions installé précédemment. Cela permettra de push l’image dans le registre
Nous pouvons vérifier si une nouvelle image est présente à l’aide de la commande « docker images »
Il est possible de réutiliser cette image pour créer des conteneurs. Ces derniers auront donc les modifications apportées précédemment.
Le conteneur est bien présent et en cours d’exécution.
Vérifions le résultat de la page d’accueil du site depuis une autre machine.
La création d’une image à partir du conteneur modifié a correctement fonctionnée ainsi que la création d’un nouveau conteneur depuis cette image.
Dans le cas où vous auriez un registre local il sera même possible de « push » l’image dans ce dernier