Cómo usar el comando docker buildx ls para listar instancias de construcción

Introducción

En este laboratorio, aprenderás a utilizar el comando docker buildx ls para listar instancias de construcción (builder) y sus nodos asociados. Explorarás el uso básico del comando para visualizar entornos de construcción disponibles y sus configuraciones.

Además, descubrirás cómo formatear la salida de docker buildx ls utilizando plantillas Go (Go templates) para personalizar la información mostrada. Esto incluye formatear la salida para mostrar campos específicos y visualizar las relaciones entre las instancias de construcción y sus nodos.

Skills Graph

Listar todas las instancias de construcción y nodos

En este paso, aprenderás a listar todas las instancias de construcción (builder) y nodos utilizando el comando docker buildx ls. Este comando es útil para comprender los entornos de construcción disponibles y sus configuraciones.

Primero, ejecutemos el comando básico para listar las instancias de construcción y nodos.

docker buildx ls

Deberías ver una salida similar a esta:

NAME/NODE       DRIVER/ENDPOINT STATUS  BUILDKIT             PLATFORMS
default         docker
  default       docker          running linux/amd64, linux/arm64, linux/riscv64, linux/ppc64le, linux/s390x

La salida proporciona información sobre las instancias de construcción y sus nodos asociados. La columna NAME/NODE muestra el nombre de la instancia de construcción y el nodo dentro de esa instancia. La columna DRIVER/ENDPOINT indica el controlador (driver) utilizado y el endpoint para el nodo. La columna STATUS muestra el estado actual del nodo (ej. running). La columna BUILDKIT muestra la versión de BuildKit. Finalmente, la columna PLATFORMS lista las plataformas soportadas por el nodo.

En este ejemplo, vemos una instancia de construcción llamada default con un único nodo también llamado default. Utiliza el controlador docker y actualmente está running. Soporta múltiples plataformas.

Formatear la salida usando una plantilla Go

En este paso, aprenderás a formatear la salida del comando docker buildx ls utilizando una plantilla Go. Las plantillas Go proporcionan una forma flexible de personalizar el formato de salida para mostrar solo la información que necesitas.

La bandera --format te permite especificar una plantilla Go. La plantilla utiliza marcadores como {{.Name}}, {{.Driver}}, {{.Status}}, etc., para acceder a los diferentes campos de las instancias de construcción (builder) y objetos nodo.

Probemos formatear la salida para mostrar solo el nombre y el controlador (driver) de las instancias de construcción y nodos.

docker buildx ls --format "{{.Name}}\t{{.Driver}}"

Deberías ver una salida similar a esta:

default docker
default docker

En esta plantilla, {{.Name}} representa el nombre del builder o nodo, y {{.Driver}} representa el controlador. El \t se utiliza para insertar un carácter de tabulación entre el nombre y el controlador para una mejor legibilidad.

Esto demuestra cómo puedes usar una plantilla Go simple para extraer información específica de la salida de docker buildx ls. En los siguientes pasos, exploraremos plantillas más complejas para formatear la salida de diferentes maneras.

Formatear la salida con campos específicos

En este paso, continuaremos explorando las plantillas Go para formatear la salida de docker buildx ls y mostrar campos específicos de interés. Puedes seleccionar diversos campos de las instancias de construcción (builder) y objetos nodo para incluirlos en tu salida personalizada.

Formateemos la salida para mostrar el nombre, estado y plataformas soportadas para cada nodo constructor:

docker buildx ls --format "{{.Name}}\t{{.Status}}\t{{.Platforms}}"

Deberías ver una salida similar a esta:

default running linux/amd64, linux/arm64, linux/riscv64, linux/ppc64le, linux/s390x
default running linux/amd64, linux/arm64, linux/riscv64, linux/ppc64le, linux/s390x

En esta plantilla:

• {{.Name}} se refiere al nombre del nodo constructor
• {{.Status}} indica el estado del nodo (ej. running)
• {{.Platforms}} muestra la lista de plataformas soportadas por el nodo

Nuevamente usamos \t para separar los campos con tabulaciones, lo que permite visualizar rápidamente el estado y plataformas soportadas de cada nodo.

Puedes combinar diferentes campos en tu plantilla según tus necesidades. Experimenta incluyendo otros campos como {{.Driver}} o {{.Buildkit}} para observar cómo cambia la salida.

Formatear la salida para mostrar relaciones entre constructores y nodos

En este paso, utilizaremos una plantilla Go más avanzada para visualizar la relación entre instancias de construcción (builders) y sus nodos. Esto resulta útil cuando tienes múltiples instancias de constructores y nodos configurados.

Podemos usar declaraciones condicionales y bucles dentro de la plantilla Go para lograr esto. Sin embargo, por simplicidad y para enfocarnos en el formato básico, crearemos una plantilla que muestre claramente qué nodo pertenece a qué instancia de constructor.

Usemos una plantilla que imprima el nombre del constructor seguido de sus nodos, con sangría:

docker buildx ls --format "{{range .}}{{if .Builder}}{{.Name}} (Builder){{range .Nodes}}\n  - {{.Name}} (Node){{end}}{{else}}\n{{.Name}} (Node){{end}}{{end}}"

Deberías ver una salida similar a esta:

default (Builder)
  - default (Node)

Analicemos esta plantilla:

• {{range .}}...{{end}}: Itera sobre la lista de instancias de constructores y nodos.
• {{if .Builder}}...{{else}}...{{end}}: Verifica si el elemento actual es una instancia de constructor (.Builder es verdadero).
• Si es un constructor:
  • {{.Name}} (Builder): Imprime el nombre del constructor seguido de "(Builder)".
  • {{range .Nodes}}...{{end}}: Itera sobre los nodos dentro del constructor actual.
  • \n - {{.Name}} (Node): Imprime un salto de línea, una sangría, "- ", el nombre del nodo y "(Node)".
• Si no es un constructor (es un nodo independiente, menos común en configuraciones básicas):
  • \n{{.Name}} (Node): Imprime un salto de línea, el nombre del nodo y "(Node)".

Esta plantilla proporciona una salida estructurada que muestra claramente qué nodos están asociados a qué instancias de constructores. Aunque este ejemplo es simple con solo un constructor y un nodo, esta plantilla se vuelve más útil cuando tienes una configuración buildx más compleja.

Resumen

En este laboratorio, aprendiste a utilizar el comando docker buildx ls para listar instancias de construcción (builders) y sus nodos asociados. Comenzaste ejecutando el comando básico para ver la salida predeterminada, que proporciona detalles sobre el nombre del constructor, nombre del nodo, controlador (driver), estado, versión de BuildKit y plataformas soportadas.

Además, exploraste cómo formatear la salida usando una plantilla Go con la bandera --format. Esto te permite personalizar la información mostrada especificando marcadores de posición para diferentes campos, lo que te posibilita extraer y presentar solo los datos relevantes sobre tus instancias de constructores y nodos.