Cómo usar el comando docker stack ls para listar pilas (stacks)

Introducción

En este laboratorio, aprenderá cómo utilizar el comando docker stack ls para listar las pilas (stacks) de Docker. Comenzaremos instalando Docker Compose, que es esencial para definir y desplegar aplicaciones de múltiples contenedores como pilas (stacks). Luego, desplegará una pila (stack) de un servicio web simple utilizando un archivo docker-compose.yml para tener una pila (stack) que listar.

Después del despliegue, explorará diferentes formas de listar las pilas (stacks) utilizando docker stack ls. Esto incluye listar todas las pilas (stacks) en ejecución, listar las pilas (stacks) con un formato de salida personalizado para mostrar información específica y listar las pilas (stacks) en formato JSON para su procesamiento programático.

Skills Graph

Listar todas las pilas (stacks)

En este paso, aprenderá cómo listar todas las pilas (stacks) de Docker que se están ejecutando en su sistema. Una pila (stack) de Docker es una colección de servicios que se despliegan juntos. Antes de poder listar las pilas (stacks), necesitamos instalar Docker Compose, que se utiliza para definir y ejecutar aplicaciones de Docker de múltiples contenedores.

Primero, instalemos Docker Compose. Descargaremos el binario de Docker Compose y lo haremos ejecutable.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

El primer comando descarga el binario de Docker Compose del repositorio oficial de GitHub. $(uname -s) y $(uname -m) se utilizan para obtener el sistema operativo y la arquitectura de su máquina, asegurando que descargue el binario correcto. El segundo comando hace que el archivo descargado sea ejecutable.

Ahora que Docker Compose está instalado, verifiquemos la instalación comprobando la versión.

docker-compose --version

Debería ver la versión de Docker Compose instalada en la salida.

Para demostrar cómo listar las pilas (stacks), necesitamos desplegar una pila (stack) simple. Crearemos un archivo docker-compose.yml que defina un servicio web simple.

nano ~/project/docker-compose.yml

Pegue el siguiente contenido en el archivo docker-compose.yml:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Este archivo docker-compose.yml define un solo servicio llamado web que utiliza la imagen nginx:latest y mapea el puerto 80 del host al puerto 80 del contenedor.

Ahora, despleguemos esta pila (stack) utilizando el comando docker stack deploy. Nombraremos nuestra pila (stack) mywebstack.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

La bandera -c especifica el archivo Compose a utilizar, y mywebstack es el nombre que le estamos dando a nuestra pila (stack). Verá una salida que indica que los servicios se están creando y desplegando.

Después de desplegar la pila (stack), puede listar todas las pilas (stacks) en ejecución utilizando el comando docker stack ls.

docker stack ls

Este comando mostrará una lista de todas las pilas (stacks) desplegadas, incluyendo el nombre de la pila (stack), el número de servicios y el número deseado y actual de réplicas para cada servicio. Debería ver mywebstack en la lista de la salida.

Listar pilas (stacks) con formato personalizado

En el paso anterior, aprendiste cómo listar todas las pilas (stacks) de Docker desplegadas utilizando el formato de salida predeterminado. En este paso, aprenderás cómo personalizar el formato de salida del comando docker stack ls para mostrar solo la información que necesitas.

El comando docker stack ls admite la bandera --format, que te permite especificar una plantilla de Go para dar formato a la salida. Esto es útil cuando quieres extraer información específica o integrar la salida con otras herramientas.

Comencemos listando los nombres de las pilas (stacks) y el número de servicios en cada pila (stack). Podemos usar los campos de plantilla {{.Name}} y {{.Services}} para esto.

docker stack ls --format "{{.Name}}: {{.Services}}"

En este comando, --format "{{.Name}}: {{.Services}}" le dice a Docker que muestre el nombre de cada pila (stack) seguido de dos puntos y luego el número de servicios. Los {{.Name}} y {{.Services}} son marcadores de posición que se reemplazarán con los valores reales de cada pila (stack).

Deberías ver una salida similar a mywebstack: 1, que indica el nombre de la pila (stack) y el número de servicios que contiene.

También puedes incluir otros campos en la cadena de formato. Por ejemplo, listemos el nombre de la pila (stack) y el número deseado de réplicas.

docker stack ls --format "Stack Name: {{.Name}}, Desired Replicas: {{.Desired}}"

Aquí, estamos usando el campo {{.Desired}} para mostrar el número deseado de réplicas de los servicios en la pila (stack).

La bandera --format es muy flexible y te permite combinar diferentes campos y agregar texto personalizado. Puedes encontrar una lista de los campos disponibles en la documentación de Docker para el comando docker stack ls.

Probemos otro ejemplo, listando el nombre de la pila (stack) y el número actual de réplicas.

docker stack ls --format "Stack: {{.Name}}, Current Replicas: {{.Current}}"

Este comando utiliza el campo {{.Current}} para mostrar el número actual de réplicas en ejecución de los servicios en la pila (stack).

Usar la bandera --format te permite adaptar la salida de docker stack ls a tus necesidades específicas, lo que facilita el procesamiento y análisis de la información sobre las pilas (stacks) desplegadas.

Listar pilas (stacks) en formato JSON

En los pasos anteriores, aprendiste cómo listar las pilas (stacks) de Docker utilizando los formatos predeterminado y personalizado. En este paso, aprenderás cómo listar las pilas (stacks) de Docker en formato JSON. Esto es especialmente útil cuando necesitas analizar la salida mediante programación o integrarla con otros sistemas.

El comando docker stack ls, al igual que muchos otros comandos de Docker, admite la opción --format json para mostrar los resultados como una matriz JSON.

Listemos las pilas (stacks) desplegadas en formato JSON.

docker stack ls --format json

Este comando mostrará una matriz JSON, donde cada elemento de la matriz representa una pila (stack) de Docker y contiene información sobre la pila (stack), como su nombre, servicios, réplicas deseadas y réplicas actuales.

La salida se verá algo así (el contenido exacto dependerá de las pilas (stacks) que hayas desplegado):

[
  {
    "Name": "mywebstack",
    "Services": "1",
    "Desired": "1",
    "Current": "1"
  }
]

Esta salida JSON está estructurada y es fácil de analizar utilizando lenguajes de scripting u otras herramientas. Por ejemplo, podrías utilizar una herramienta como jq para extraer campos específicos de la salida JSON.

Instalemos jq, un procesador JSON de línea de comandos ligero y flexible.

sudo apt-get update
sudo apt-get install -y jq

Ahora que jq está instalado, utilicémoslo para extraer solo los nombres de las pilas (stacks) desplegadas de la salida JSON.

docker stack ls --format json | jq '.[].Name'

En este comando, redirigimos la salida JSON de docker stack ls --format json a jq. El '.[].Name' es un filtro de jq que selecciona el campo Name de cada objeto en la matriz JSON.

Deberías ver el nombre de tu pila (stack) desplegada, mywebstack, como salida.

Listar las pilas (stacks) en formato JSON proporciona una forma estructurada de acceder a la información de las pilas (stacks), lo cual es esencial para fines de automatización e integración.

Resumen

En este laboratorio, aprendiste cómo usar el comando docker stack ls para listar las pilas (stacks) de Docker. El laboratorio comenzó guiándote a través de la instalación de Docker Compose, un requisito previo para trabajar con pilas (stacks) de Docker, y verificando su instalación. Luego, creaste un archivo docker-compose.yml simple que define un servicio web básico y lo desplegaste como una pila (stack) llamada mywebstack utilizando docker stack deploy.

Los pasos posteriores, aunque no se detallan completamente en el contenido proporcionado, habrían cubierto la lista de todas las pilas (stacks) desplegadas utilizando docker stack ls, la personalización del formato de salida para mostrar información específica y la lista de pilas (stacks) en formato JSON para su procesamiento mediante programación. Esta experiencia práctica proporcionó conocimientos prácticos sobre la gestión e inspección de pilas (stacks) de Docker utilizando el comando docker stack ls y sus diversas opciones.