Comment utiliser la commande docker context inspect pour visualiser les détails d'un contexte

Introduction

Dans ce lab, nous allons explorer comment utiliser la commande docker context inspect pour afficher des informations détaillées sur les contextes Docker. Les contextes Docker sont essentiels pour gérer les connexions à différents démons Docker. Nous commencerons par inspecter le contexte Docker par défaut, qui se connecte au démon local.

Ensuite, nous créerons un nouveau contexte à des fins de démonstration, puis nous utiliserons docker context inspect pour examiner ses détails par nom. Enfin, nous apprendrons comment formater la sortie de la commande inspect de différentes manières, notamment en JSON et en utilisant un template Go, pour extraire des informations spécifiques sur un contexte.

Skills Graph

Inspecter le contexte Docker par défaut

Dans cette étape, nous allons explorer le contexte Docker par défaut. Un contexte Docker est un moyen de gérer les connexions à différents démons Docker. Par défaut, Docker utilise un contexte nommé default qui se connecte au démon Docker local.

Pour inspecter le contexte Docker par défaut, nous utilisons la commande docker context inspect suivie du nom du contexte.

docker context inspect default

Cette commande affichera des informations détaillées sur le contexte default, y compris son endpoint, son type et d'autres détails de configuration. Le résultat sera au format JSON.

[
  {
    "Name": "default",
    "Current": true,
    "Endpoint": {
      "Docker": {
        "Host": "unix:///var/run/docker.sock"
      }
    },
    "Metadata": {},
    "Storage": "meta/contexts/default"
  }
]

Le résultat montre que le contexte default est le contexte actuel ("Current": true) et que son endpoint est défini sur unix:///var/run/docker.sock, qui est le socket Unix par défaut pour le démon Docker sur les systèmes Linux.

Créer un nouveau contexte à des fins de démonstration

Dans cette étape, nous allons créer un nouveau contexte Docker. La création d'un nouveau contexte vous permet de définir une connexion à un démon Docker différent, qui peut se trouver sur une machine distante ou avoir une configuration différente sur la même machine. Pour cette démonstration, nous créerons un contexte qui pointe toujours vers le démon Docker local, mais avec un nom différent.

Pour créer un nouveau contexte, nous utilisons la commande docker context create suivie du nom du nouveau contexte et des informations d'endpoint. Comme nous nous connectons au démon local, l'endpoint sera le même que pour le contexte par défaut : unix:///var/run/docker.sock.

Créons un nouveau contexte nommé my-context.

docker context create my-context --docker "host=unix:///var/run/docker.sock"

Après avoir exécuté cette commande, vous devriez voir une sortie indiquant que le contexte a été créé.

my-context

Cela confirme qu'un nouveau contexte nommé my-context a été créé avec succès, pointant vers le démon Docker local.

Inspecter le nouveau contexte par son nom

À l'étape précédente, nous avons créé un nouveau contexte Docker nommé my-context. Maintenant, inspectons ce contexte nouvellement créé pour voir ses détails. Comme pour l'inspection du contexte par défaut, nous utilisons la commande docker context inspect, mais cette fois en spécifiant le nom de notre nouveau contexte.

docker context inspect my-context

Cette commande affichera les détails de configuration du contexte my-context que nous venons de créer. Le résultat sera à nouveau au format JSON.

[
  {
    "Name": "my-context",
    "Current": false,
    "Endpoint": {
      "Docker": {
        "Host": "unix:///var/run/docker.sock"
      }
    },
    "Metadata": {},
    "Storage": "meta/contexts/my-context"
  }
]

Notez que le résultat pour my-context est similaire à celui du contexte default, car les deux pointent vers le démon Docker local. Cependant, le champ "Current" est à false pour my-context, indiquant qu'il n'est pas le contexte actuellement actif. Le contexte default reste celui qui est actif.

Inspecter le contexte et formater la sortie en JSON

Dans cette étape, nous allons explicitement demander que la sortie de la commande docker context inspect soit au format JSON. Bien que la sortie par défaut soit déjà en JSON, utiliser le flag --format json est une bonne pratique lorsque vous avez spécifiquement besoin d'un format JSON, par exemple pour rediriger la sortie vers d'autres outils pour traitement.

Nous allons inspecter le contexte my-context créé précédemment et formater la sortie en JSON.

docker context inspect my-context --format json

Cette commande produira le même résultat JSON que dans l'étape précédente, mais elle démontre explicitement comment utiliser le flag --format pour spécifier le format de sortie.

[
  {
    "Name": "my-context",
    "Current": false,
    "Endpoint": {
      "Docker": {
        "Host": "unix:///var/run/docker.sock"
      }
    },
    "Metadata": {},
    "Storage": "meta/contexts/my-context"
  }
]

L'utilisation du flag --format json est particulièrement utile lorsque vous souhaitez analyser programmatiquement la sortie des commandes Docker.

Inspecter le contexte et formater la sortie à l'aide d'un template Go

Dans cette dernière étape, nous allons explorer comment formater la sortie de docker context inspect en utilisant un template Go. Cette fonctionnalité puissante vous permet d'extraire des informations spécifiques de la sortie JSON et de les afficher dans un format personnalisé.

Nous allons inspecter le contexte my-context et utiliser un template Go pour afficher uniquement le nom du contexte et l'endpoint Docker host. La syntaxe du template utilise des doubles accolades {{ }} pour encadrer les expressions. Nous pouvons accéder aux champs de la sortie JSON en utilisant la notation par points, par exemple .Name pour le nom du contexte et .Endpoint.Docker.Host pour l'endpoint Docker host.

docker context inspect my-context --format '{{.Name}}: {{.Endpoint.Docker.Host}}'

Cette commande utilisera le template Go fourni pour formater la sortie. Vous devriez voir le nom du contexte suivi de son endpoint Docker host.

my-context: unix:///var/run/docker.sock

Cela démontre comment les templates Go peuvent être utilisés pour personnaliser la sortie des commandes Docker, facilitant ainsi l'extraction et le traitement de données spécifiques.

Résumé

Dans ce lab, nous avons appris à utiliser la commande docker context inspect pour visualiser les détails des contextes Docker. Nous avons commencé par inspecter le contexte par défaut, qui se connecte au démon Docker local. Nous avons ensuite créé un nouveau contexte nommé my-context à des fins de démonstration, pointant également vers le démon local.

Nous avons approfondi notre exploration de la commande docker context inspect en inspectant le nouveau contexte créé par son nom. Enfin, nous avons démontré comment formater la sortie de la commande inspect de différentes manières, notamment en JSON et en utilisant un template Go, pour extraire et afficher des informations spécifiques sur un contexte.