Cómo usar el comando docker compose alpha viz para visualizar archivos compose

Introducción

En este laboratorio, aprenderás a visualizar eficazmente tus archivos Docker Compose utilizando el comando docker-compose alpha viz. Esta experiencia práctica te guiará a través de la generación de gráficos básicos para representar tus servicios, y luego mejorará progresivamente estas visualizaciones incluyendo imágenes de servicios, redes y puertos. También descubrirás cómo personalizar la sangría del gráfico de salida para una mejor legibilidad.

Al finalizar este laboratorio, serás capaz de crear representaciones visuales claras e informativas de tus configuraciones de Docker Compose, facilitando la comprensión de las relaciones y dependencias dentro de tus aplicaciones multi-contenedor.

Skills Graph

Generar un gráfico básico a partir de un archivo compose

En este paso, aprenderás cómo generar una representación gráfica básica de tu archivo Docker Compose. Esto es útil para visualizar las relaciones entre tus servicios, redes y volúmenes.

Primero, necesitas instalar Docker Compose. Como no viene preinstalado en el entorno de LabEx, lo instalarás usando pip.

sudo apt update
sudo apt install -y python3-pip
pip install docker-compose

Una vez completada la instalación, puedes verificar la instalación comprobando la versión de Docker Compose.

docker-compose --version

Deberías ver una salida similar a docker-compose version 1.29.2, build 5becea4c.

Ahora, creemos un archivo Docker Compose simple. Navega a tu directorio de proyecto y crea un archivo llamado docker-compose.yml.

cd ~/project
nano docker-compose.yml

Agrega el siguiente contenido al archivo docker-compose.yml:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  app:
    image: ubuntu:latest
    command: sleep infinity

Este archivo docker-compose.yml define dos servicios: web que utiliza la imagen nginx:latest y app que usa la imagen ubuntu:latest. El servicio web mapea el puerto 80 del host al puerto 80 del contenedor. El servicio app simplemente ejecuta el comando sleep infinity para mantener el contenedor en ejecución.

Para generar un gráfico básico a partir de este archivo compose, usarás el comando docker-compose config con la bandera --graph. Este comando analiza el archivo compose y genera una representación gráfica en formato DOT.

docker-compose config --graph

La salida estará en lenguaje DOT, que es un lenguaje de descripción de gráficos. Mostrará los servicios y sus conexiones básicas. Por ejemplo, podrías ver algo como:

digraph {
  compound=true
  "web" [label="web"]
  "app" [label="app"]
  "web" -> "app" [label="depends_on"]
}

Esta salida DOT representa un gráfico dirigido donde web y app son nodos, y hay una arista dirigida de web a app etiquetada como "depends_on". Aunque este ejemplo simple no define explícitamente dependencias, docker-compose config --graph puede inferir algunas relaciones.

Incluir imágenes de servicios en el gráfico

En este paso, aprenderás cómo incluir las imágenes de los servicios en el gráfico generado. Por defecto, el gráfico básico solo muestra los nombres de los servicios. Incluir los nombres de las imágenes proporciona más contexto sobre lo que representa cada servicio.

Continuarás utilizando el archivo docker-compose.yml que creaste en el paso anterior.

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  app:
    image: ubuntu:latest
    command: sleep infinity

Para incluir las imágenes de los servicios en la salida del gráfico, necesitas usar la bandera --images con el comando docker-compose config --graph.

docker-compose config --graph --images

Al ejecutar este comando, se generará la salida del gráfico DOT, pero esta vez los nodos que representan los servicios también incluirán los nombres de las imágenes. La salida será similar al paso anterior, pero con información adicional dentro de las definiciones de los nodos.

Por ejemplo, la salida ahora podría verse así:

digraph {
  compound=true
  "web" [label="web\nnginx:latest"]
  "app" [label="app\nubuntu:latest"]
  "web" -> "app" [label="depends_on"]
}

Observa que el atributo label para cada nodo ahora incluye tanto el nombre del servicio como el nombre de la imagen, separados por un carácter de nueva línea (\n). Esto hace que el gráfico sea más informativo al mostrar qué imagen de Docker se utiliza para cada servicio.

Esta es una forma sencilla de agregar más detalle a tu visualización gráfica de Docker Compose, ayudándote a comprender los componentes de tu aplicación de un vistazo.

Incluir redes de servicios en el gráfico

En este paso, aprenderás cómo incluir las redes a las que están conectados tus servicios en el gráfico generado. Comprender la topología de red es crucial para depurar y visualizar el flujo de comunicación entre tus contenedores.

Modificarás el archivo docker-compose.yml para definir explícitamente una red y conectar los servicios a ella.

Abre el archivo docker-compose.yml en tu directorio de proyecto:

nano ~/project/docker-compose.yml

Modifica el contenido para incluir una definición de red y conectar los servicios a esta red:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    networks:
      - my_network
  app:
    image: ubuntu:latest
    command: sleep infinity
    networks:
      - my_network

networks:
  my_network:
    driver: bridge

En este docker-compose.yml actualizado, hemos añadido una sección networks en el nivel superior para definir una red llamada my_network usando el driver bridge. También hemos añadido una clave networks bajo cada servicio (web y app) para especificar que deben conectarse a my_network.

Ahora, para incluir la información de red en la salida del gráfico, usarás la bandera --networks junto con la bandera --graph.

docker-compose config --graph --networks

Al ejecutar este comando, se generará la salida del gráfico DOT, que ahora incluirá nodos representando la red y aristas mostrando qué servicios están conectados a ella. La salida será más compleja que antes, ilustrando las conexiones de red.

Verás nodos para los servicios (web y app) y un nodo para la red (my_network). Habrá aristas conectando los servicios a la red, indicando su pertenencia a dicha red. Esta visualización te ayuda a ver cómo tus servicios están aislados o conectados a nivel de red.

Incluir puertos de servicios en el gráfico

En este paso, aprenderás cómo incluir los puertos expuestos y publicados de tus servicios en el gráfico generado. Visualizar los puertos ayuda a comprender cómo tus servicios son accesibles desde fuera de la red Docker o desde otros servicios.

Continuarás utilizando el archivo docker-compose.yml de los pasos anteriores.

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    networks:
      - my_network
  app:
    image: ubuntu:latest
    command: sleep infinity
    networks:
      - my_network

networks:
  my_network:
    driver: bridge

Para incluir los puertos de los servicios en la salida del gráfico, usarás la bandera --ports junto con la bandera --graph. Puedes combinar múltiples banderas para incluir diferentes tipos de información en el gráfico. Incluyamos imágenes, redes y puertos en el gráfico.

docker-compose config --graph --images --networks --ports

Al ejecutar este comando, se generará la salida del gráfico DOT, que ahora incluirá información sobre los puertos de cada servicio. La salida será aún más detallada, mostrando los nombres de los servicios, nombres de imágenes, conexiones de red y mapeos de puertos.

Para el servicio web, verás el mapeo de puertos 80:80 incluido en su definición de nodo. Esto indica que el puerto 80 en el host está mapeado al puerto 80 dentro del contenedor web.

La salida DOT para el nodo del servicio web podría verse así:

"web" [label="web\nnginx:latest\n80:80"]

Al incluir los puertos en el gráfico, obtienes una imagen más clara de cómo tus servicios están expuestos y cómo el tráfico externo o de otros contenedores puede alcanzarlos. Esto es particularmente útil para depurar problemas de conectividad o entender la interfaz externa del servicio.

Personalizar la indentación en el gráfico de salida

En este paso, aprenderás cómo personalizar la indentación de la salida del gráfico DOT generado. Aunque la indentación predeterminada suele ser aceptable, es posible que desees ajustarla para mejorar la legibilidad o cumplir con estándares de formato específicos si planeas procesar la salida posteriormente.

Continuarás utilizando el archivo docker-compose.yml de los pasos anteriores.

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    networks:
      - my_network
  app:
    image: ubuntu:latest
    command: sleep infinity
    networks:
      - my_network

networks:
  my_network:
    driver: bridge

Para personalizar la indentación de la salida del gráfico, puedes usar la bandera --indent seguida del número de espacios que deseas usar para la indentación. Generemos el gráfico incluyendo imágenes, redes y puertos, y establezcamos la indentación a 4 espacios.

docker-compose config --graph --images --networks --ports --indent 4

Al ejecutar este comando, se producirá el mismo contenido de gráfico que en el paso anterior, pero las líneas en la salida DOT estarán indentadas con 4 espacios. Compara la salida de este comando con la del paso anterior para ver la diferencia en la indentación.

Por ejemplo, una sección de la salida podría verse así con 4 espacios de indentación:

digraph {
    compound=true
    "web" [label="web\nnginx:latest\n80:80"]
    "app" [label="app\nubuntu:latest"]
    "my_network" [label="my_network"]
    "web" -> "my_network" [label="network"]
    "app" -> "my_network" [label="network"]
    "web" -> "app" [label="depends_on"]
}

Puedes experimentar con diferentes valores de indentación para ver cómo afecta el formato de salida. Esta opción es principalmente para fines estéticos o para herramientas que requieren un estilo de indentación específico para archivos DOT.

Resumen

En este laboratorio, aprendiste a visualizar archivos Docker Compose utilizando el comando docker-compose config --graph. Comenzaste instalando Docker Compose y creando un archivo básico docker-compose.yml con dos servicios. Luego generaste una representación gráfica básica de este archivo en formato DOT, que muestra visualmente los servicios y sus relaciones.

Partiendo de la visualización básica, exploraste cómo incluir detalles adicionales en el gráfico. Esto incluyó incorporar imágenes de servicios, redes y puertos en la salida visual, proporcionando una vista más completa de la configuración del archivo compose. Finalmente, aprendiste a personalizar la indentación del gráfico de salida para mejorar su legibilidad.