Comment lister les modules Docker Desktop avec la commande docker version

Introduction

Dans ce labo (lab), vous apprendrez à lister les modules de Docker Desktop en utilisant la commande docker version. Nous explorerons différentes méthodes pour visualiser ces informations, notamment lister tous les modules, afficher le résultat au format JSON et extraire uniquement les ID des modules. Cet exercice pratique vous aidera à comprendre les composants de votre installation Docker et comment récupérer des informations à leur sujet.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/SystemManagementGroup(["System Management"]) docker/SystemManagementGroup -.-> docker/version("Show Docker Version") subgraph Lab Skills docker/version -.-> lab-555144{{"Comment utiliser la commande docker desktop module ls pour lister les modules"}} end

Lister tous les modules de Docker Desktop

Dans cette étape, nous allons apprendre à lister tous les modules de Docker Desktop en utilisant la commande docker version. La commande docker version fournit des informations détaillées sur l'installation Docker, y compris les composants client et serveur, ainsi que les modules faisant partie de l'installation Docker Desktop.

Pour lister tous les modules de Docker Desktop, ouvrez votre terminal et exécutez la commande suivante :

docker version

Cette commande affichera de nombreuses informations sur votre installation Docker. Recherchez les sections comme Client et Server. Dans ces sections, vous trouverez des détails sur les différents composants et modules.

Par exemple, le résultat pourrait ressembler à ceci (le résultat exact peut varier selon votre version de Docker et votre installation) :

Client: Docker Engine - Community
 Version:           20.10.21
 API version:       1.41
 Go version:        go1.16.15
 Git commit:        f2213a1
 Built:             Thu Oct 27 00:18:36 2022
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.21
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.16.15
  Git commit:       3056e8c
  Built:            Thu Oct 27 00:17:23 2022
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.8
  GitCommit:        9cd358bba7fd9c7bb19904ba6d2f58fd60b1ca2b
 runc:
  Version:          1.1.4
  GitCommit:        v1.1.4-0-g5fd4c4d
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

Dans ce résultat, vous pouvez voir des informations sur Docker Engine, containerd, runc et docker-init. Ce sont quelques-uns des principaux modules qui composent l'environnement Docker. La commande docker version est un outil utile pour comprendre les différents composants de votre installation Docker et leurs versions.

Lister les modules Docker Desktop au format JSON

Dans l'étape précédente, nous avons utilisé la commande docker version pour lister les modules Docker Desktop. Le résultat par défaut est lisible par un humain, mais parfois vous pourriez avoir besoin d'un format structuré comme JSON pour des scripts ou un traitement ultérieur.

La commande docker version prend en charge un drapeau --format qui permet de spécifier le format de sortie en utilisant le package text/template de Go. Pour obtenir le résultat au format JSON, vous pouvez utiliser le modèle json ..

Exécutez la commande suivante dans votre terminal :

docker version --format '{{json .}}'

Cette commande affichera les mêmes informations que docker version, mais formatées comme un objet JSON. La partie {{json .}} est le modèle qui indique à Docker de formater l'ensemble du résultat (.) en JSON.

Le résultat sera une seule ligne de données JSON, qui pourrait ressembler à ceci (formaté pour une meilleure lisibilité) :

{
  "Client": {
    "Version": "20.10.21",
    "ApiVersion": "1.41",
    "GoVersion": "go1.16.15",
    "GitCommit": "f2213a1",
    "Built": "Thu Oct 27 00:18:36 2022",
    "OsArch": "linux/amd64",
    "Context": "default",
    "Experimental": true
  },
  "Server": {
    "Engine": {
      "Version": "20.10.21",
      "ApiVersion": "1.41",
      "MinAPIVersion": "1.12",
      "GoVersion": "go1.16.15",
      "GitCommit": "3056e8c",
      "Built": "Thu Oct 27 00:17:23 2022",
      "OsArch": "linux/amd64",
      "Experimental": false
    },
    "Containerd": {
      "Version": "1.6.8",
      "GitCommit": "9cd358bba7fd9c7bb19904ba6d2f58fd60b1ca2b"
    },
    "Runc": {
      "Version": "1.1.4",
      "GitCommit": "v1.1.4-0-g5fd4c4d"
    },
    "DockerInit": {
      "Version": "0.19.0",
      "GitCommit": "de40ad0"
    }
  }
}

Ce résultat JSON contient les mêmes informations que le résultat par défaut, mais dans un format structuré facile à analyser par des programmes. Cela est particulièrement utile lorsque vous souhaitez extraire des informations spécifiques du résultat de docker version dans des scripts.

Lister uniquement les IDs des modules Docker Desktop

Dans les étapes précédentes, nous avons appris à lister tous les modules Docker Desktop et à formater la sortie en JSON. Voyons maintenant comment extraire uniquement des informations spécifiques, comme les IDs de commit Git des modules. Ceci est utile lorsque vous n'avez besoin que d'une donnée particulière pour des scripts ou de l'automatisation.

Nous pouvons à nouveau utiliser le drapeau --format avec un modèle personnalisé pour y parvenir. En examinant la sortie JSON de l'étape précédente, nous voyons que les IDs de commit Git se trouvent sous Server.Engine.GitCommit, Server.Containerd.GitCommit, Server.Runc.GitCommit et Server.DockerInit.GitCommit.

Nous pouvons construire un modèle pour extraire ces champs spécifiques. Exécutez la commande suivante dans votre terminal :

docker version --format 'Engine GitCommit: {{.Server.Engine.GitCommit}}\nContainerd GitCommit: {{.Server.Containerd.GitCommit}}\nRunc GitCommit: {{.Server.Runc.GitCommit}}\nDockerInit GitCommit: {{.Server.DockerInit.GitCommit}}'

Décomposons le modèle :

Engine GitCommit: {{.Server.Engine.GitCommit}} : Cette partie extrait la valeur GitCommit de l'objet Engine dans l'objet Server.
\n : Ajoute un caractère de nouvelle ligne pour séparer les sorties de chaque module.
Containerd GitCommit: {{.Server.Containerd.GitCommit}} : Extrait le GitCommit pour containerd.
Runc GitCommit: {{.Server.Runc.GitCommit}} : Extrait le GitCommit pour runc.
DockerInit GitCommit: {{.Server.DockerInit.GitCommit}} : Extrait le GitCommit pour docker-init.

La sortie affichera l'ID de commit Git pour chaque module spécifié, similaire à ceci :

Engine GitCommit: 3056e8c
Containerd GitCommit: 9cd358bba7fd9c7bb19904ba6d2f58fd60b1ca2b
Runc GitCommit: v1.1.4-0-g5fd4c4d
DockerInit GitCommit: de40ad0

Ceci démontre la puissance du drapeau --format et des modèles Go pour extraire des données spécifiques des commandes Docker. Vous pouvez personnaliser le modèle pour extraire n'importe quel champ disponible dans la sortie de docker version.

Résumé

Dans ce lab, nous avons appris à lister les modules Docker Desktop en utilisant la commande docker version. Nous avons exploré comment afficher tous les modules et leurs détails, ce qui fournit des informations précieuses sur les différents composants de l'installation Docker, tels que Docker Engine, containerd, runc et docker-init, ainsi que leurs versions.

Nous avons également appris à lister les modules Docker Desktop au format JSON, ce qui est utile pour un traitement programmatique et une intégration avec d'autres outils. Enfin, nous avons vu comment lister uniquement les IDs des modules Docker Desktop, fournissant ainsi une sortie concise pour une identification rapide.