Monitorización de Contenedores Docker con cAdvisor, Prometheus y Grafana: Un Stack Observabilidad Completo

¡Bienvenido a esta guía completa sobre cómo establecer un stack de monitoreo robusto para tus contenedores Docker! 🐳 En el mundo de DevOps, la observabilidad es clave para asegurar el buen funcionamiento y rendimiento de nuestras aplicaciones. Con la creciente adopción de contenedores, se vuelve fundamental tener herramientas que nos permitan visualizar qué está sucediendo dentro de ellos.

En este tutorial, construiremos un sistema de monitoreo utilizando tres componentes líderes de la industria:

• cAdvisor (Container Advisor): Una herramienta de Google de código abierto que recopila y exporta métricas de rendimiento y uso de recursos de los contenedores en ejecución.
• Prometheus: Un sistema de monitoreo y alerta de código abierto, diseñado para la fiabilidad. Recopila métricas de targets configurados a través de un modelo pull, almacena esas métricas y permite consultarlas con su potente lenguaje PromQL.
• Grafana: Una plataforma de código abierto para el análisis y la visualización interactiva de datos. Nos permitirá crear dashboards personalizados y dinámicos para entender el estado de nuestros contenedores.

Este stack te proporcionará una visión completa del rendimiento de tus contenedores Docker, ayudándote a identificar cuellos de botella, optimizar recursos y diagnosticar problemas de manera proactiva. ¡Manos a la obra!

🎯 Objetivos del Tutorial

Al finalizar este tutorial, serás capaz de:

• Entender la arquitectura básica de monitoreo con cAdvisor, Prometheus y Grafana.
• Desplegar cAdvisor como un contenedor Docker para recolectar métricas.
• Configurar Prometheus para scrapear métricas de cAdvisor.
• Instalar y configurar Grafana para visualizar las métricas de Prometheus.
• Crear un dashboard básico en Grafana para monitorear el uso de CPU, memoria y red de tus contenedores.

📖 Arquitectura del Sistema de Monitoreo

Antes de sumergirnos en la implementación, es útil comprender cómo interactúan estos tres componentes.

El flujo de datos es el siguiente:

1. cAdvisor: Se ejecuta como un contenedor en el mismo host que los contenedores que queremos monitorear. Accede directamente a las cgroups de Linux para recolectar métricas de todos los contenedores en ejecución (incluyéndose a sí mismo y a los otros componentes del stack de monitoreo).
2. Prometheus: Consulta (o 'scrapea') periódicamente el endpoint de métricas que cAdvisor expone (generalmente en el puerto 8080).
3. Grafana: Se conecta a Prometheus como una fuente de datos y permite al usuario construir paneles de visualización a partir de las métricas almacenadas.

Esta configuración nos permite una gran flexibilidad y escalabilidad para monitorear no solo un host, sino múltiples hosts Docker si expandimos la configuración.

🛠️ Paso 1: Configuración Inicial de Docker Compose

Vamos a usar Docker Compose para orquestar nuestros tres servicios de monitoreo. Esto simplificará la configuración y el despliegue.

Crea un directorio para tu proyecto de monitoreo y dentro de él, un archivo llamado docker-compose.yml:

mkdir docker-monitoring
cd docker-monitoring
touch docker-compose.yml

Ahora, abre docker-compose.yml con tu editor de texto favorito y añade el siguiente contenido:

version: '3.8'

services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:rw
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
    privileged: true
    devices:
      - /dev/kmsg
    command: -docker_socket_path=/var/run/docker.sock -logtostderr=true
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/:/etc/prometheus/
      - prometheus_data:/prometheus
    command: --config.file=/etc/prometheus/prometheus.yml --web.enable-lifecycle
    depends_on:
      - cadvisor
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    depends_on:
      - prometheus
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

Explicación de los servicios:

• cadvisor:

  • Utiliza la imagen oficial de Google gcr.io/cadvisor/cadvisor:latest.
  • Expone el puerto 8080 para que Prometheus pueda acceder a sus métricas.
  • Requiere varios montajes de volúmenes para acceder a la información del sistema (cgroups, sistema de archivos raíz, socket de Docker, etc.) que necesita para recolectar métricas de otros contenedores. La mayoría son de solo lectura (ro).
  • privileged: true es necesario para cAdvisor en algunas configuraciones para acceder a /dev/kmsg y otras partes del sistema.
  • devices: - /dev/kmsg le da acceso explícito a este dispositivo.
  • El command especifica el path al socket de Docker y otras opciones de logging.

• prometheus:

  • Utiliza la imagen oficial prom/prometheus:latest.
  • Expone el puerto 9090 para su interfaz web y API.
  • Monta un volumen ./prometheus/:/etc/prometheus/ que utilizaremos para la configuración de Prometheus. Es crucial que este directorio exista en el host y contenga el archivo prometheus.yml.
  • Utiliza un volumen con nombre prometheus_data para persistir las métricas recolectadas.
  • depends_on: - cadvisor asegura que cAdvisor se inicie antes que Prometheus.

• grafana:

  • Utiliza la imagen oficial grafana/grafana:latest.
  • Expone el puerto 3000 para su interfaz web.
  • Utiliza un volumen con nombre grafana_data para persistir sus configuraciones y dashboards.
  • depends_on: - prometheus asegura que Prometheus esté disponible cuando Grafana intente conectarse.

⚙️ Paso 2: Configuración de Prometheus

Prometheus necesita saber dónde encontrar las métricas de cAdvisor. Para ello, crearemos un archivo de configuración específico.

Dentro del mismo directorio docker-monitoring, crea una subcarpeta llamada prometheus y dentro de ella, un archivo prometheus.yml:

mkdir prometheus
touch prometheus/prometheus.yml

Edita el archivo prometheus/prometheus.yml con el siguiente contenido:

global:
  scrape_interval: 15s # Por defecto, recopila métricas cada 15 segundos
  evaluation_interval: 15s # Evalúa las reglas cada 15 segundos

alerting:
  alertmanagers:
  - static_configs:
    - targets: ['localhost:9093'] # Esto es solo un placeholder, no lo configuraremos en este tutorial

rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']

Explicación de la configuración de Prometheus:

• global:
  • scrape_interval: Define cada cuánto tiempo Prometheus intentará recolectar métricas de sus targets. Aquí lo configuramos a 15 segundos.
• scrape_configs:
  • Define los jobs o tareas de scraping. Cada job_name es un grupo de targets.
  • El primer job_name: 'prometheus' configura a Prometheus para que se monitoree a sí mismo, apuntando a su propio puerto 9090.
  • El segundo job_name: 'cadvisor' es el crucial para nuestro propósito. Apunta a cadvisor:8080. Docker Compose se encarga de la resolución de nombres de servicio, por lo que cadvisor se resolverá a la IP interna del contenedor de cAdvisor dentro de la red Docker.

▶️ Paso 3: Despliegue del Stack con Docker Compose

Con todos los archivos de configuración en su lugar, podemos iniciar nuestro stack de monitoreo.

Abre tu terminal, navega al directorio docker-monitoring (donde está tu docker-compose.yml) y ejecuta el siguiente comando:

docker-compose up -d

• El comando up crea y inicia los contenedores.
• El flag -d significa 'detached mode', lo que hace que los contenedores se ejecuten en segundo plano y liberen tu terminal.

Deberías ver una salida similar a esta (puede variar ligeramente):

Creating network "docker-monitoring_default" with the default driver
Creating volume "docker-monitoring_prometheus_data" with default driver
Creating volume "docker-monitoring_grafana_data" with default driver
Creating cadvisor      ... done
Creating prometheus    ... done
Creating grafana       ... done

Verifica que todos los contenedores se estén ejecutando correctamente:

docker ps

Deberías ver cadvisor, prometheus y grafana en la lista, con el estado Up.

CONTAINER ID   IMAGE                          COMMAND                  CREATED          STATUS          PORTS                                       NAMES
c0a1b2c3d4e5   grafana/grafana:latest         "/run.sh"                5 seconds ago    Up 4 seconds    0.0.0.0:3000->3000/tcp, :::3000->3000/tcp   grafana
6f7e8d9c0b1a   prom/prometheus:latest         "/bin/prometheus --c…"   5 seconds ago    Up 4 seconds    0.0.0.0:9090->9090/tcp, :::9090->9090/tcp   prometheus
a0b1c2d3e4f5   gcr.io/cadvisor/cadvisor:latest  "/usr/bin/cadvisor -…"   6 seconds ago    Up 5 seconds    0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   cadvisor

¡Enhorabuena! 🎉 Tu stack de monitoreo está en marcha.

🌐 Paso 4: Accediendo a las Interfaces Web

Ahora que los servicios están funcionando, vamos a acceder a sus interfaces web.

Interfaz de cAdvisor

Aunque no es estrictamente necesario para la integración con Prometheus, puedes acceder a la interfaz web de cAdvisor para ver las métricas directamente:

• Abre tu navegador y ve a: http://localhost:8080

Verás una interfaz con información detallada sobre los contenedores, su uso de CPU, memoria, red y E/S de disco. cAdvisor expone todas estas métricas en formato Prometheus en el endpoint /metrics.

Interfaz de Prometheus

La interfaz de Prometheus te permite ver los targets de scraping, el estado del servidor y ejecutar consultas con PromQL.

• Abre tu navegador y ve a: http://localhost:9090

Navega a la sección Status > Targets. Deberías ver que los targets prometheus y cadvisor están en estado UP. Si no es así, revisa tus archivos de configuración y los logs de los contenedores (docker-compose logs prometheus).

📊 Paso 5: Configuración de Grafana y Creación de un Dashboard

Grafana es la capa de visualización donde daremos sentido a todas las métricas recolectadas.

Acceder a Grafana

• Abre tu navegador y ve a: http://localhost:3000

La primera vez que accedas, se te pedirá que inicies sesión. Las credenciales predeterminadas son:

• Usuario: admin
• Contraseña: admin

Se te solicitará que cambies la contraseña predeterminada por una más segura. Hazlo y guarda tu nueva contraseña.

Añadir Prometheus como Fuente de Datos

El primer paso en Grafana es conectar a nuestra instancia de Prometheus:

1. En el menú lateral izquierdo, haz clic en el icono de engranaje (Configuration).
2. Selecciona Data Sources.
3. Haz clic en Add data source.
4. Busca y selecciona Prometheus.

Ahora, configura los detalles de la fuente de datos:

• Name: Prometheus (o el nombre que prefieras)
• URL: http://prometheus:9090 (Recuerda que estamos dentro de la red Docker, así que usamos el nombre del servicio de Prometheus)
• Deja las demás opciones por defecto.

5. Haz clic en Save & test. Deberías ver un mensaje que dice Data source is working.

Crear un Dashboard para Contenedores Docker

Ahora que Grafana puede hablar con Prometheus, vamos a crear un dashboard para visualizar las métricas de nuestros contenedores.

1. En el menú lateral izquierdo, haz clic en el icono de cuadrados (Dashboards).
2. Selecciona + New dashboard.
3. Haz clic en Add a new panel.

Panel 1: Uso de CPU Total

Este panel mostrará el porcentaje de CPU utilizado por todos los contenedores.

• En el campo Metric browser, selecciona tu fuente de datos Prometheus.
• En el campo de la consulta (Query), introduce la siguiente expresión PromQL:

sum(rate(container_cpu_usage_seconds_total{image!=""}[1m])) by (instance) * 100

*   `container_cpu_usage_seconds_total`: Métrica de cAdvisor que indica el total de segundos de CPU utilizados.
*   `rate(...[1m])`: Calcula la tasa de cambio por segundo durante el último minuto.
*   `sum(...) by (instance)`: Suma el uso de CPU por instancia (host).
*   `* 100`: Convierte la tasa a porcentaje.

• En la pestaña Transform (al lado de Query), puedes añadir un Group by a instance y sum.
• En la pestaña Panel options (a la derecha), cambia el Title a Uso de CPU Total (Host). Puedes ajustar el tipo de visualización a Graph.
• Haz clic en Apply en la parte superior derecha.

Panel 2: Uso de Memoria por Contenedor

Este panel mostrará el uso de memoria de cada contenedor individualmente.

• Haz clic en Add panel y luego en Add a new panel.
• En el campo de la consulta (Query), introduce la siguiente expresión PromQL:

sum(container_memory_usage_bytes{image!=""}) by (name) / (1024 * 1024)

*   `container_memory_usage_bytes`: Métrica de cAdvisor que indica el uso de memoria en bytes.
*   `sum(...) by (name)`: Suma el uso de memoria por nombre de contenedor.
*   `/ (1024 * 1024)`: Convierte los bytes a megabytes (MB).

• En la pestaña Panel options, cambia el Title a Uso de Memoria por Contenedor (MB). Asegúrate de que la visualización sea Graph.
• Haz clic en Apply.

Panel 3: Tráfico de Red Saliente por Contenedor

• Haz clic en Add panel y luego en Add a new panel.
• En el campo de la consulta (Query), introduce la siguiente expresión PromQL:

sum(rate(container_network_transmit_bytes_total{image!=""}[1m])) by (name) / (1024 * 1024)

*   `container_network_transmit_bytes_total`: Bytes transmitidos por la red.
*   `rate(...[1m])`: Tasa de cambio por segundo.
*   `sum(...) by (name)`: Suma por nombre de contenedor.
*   `/ (1024 * 1024)`: Convierte a MB/s.

• En la pestaña Panel options, cambia el Title a Tráfico Saliente (MB/s) por Contenedor. Ajusta el tipo de visualización a Graph.
• Haz clic en Apply.

Cuando hayas terminado de añadir paneles, haz clic en el icono de Guardar (Save dashboard) en la parte superior del dashboard para guardarlo. Dale un nombre, por ejemplo, Docker Monitoring.

¡Felicidades! Ahora tienes un dashboard funcional de Grafana que te permite monitorear el estado de tus contenedores Docker en tiempo real. ✨

🗑️ Limpieza del Entorno (Opcional)

Si deseas detener y eliminar los contenedores y los volúmenes creados por Docker Compose, navega al directorio docker-monitoring en tu terminal y ejecuta:

docker-compose down --volumes

• down detiene y elimina los contenedores, redes e imágenes.
• --volumes es crucial para eliminar también los volúmenes prometheus_data y grafana_data, asegurando una limpieza completa. Si no usas --volumes, los datos persistirán.

Resumen de Comandos Clave

Aquí tienes un resumen rápido de los comandos más importantes que hemos usado:

FAQs Frecuentes

¿Por qué mi cAdvisor no puede acceder a las métricas de los contenedores?

Asegúrate de que los volúmenes están correctamente montados en docker-compose.yml (especialmente /sys, /var/lib/docker, /var/run) y que el contenedor de cAdvisor tiene los permisos adecuados (a veces privileged: true es necesario, como lo hemos configurado aquí).

¿Qué hago si Prometheus no ve los targets de cAdvisor?

1. Verifica los logs de Prometheus (docker-compose logs prometheus).
2. Asegúrate de que cadvisor:8080 es accesible desde el contenedor de Prometheus. Confirma que ambos contenedores están en la misma red Docker (por defecto, Docker Compose los coloca en la misma).
3. Revisa la sintaxis de tu prometheus/prometheus.yml en la sección scrape_configs.

¿Cómo puedo monitorear múltiples hosts Docker?

Para monitorear múltiples hosts, necesitarías desplegar una instancia de cAdvisor en cada host. Luego, puedes tener una instancia central de Prometheus que "scrapee" a todas las instancias de cAdvisor, ya sea configurando sus direcciones IP directamente o utilizando un sistema de descubrimiento de servicios (como Consul o Kubernetes).

¿Puedo añadir alertas a este stack?

¡Sí! Prometheus tiene un componente llamado Alertmanager que se encarga de gestionar y enviar alertas. Tendrías que añadir un servicio alertmanager en tu docker-compose.yml y configurar las reglas de alerta en Prometheus (rule_files en prometheus.yml). Este tema da para otro tutorial completo.

✅ Conclusión

Has llegado al final de esta guía, y ahora tienes un potente stack de monitoreo de contenedores Docker funcionando con cAdvisor, Prometheus y Grafana. Esta combinación es un estándar de la industria para la observabilidad y te proporcionará las herramientas necesarias para mantener tus entornos Docker bajo control.

La capacidad de visualizar y consultar métricas de tus contenedores es invaluable para el mantenimiento, la depuración y la optimización del rendimiento. Te animo a explorar más a fondo las capacidades de PromQL en Prometheus y a crear dashboards más complejos y específicos en Grafana para tus necesidades.

¡Sigue explorando el mundo de la observabilidad y los contenedores! 🚀