Il est très important que vous connaissiez toujours la version de Docker sur laquelle vous travaillez à tout moment.

C'est très utile car cela vous permet de savoir quelles fonctionnalités sont compatibles avec ce que vous utilisez. C'est également important car vous savez quels conteneurs exécuter à partir du docker store lorsque vous essayez d'obtenir des conteneurs modèles.

Obtenir la version du serveur :

$ docker version --format '{{.Server.Version}}'
1.8.0

Vous pouvez également transmettre des données brutes JSON :

$ docker version --format '{{json .}}'
{"Client":{"Version":"1.8.0","ApiVersion":"1.20","GitCommit":"f5bae0a","GoVersion":"go1.4.2","Os":"linux","Arch":"am"}

docker start démarre un conteneur pour qu'il soit en cours d'exécution.

docker stop arrête un conteneur en cours d'exécution.

docker restart arrête et démarre un conteneur.

docker pause met en pause un conteneur en cours d'exécution.

docker unpause met en pause un conteneur en cours d'exécution.

docker wait bloque jusqu'à ce que le conteneur en cours d'exécution s'arrête.

docker kill envoie un SIGKILL à un conteneur en cours d'exécution.

docker attach se connecte à un conteneur en cours d'exécution.

• Si vous voulez vous détacher d'un conteneur en cours d'exécution, utilisez Ctrl + p, Ctrl + q.
• Si vous voulez intégrer un conteneur avec un gestionnaire de processus hôte, démarrez le démon avec -r=false puis utilisez docker start -a.

Pour utiliser vos conteneurs dans Docker, vous devez d'abord les démarrer. La commande “docker start” vous permet de le faire très rapidement, comme illustré dans l'exemple suivant.

$ docker start CONTAINER_ID

Ici, CONTAINER_ID est l'ID de votre conteneur. Vous l'obtiendrez lorsque vous exécuterez la commande “docker ps -a”.

Vous pouvez facilement arrêter un conteneur actif à l'aide de la commande “docker stop”. C'est l'une des commandes de docker les plus utiles pour les débutants car elle permet de quitter facilement un conteneur en cours d'exécution. La commande suivante vous montre comment cela fonctionne.

$ docker stop CONTAINER_ID

Une autre solution simple consiste à simplement quitter le conteneur en utilisant “Ctrl + D” ou en tapant “exit” à l'intérieur du conteneur.

Docker permet également aux utilisateurs de tuer un conteneur en cours d'exécution. La différence entre arrêter un conteneur et en tuer un est assez subtile, du moins dans Docker. Lorsque vous utilisez “docker stop”, il termine d'abord les processus en cours d'exécution à l'intérieur du conteneur, puis termine le conteneur.

$ docker kill CONTAINER_ID

Mais, la commande “docker kill” tue l'intégralité du processus de conteneur en cours d'exécution sur la machine hôte. Cela peut entraîner une mauvaise configuration indésirable ou corrompre les processus de conteneur. Soyez donc prudent lorsque vous utilisez de telles commandes de docker.

Une fois démarré avec succès, vous devrez vous connecter à ce conteneur pour pouvoir l'utiliser. La commande “docker attach” est là pour cela. La commande suivante vous montre comment vous connecter au conteneur que vous avez créé précédemment.

$ docker attach CONTAINER_ID

Cela entraînera une modification de votre invite. Et vous êtes maintenant dans un conteneur basé sur Ubuntu Xenial. Ce que vous faites à l'intérieur de ce conteneur restera à l'intérieur. Vous pouvez vérifier le conteneur en exécutant : “cat /etc/issue”.

Vous pouvez limiter le CPU, soit en utilisant un pourcentage de tous les CPU, soit en utilisant des cœurs spécifiques.

Par exemple, vous pouvez indiquer le paramètre cpu-shares. Le paramètre est un peu étrange – 1024 signifie 100% du CPU, donc si vous voulez que le conteneur prenne 50% de tous les cœurs du CPU, vous devez spécifier 512.

# docker run -it -c 512 agileek/cpuset-test

Vous pouvez également n'utiliser que certains cœurs de CPU en utilisant cpuset-cpus.

docker run -it --cpuset-cpus=0,4,6 agileek/cpuset-test

Vous pouvez également définir des contraintes de mémoire sur Docker :

# docker run -it -m 300M ubuntu:14.04 /bin/bash

Pour vérifier l'utilisation du processeur, de la mémoire et des E/S réseau d'un seul conteneur, vous pouvez utiliser :

# docker stats <conteneur>

Pour tous les conteneurs répertoriés par ID :

# docker stats $(docker ps -q)

Pour tous les conteneurs répertoriés par nom :

# docker stats $(docker ps --format '{{.Names}}')

La commande “docker events” permet aux développeurs de surveiller les serveurs pour obtenir des informations en temps réel sur les conteneurs, les images, les plugins et bien d'autres.

Vous pouvez essayer cela sur votre système à l'aide de la ligne de commande.

$ docker events

Entrez la commande ci-dessus dans le premier shell.

Faites maintenant apparaître un conteneur docker dans un autre shell.

Exécutez certaines commandes docker à l'intérieur de ce conteneur et vous recevrez des notifications en temps réel dans le premier terminal.

Comme indiqué précédemment, les images sont les éléments constitutifs des conteneurs Docker. Ainsi, vous pouvez facilement afficher les historiques d'images pour détecter les problèmes soudains dans un conteneur.

Il est simple d'utiliser cette commande.

$ docker history IMAGE_ID

Obtenez simplement l'ID d'image du conteneur à l'aide de “docker ps” et utilisez-le comme indiqué ci-dessus. Il montrera comment l'image actuelle est créée.

docker images affiche toutes les images.

docker import crée une image à partir d'une archive.

docker build crée une image à partir d'un Dockerfile.

docker commit crée une image à partir d'un conteneur, en le mettant temporairement en pause s'il est en cours d'exécution.

docker rmi supprime une image.

docker load charge une image à partir d'une archive tar en tant que STDIN, y compris les images et les balises (à partir de 0.7).

docker save enregistre une image dans un flux d'archives tar vers STDOUT avec toutes les couches parentes, les étiquettes et les versions (à partir de 0.7).

docker history montre l'historique de l'image.

docker tag marque une image à un nom (local ou registre).

Charge une image à partir d'un fichier :

# docker load < mon_image.tar.gz
<code bash>
 
Sauvegarder une image existante :
<code bash>
# docker save mon_image:mon_tag | gzip > mon_image.tar.gz

Importez un conteneur en tant qu'image à partir d'un fichier :

# cat mon_conteneur.tar.gz | docker import - mon_image:mon_tag

Exportez un conteneur existant :

# docker export my_container | gzip > my_container.tar.gz

Le chargement d'une image à l'aide de la commande load crée une nouvelle image incluant son historique. L'importation d'un conteneur en tant qu'image à l'aide de la commande import crée une nouvelle image sans l'historique, ce qui réduit la taille de l'image par rapport au chargement d'une image.

Bien que vous puissiez utiliser la commande docker rmi pour supprimer des images spécifiques, il existe un outil appelé docker-gc qui nettoie en toute sécurité les images qui ne sont plus utilisées par aucun conteneur.

Depuis la version 1.13 de docker, docker image prune est également disponible pour supprimer les images inutilisées.

Étant donné que les conteneurs sont comme un petit morceau de machines virtuelles, vous pouvez facilement les supprimer sans faire face aux conséquences sur la machine hôte. Utilisez la commande suivante pour supprimer le conteneur que vous avez créé précédemment.

$ docker rm CONTAINER_ID

Il supprimera le conteneur instantanément. Cependant, tous vos fichiers et configurations créés à l'intérieur de ce conteneur seront également supprimés. Assurez-vous donc de les déplacer ailleurs si vous en avez besoin dans un futur proche.

Parfois, vous souhaiterez peut-être supprimer une ou plusieurs images de docker qui ne sont plus nécessaires. La commande suivante montre comment procéder.

$ docker rmi <IMAGE_ID>

Cependant, si l'image est balisée par plusieurs référentiels, vous devrez la supprimer de la manière suivante.

$ docker rmi REPOSITORY:TAG

Vous pouvez trouver ces informations lorsque vous exécutez la commande docker images.

Utilisez la commande docker images avec le paramètre -a pour localiser l'ID des images que vous voulez supprimer. Cela vous montrera toutes les images, y compris les couches d'images intermédiaires. Lorsque vous avez localisé les images que vous voulez supprimer, vous pouvez passer leur ID ou leur étiquette à docker rmi :

Lister :

# docker images -a

Supprimer :

# docker rmi <Image> <Image>

Les images de Docker sont constituées de plusieurs couches. Les images en suspens sont des couches qui n'ont aucune relation avec les images marquées. Elles n'ont plus d'utilité et consomment de l'espace disque. Elles peuvent être localisées en ajoutant le paramètre filtre, -f avec une valeur de dangling=true à la commande docker images.

Lorsque vous êtes sûr de vouloir les supprimer, vous pouvez utiliser la commande docker images purge :

Lister :

# docker images -f dangling=true

Supprimer :

# docker images purge

Vous pouvez trouver toutes les images qui correspondent à un modèle en utilisant une combinaison de docker images et grep. Une fois que vous êtes satisfait, vous pouvez les supprimer en utilisant awk pour passer les identifiants à docker rmi.

Notez que ces utilitaires ne sont pas fournis par Docker et ne sont pas nécessairement disponibles sur tous les systèmes :

Lister :

# docker images -a |  grep "pattern"

Supprimer :

# docker images -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

Toutes les images de Docker sur un système peuvent être listées en ajoutant -a à la commande docker images. Une fois que vous êtes sûr de vouloir toutes les supprimer, vous pouvez ajouter le drapeau -q pour passer l'ID de l'image au docker rmi :

Lister :

# docker images -a

Supprimer :

# docker rmi $(docker images -a -q)

Utilisez la commande docker ps avec le drapeau -a pour localiser le nom ou l'ID des conteneurs que vous voulez supprimer.

Lister :

# docker ps -a

Supprimer :

# docker rm <ID_or_Name> <ID_or_Name>

Si vous savez, lorsque vous créez un conteneur, que vous ne voudrez pas le conserver une fois que vous aurez terminé, vous pouvez lancer le programme docker run –rm pour le supprimer automatiquement à sa sortie.

Exécuter et supprimer :

# docker run --rm <image_name>

Vous pouvez localiser les conteneurs en utilisant le docker ps -a et les filtrer selon leur statut : créé, redémarré, en cours d'exécution, en pause ou quitté.

Pour consulter la liste des conteneurs quittés, utilisez le paramètre -f pour filtrer en fonction de leur statut. Lorsque vous avez vérifié que vous voulez supprimer ces conteneurs, utilisez -q pour transmettre les ID à la commande docker rm.

Lister :

# docker ps -a -f status=exited

Supprimer :

# docker rm $(docker ps -a -f status=exited -q)

Les filtres de Docker peuvent être combinés en répétant le drapeau filter avec une valeur supplémentaire. Il en résulte une liste de conteneurs qui remplissent l'une ou l'autre de ces conditions.

Par exemple, si vous voulez supprimer tous les conteneurs marqués comme étant soit Créé (un état qui peut survenir lorsque vous exécutez un conteneur avec une commande non valide) soit Quitté, vous pouvez utiliser deux filtres :

Lister :

# docker ps -a -f status=exited -f status=created

Supprimer :

# docker rm $(docker ps -a -f status=exited -f status=created -q)

Vous pouvez trouver tous les containers qui correspondent à un modèle en utilisant une combinaison de docker ps et grep. Lorsque vous êtes satisfait de la liste que vous souhaitez supprimer, vous pouvez utiliser awk et xargs pour fournir l'ID à docker rmi.

Lister :

# docker ps -a |  grep "pattern”

Supprimer :

# docker ps -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

Vous pouvez consulter les conteneurs sur votre système avec docker ps. L'ajout du paramètre -a affichera tous les conteneurs. Lorsque vous êtes sûr de vouloir les supprimer, vous pouvez ajouter le drapeau -q pour fournir les identifiants aux commandes docker start et docker rm :

Lister :

# docker ps -a

Supprimer :

# docker stop $(docker ps -a -q)
# docker rm $(docker ps -a -q)

Docker possède une fonctionnalité de réseaux. Docker crée automatiquement 3 interfaces réseau lorsque vous l'installez (bridge, host, none). Un nouveau conteneur est lancé dans le réseau bridge par défaut.

Pour permettre la communication entre plusieurs conteneurs, vous pouvez créer un nouveau réseau et y lancer des conteneurs.

Cela permet aux conteneurs de communiquer entre eux tout en étant isolés des conteneurs qui ne sont pas connectés au réseau. En outre, cela permet de faire correspondre les noms des conteneurs à leurs adresses IP.

docker network create NOM Crée un nouveau réseau (type par défaut : pont).

docker network rm NOM Supprime un ou plusieurs réseaux par nom ou identifiant. Aucun conteneur ne peut être connecté au réseau lors de sa suppression.

docker network ls Liste des réseaux.

docker network inspect NOM Affiche des informations détaillées sur un ou plusieurs réseaux.

docker network connect CONTAINER NETWORK Connecter un conteneur à un réseau.

docker network disconnect NETWORK CONTAINER Déconnecte un conteneur d'un réseau.

Vous pouvez communiquer avec vos conteneurs directement à partir de l'hôte sans utiliser le runtime du docker. Cela fonctionne en utilisant une sorte de schémas de mise en réseau définis par l'administrateur.

L'exposition de certains ports pour le conteneur est une telle technique largement répandue.

$ docker run --name NEW nginx -p 8080:80

La commande ci-dessus crée un conteneur nommé NEW et lie son port 80 au port 8080 du système hôte.

Ainsi, vous pourrez désormais envoyer des demandes/réponses à votre conteneur à l'aide de ce port.

Vous pouvez spécifier une adresse IP spécifique pour un conteneur.

Créer un nouveau réseau de pont avec votre sous-réseau et votre passerelle pour votre bloc d'ip :

# docker network create --subnet 203.0.113.0/24 --gateway 203.0.113.254 iptastic

Exécuter un conteneur nginx avec une ip spécifique dans ce bloc

# docker run --rm -it --net iptastic --ip 203.0.113.2 nginx

curl l'ip à partir de n'importe quel autre endroit (en supposant que c'est un bloc d'ip publique duh)

# curl 203.0.113.2

Un repository est une collection hébergée d'images balisées qui, ensemble, créent le système de fichiers d'un conteneur.

Un registre (registry) est un hôte, c'est-à-dire un serveur qui stocke les repositories et fournit une API HTTP pour gérer le chargement et le téléchargement des repo.

docker login pour se connecter à un registre.

docker logout pour se déconnecter d'un registre.

docker search recherche une image dans le registre.

docker pull extrait une image du registre vers la machine locale.

docker push pousse une image vers le registre depuis la machine locale.

Les volumes Docker sont des systèmes de fichiers flottants. Ils n'ont pas besoin d'être connectés à un conteneur particulier. Vous pouvez utiliser des volumes montés à partir de conteneurs de données uniquement pour des raisons de portabilité. Depuis la version 1.9.0 de Docker, Docker dispose de volumes nommés qui remplacent les conteneurs de données uniquement. Envisagez d'utiliser des volumes nommés pour l'implémenter plutôt que des conteneurs de données.

docker volume create

docker volume rm

docker volume ls

docker volume inspect

Les volumes sont utiles dans les situations où vous ne pouvez pas utiliser les liens (qui sont uniquement TCP/IP). Par exemple, si vous avez besoin que deux instances docker communiquent en laissant des choses sur le système de fichiers.

Vous pouvez les monter dans plusieurs conteneurs docker à la fois, en utilisant docker run –volumes-from.

Les volumes étant des systèmes de fichiers isolés, ils sont souvent utilisés pour stocker l'état des calculs entre les conteneurs transitoires. En d'autres termes, vous pouvez faire exécuter un conteneur sans état et transitoire à partir d'une recette, le faire sauter, puis faire en sorte qu'une deuxième instance du conteneur transitoire reprenne là où le dernier s'est arrêté.

# docker inspect $(dl) | grep -wm1 IPAddress | cut -d '"' -f 4

Ou avec jq installé :

#docker inspecte $(dl) | jq -r '.[0].NetworkSettings.IPAddress' -f 4

Ou en utilisant un modèle go :

# docker inspect -f '{{ .NetworkSettings.IPAddress }}'' <nom_du_conteneur>

# docker inspect -f '{{range $p, $conf := .NetworkSettings.Ports}} {{$p}} -> {{(index $conf 0).HostPort}} {{end}}' <containername>

Souvent, vous souhaiterez peut-être copier les fichiers de configuration de votre produit actuel à partir du conteneur et du système de fichiers ou même d'autres conteneurs. La commande “docker cp” vous permet de le faire. Elle agit comme la commande Unix cp -a et copie le contenu de manière récursive.

$ docker cp CONTAINER_ID:/test_file test_file

Cette commande copiera le test_file du conteneur avec CONTAINER_ID sur la machine hôte. Le suivant nous montre comment copier un document de l'hôte vers un conteneur.

$ docker cp test_file CONTAINER_ID:/test_file

Bien que vous puissiez exécuter des commandes directement à partir d'un conteneur en cours d'exécution, vous pouvez ne pas vouloir attacher des conteneurs tout le temps, surtout si vous avez des centaines de conteneurs. Puisqu'il s'agit d'un scénario courant, le docker runtime fournit une commande robuste pour exécuter des commandes spécifiques au conteneur à partir de l'instance de terminal de l'administrateur.

$ docker exec commande CONTAINER_ID

Cela vous permettra d'exécuter la commande à l'intérieur du conteneur CONTAINER_ID.

Les images Docker sont la pierre angulaire des conteneurs. Comme vous devez vous en souvenir, les conteneurs sont créés en utilisant une image comme base. Il est normal que les développeurs disposent de plusieurs images Docker sur leurs systèmes.

La commande suivante nous montre comment lister toutes les images de votre machine.

$ docker images

Le simple fait d'appeler cette commande affichera toutes les images de docker de niveau supérieur avec leur taille, leurs balises et leur référentiel. L'option -q peut être utilisée uniquement pour récupérer l'IMAGE_ID.

Ainsi, lorsque nous supprimons un conteneur, toutes les données qui lui sont associées sont perdues. Docker permet aux développeurs de créer des «volumes» qui fournissent un stockage persistant pour ces données. Les volumes sont simplement un mécanisme qui lie votre conteneur à un espace prédéfini sur votre système de fichiers.

$ docker create -it -v $ (pwd):/var/www ubuntu:xenial bash

L'exécution de la commande ci-dessus liera votre répertoire de travail actuel à l'emplacement “/var/www” de votre conteneur.

Vous pouvez maintenant modifier des fichiers dans votre répertoire actuel et les changements seront reflétés dans Docker.

Jusqu'à présent, nous avons d'abord créé nos conteneurs Docker, puis nous les avons démarrés. Cependant, docker nous permet de faire les deux en utilisant une seule commande.

Consultez l'exemple ci-dessous pour voir comment cela fonctionne.

$ docker run -it -d ubuntu:xenial bash

Lorsque vous exécutez cette commande, elle récupère l'image Xenial, crée le conteneur et la démarre avec bash. Cependant, vous ne verrez pas l'effet directement dans votre terminal.

En effet, nous avons demandé au docker d'exécuter ce conteneur en arrière-plan à l'aide de l'indicateur “-d”. L'éliminer vous amènera au conteneur dès qu'il sera créé.

L'option "--name" peut être utilisée pour créer des conteneurs portant des noms spécifiques. Vous pouvez les utiliser en remplacement de CONTAINER_ID pour la plupart des commandes docker.

La commande suivante le montre en action.

$ docker create --name TEST nginx

Cette commande va extraire l'image Nginx de Docker Hub et créer le conteneur appelé TEST dans ce cas. Vous pouvez maintenant le démarrer et attacher votre session pour utiliser le conteneur. Il en va de même avec la commande “docker run”.

Souvent, la moindre mauvaise configuration peut entraîner des problèmes indésirables et prendre des heures à déboguer. La commande “docker diff” est très pratique dans de nombreux cas. Vous pouvez l'utiliser pour inspecter toute modification du système de fichiers de votre conteneur.

$ docker diff CONTAINER_ID

Donc, si vous savez avec certitude qu'un certain conteneur est entièrement sain, vous pouvez utiliser cette commande de temps en temps pour afficher les modifications dans le système de fichiers de ce conteneur.

Docker permet aux développeurs de créer une image entièrement nouvelle basée sur les modifications d'un conteneur déjà existant. Cela sera utilisé lorsque vous souhaitez créer plusieurs conteneurs pour différentes phases de votre application.

$ docker commit CONTAINER_ID REPOSITORY:TAG

La commande ci-dessus créera une nouvelle image à l'aide du conteneur CONTAINER_ID.

https://docs.docker.com/engine/reference/commandline/docker/