Cómo usar el comando docker context inspect para ver detalles del contexto

Introducción

En este laboratorio, exploraremos cómo utilizar el comando docker context inspect para ver información detallada sobre los contextos de Docker. Los contextos de Docker son esenciales para gestionar conexiones con diferentes daemons de Docker. Comenzaremos inspeccionando el contexto predeterminado de Docker, que se conecta al daemon local.

A continuación, crearemos un nuevo contexto con fines de demostración y luego usaremos docker context inspect para examinar sus detalles por nombre. Finalmente, aprenderemos cómo formatear la salida del comando inspect de diferentes maneras, específicamente como JSON y utilizando una plantilla de Go, para extraer información específica sobre un contexto.

Skills Graph

Inspeccionar el contexto predeterminado de Docker

En este paso, exploraremos el contexto predeterminado de Docker. Un contexto de Docker es una forma de gestionar conexiones con diferentes daemons de Docker. Por defecto, Docker utiliza un contexto llamado default que se conecta al daemon local de Docker.

Para inspeccionar el contexto predeterminado de Docker, usamos el comando docker context inspect seguido del nombre del contexto.

docker context inspect default

Este comando mostrará información detallada sobre el contexto default, incluyendo su endpoint, tipo y otros detalles de configuración. La salida estará en formato JSON.

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

La salida muestra que el contexto default es el contexto actual ("Current": true) y su endpoint está configurado como unix:///var/run/docker.sock, que es el socket Unix predeterminado para el daemon de Docker en sistemas Linux.

Crear un nuevo contexto para demostración

En este paso, crearemos un nuevo contexto de Docker. La creación de un nuevo contexto permite definir una conexión a un daemon de Docker diferente, que podría estar en una máquina remota o tener una configuración distinta en la misma máquina. Para esta demostración, crearemos un contexto que seguirá apuntando al daemon local de Docker, pero con un nombre diferente.

Para crear un nuevo contexto, utilizamos el comando docker context create seguido del nombre del nuevo contexto y la información del endpoint. Como nos conectaremos al daemon local, el endpoint será el mismo que el contexto predeterminado: unix:///var/run/docker.sock.

Vamos a crear un nuevo contexto llamado my-context.

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

Después de ejecutar este comando, deberías ver una salida que confirma la creación del contexto.

my-context

Esto confirma que se ha creado correctamente un nuevo contexto llamado my-context, que apunta al daemon local de Docker.

Inspeccionar el contexto recién creado por nombre

En el paso anterior, creamos un nuevo contexto de Docker llamado my-context. Ahora, vamos a inspeccionar este contexto recién creado para ver sus detalles. Al igual que al inspeccionar el contexto predeterminado, usamos el comando docker context inspect, pero esta vez especificamos el nombre de nuestro nuevo contexto.

docker context inspect my-context

Este comando mostrará los detalles de configuración del my-context que acabamos de crear. La salida nuevamente estará en formato JSON.

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

Observa que la salida para my-context es similar al contexto default, ya que ambos apuntan al daemon local de Docker. Sin embargo, el campo "Current" es false para my-context, lo que indica que no es el contexto activo actual. El contexto default sigue siendo el activo.

Inspeccionar el contexto y formatear la salida como JSON

En este paso, solicitaremos explícitamente que la salida del comando docker context inspect sea en formato JSON. Aunque la salida predeterminada ya es JSON, usar la bandera --format json es una buena práctica cuando específicamente necesitas salida JSON, por ejemplo, al canalizar (pipe) la salida a otras herramientas para su procesamiento.

Inspeccionaremos el my-context que creamos en el paso anterior y formatearemos la salida como JSON.

docker context inspect my-context --format json

Este comando producirá la misma salida JSON que en el paso anterior, pero demuestra explícitamente cómo usar la bandera --format para especificar el formato de salida.

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

Usar la bandera --format json es particularmente útil cuando deseas analizar programáticamente la salida de los comandos de Docker.

Inspeccionar el contexto y formatear la salida usando una plantilla Go

En este paso final, exploraremos cómo formatear la salida de docker context inspect usando una plantilla Go. Esta es una característica poderosa que te permite extraer información específica del output JSON y mostrarla en un formato personalizado.

Inspeccionaremos my-context y usaremos una plantilla Go para mostrar solo el nombre del contexto y el endpoint del host Docker. La sintaxis de la plantilla usa llaves dobles {{ }} para encerrar expresiones. Podemos acceder a campos dentro del output JSON usando notación de punto, por ejemplo .Name para el nombre del contexto y .Endpoint.Docker.Host para el endpoint del host Docker.

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

Este comando usará la plantilla Go proporcionada para formatear la salida. Deberías ver el nombre del contexto seguido de su endpoint de host Docker.

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

Esto demuestra cómo las plantillas Go pueden usarse para personalizar la salida de comandos Docker, facilitando la extracción y procesamiento de datos específicos.

Resumen

En este laboratorio, aprendimos a utilizar el comando docker context inspect para visualizar detalles sobre los contextos de Docker. Comenzamos inspeccionando el contexto predeterminado, que se conecta al daemon local de Docker. Luego creamos un nuevo contexto llamado my-context con fines demostrativos, que también apunta al daemon local.

Exploramos más a fondo el comando docker context inspect al examinar el contexto recién creado por su nombre. Finalmente, demostramos cómo formatear la salida del comando inspect de diferentes maneras, específicamente como JSON y usando una plantilla Go, para extraer y mostrar información específica sobre un contexto.