Observabilidad de Servidores y Contenedores Docker: Una Mirada Práctica con Prometheus, Grafana y cAdvisor

En el mundo de la infraestructura moderna, especialmente con la creciente adopción de contenedores y arquitecturas distribuidas, entender qué está sucediendo dentro de nuestros sistemas en tiempo real se ha vuelto fundamental. Ya no basta con saber si un servidor está “encendido”; necesitamos comprender su comportamiento interno, cómo interactúan sus componentes y predecir posibles problemas antes de que afecten a los usuarios. Aquí es donde entra el concepto de

Observabilidad.

¿Qué es la Observabilidad?

La observabilidad es la capacidad de inferir el estado interno de un sistema midiendo sus salidas externas. En términos prácticos, se trata de recopilar y analizar datos de nuestro sistema para poder hacer preguntas arbitrarias sobre su comportamiento sin necesidad de conocer previamente todas las posibles fallas o estados. A diferencia del monitoreo tradicional, que a menudo se centra en métricas conocidas y umbrales predefinidos para alertar sobre problemas conocidos, la observabilidad nos permite explorar el sistema para diagnosticar problemas desconocidos o inesperados.

Los Tres Pilares de la Observabilidad

La observabilidad se construye típicamente sobre tres tipos principales de datos o “pilares”:

1. Monitoreo (Metrics): Consiste en la recopilación de datos numéricos agregados a lo largo del tiempo (series temporales). Estas son las métricas de rendimiento como uso de CPU, memoria, latencia de red, errores por segundo, etc. El monitoreo nos da una vista de alto nivel del rendimiento y salud del sistema y sus componentes. Es excelente para detectar tendencias, identificar cuellos de botella y disparar alertas basadas en umbrales.
2. Logging (Logs): Son registros de eventos discretos que ocurren dentro de una aplicación o sistema. Los logs proporcionan información detallada sobre lo que sucedió en un momento específico. Son cruciales para la depuración, el análisis de causa raíz de problemas y la auditoría.
3. Trazabilidad (Tracing): Permite seguir el camino de una solicitud a medida que atraviesa los diferentes servicios en un sistema distribuido. El tracing es vital para comprender las interacciones entre microservicios, identificar la latencia en flujos de trabajo complejos y depurar problemas de rendimiento en arquitecturas distribuidas.

Aunque los tres pilares son esenciales para una observabilidad completa, el monitoreo a menudo constituye la base inicial, proporcionando la visibilidad en tiempo real necesaria para identificar rápidamente cuándo y dónde podría estar ocurriendo un problema.

Enfocándonos en el Monitoreo

El monitoreo nos proporciona la capacidad de responder preguntas como:

• ¿Cuánta CPU está usando mi servidor?
• ¿Cuánta memoria libre tiene un contenedor Docker específico?
• ¿Cuántas solicitudes por segundo está manejando mi aplicación?
• ¿Cuál es la latencia promedio de las respuestas de mi API?
• ¿Está aumentando el número de errores HTTP en mi servicio web?

Tener acceso a estas métricas en tiempo real y a lo largo del tiempo nos permite no solo reaccionar a los problemas, sino también anticiparlos, optimizar recursos y planificar la capacidad.

Herramientas Clave para el Monitoreo

Existen numerosas herramientas para implementar soluciones de monitoreo. Para monitorear servidores y, crucialmente, los recursos y el rendimiento a nivel de contenedor en Docker, una pila muy popular y efectiva es la compuesta por Prometheus y Grafana, complementada con Exporters como Node Exporter y cAdvisor. En algunos setups, herramientas como Redis pueden usarse como soporte (aunque no es estrictamente parte del pipeline de métricas principal en este contexto).

• Prometheus: Es un sistema de monitoreo y alerta basado en series temporales. Prometheus recolecta métricas de diversos orígenes (endpoints HTTP que exponen métricas en un formato específico) mediante un modelo “pull” (Prometheus va y “raspa” los datos de los targets configurados). Es la base de nuestra recopilación y almacenamiento de métricas.

• Grafana: Es una plataforma de código abierto para la visualización y el análisis de métricas. Grafana se conecta a diversas fuentes de datos, incluyendo Prometheus, y permite crear dashboards personalizables con gráficos, tablas y otros paneles para visualizar las métricas recopiladas de forma intuitiva. Es la interfaz principal para que los humanos interactúen con los datos de monitoreo. 📝 Nota: Una vez que Grafana esté funcionando, puedes importar dashboards prediseñados desde Grafana Labs. Por ejemplo, si estás monitoreando un servidor como una Raspberry Pi, puedes utilizar el dashboard con el ID 15120, que está optimizado para mostrar métricas clave de un sistema Linux. Solo necesitas ir a “+ / Import” dentro de Grafana, ingresar el número del panel (15120) y seleccionar Prometheus como fuente de datos. Esto te permitirá visualizar de inmediato un conjunto de gráficos útiles sin tener que construirlos desde cero.

• Node Exporter: Es un “exporter” oficial de Prometheus que se instala en servidores Linux para exponer métricas a nivel del sistema operativo (CPU, memoria, disco, red, etc.). Esencial para entender el estado de la máquina host donde se ejecutan los contenedores.

• cAdvisor (Container Advisor): Es otra herramienta de código abierto (originalmente de Google) que monitorea el uso de recursos y el rendimiento de los contenedores en ejecución. cAdvisor recopila métricas como uso de CPU, memoria, E/S de red y sistema de archivos para cada contenedor. Es indispensable para tener visibilidad del consumo de recursos por contenedor.

• Redis: Aunque no es una herramienta de monitoreo per se, a veces se incluye en setups (como parece insinuar tu depends_on en cAdvisor, aunque no es el uso más común hoy en día) potencialmente como una caché o base de datos auxiliar para ciertas herramientas de monitoreo o sus componentes. En el contexto de este setup, su papel específico no es central para la recopilación de métricas por parte de Prometheus, sino quizás una dependencia para la versión o configuración específica de cAdvisor que se está utilizando.

Implementando la Pila de Monitoreo con Docker Compose

Docker Compose nos permite definir y ejecutar aplicaciones multi-contenedor con un solo comando. El archivo docker-compose.yml que proporcionaste orquesta la implementación de Prometheus, Grafana, Node Exporter, cAdvisor y Redis.

Aquí está el contenido del archivo docker-compose.yml:

services: 
  grafana: 
    image: grafana/grafana:latest
    container_name: grafana_monitoring
    restart: unless-stopped manualmente.
    volumes: 
      - /home/dev/docker/monitoring/grafana/data:/var/lib/grafana 
    ports: 
      - '3000:3000' 
    networks: 
      - monitoring_net 
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus 
    restart: unless-stopped 
    volumes: 
      - /home/dev/docker/monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml 
      - /home/dev/docker/monitoring/prometheus/data:/prometheus 
    ports:
      - '9090:9090' 
    command:
      - '--config.file=/etc/prometheus/prometheus.yml' 
      - '--storage.tsdb.path=/prometheus' 
      - '--web.console.libraries=/etc/prometheus/console_libraries' 
      - '--web.console.templates=/etc/prometheus/consoles' 
      - '--web.enable-lifecycle'
    networks: 
      - monitoring_net 

  node-exporter: 
    image: prom/node-exporter:latest 
    container_name: node-exporter 
    restart: unless-stopped 
    volumes: 
      - /proc:/host/proc:ro 
      - /sys:/host/sys:ro 
      - /:/rootfs:ro
    command: 
      - '--path.procfs=/host/proc'
      - '--path.rootfs=/rootfs'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)' 
    expose: 
      - 9100 
    networks: 
      - monitoring_net 

  cadvisor: 
    image: gcr.io/cadvisor/cadvisor:latest 
    container_name: cadvisor 
    restart: unless-stopped 
    ports: 
      - '8080:8080' 
    volumes: 
      - /:/rootfs:ro 
      - /var/run:/var/run:rw 
      - /sys:/sys:ro 
      - /var/lib/docker/:/var/lib/docker:ro 
    depends_on: 
      - redis 
    networks: 
      - monitoring_net 

  redis: 
    image: redis:latest 
    container_name: redis 
    expose: 
      - 6379 
    networks: 
      - monitoring_net 

networks: 
  monitoring_net: 
    external: true 

Explicación del Archivo Docker Compose:

El archivo define varios services, cada uno representando un contenedor:

• grafana: Configura el contenedor de Grafana, mapeando su puerto web (3000) al host y persistiendo sus datos en un volumen del host. Se une a la red monitoring_net.
• prometheus: Configura el contenedor de Prometheus, montando su archivo de configuración (prometheus.yml) y volumen de datos en el host. Su puerto web (9090) se mapea al host. También se une a la red monitoring_net y especifica argumentos de comando para su inicio.
• node-exporter: Configura el contenedor de Node Exporter. Crucialmente, monta directorios del sistema operativo host (/proc, /sys, /) en modo lectura (ro) para poder acceder a las métricas del sistema. Especifica los paths correctos en su comando de inicio. Expone su puerto por defecto (9100) internamente en la red monitoring_net.
• cadvisor: Configura el contenedor de cAdvisor. Mapea su puerto web (8080) al host y monta varios directorios (/, /var/run, /sys, /var/lib/docker) que necesita para acceder a la información de los contenedores y el sistema Docker. Depende del servicio redis para iniciar y se une a la red monitoring_net.
• redis: Configura el contenedor de Redis, exponiendo su puerto por defecto (6379) internamente en la red monitoring_net. Su inclusión aquí es principalmente como dependencia para cAdvisor en este setup específico.

Finalmente, la sección networks define la red monitoring_net como external: true. Esto significa que Docker Compose buscará una red existente con ese nombre en lugar de crear una nueva. Debes crear esta red manualmente antes de ejecutar el docker-compose utilizando el comando: docker network create monitoring_net

Configuración de Prometheus (prometheus.yml)

El archivo prometheus.yml le dice a Prometheus qué objetivos (targets) debe “raspar” (scrape) para obtener métricas y con qué frecuencia debe hacerlo.

Aquí está el contenido del archivo prometheus.yml:

global:
  scrape_interval:   15s 
scrape_configs: 

  - job_name: 'prometheus' 
    scrape_interval: 15s 
    static_configs: 
    - targets: ['prometheus:9090'] 

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

  - job_name: 'node-exporter' 
    static_configs: 
    - targets: ['node-exporter:9100'] 

Explicación del Archivo de Configuración de Prometheus:

• global: Establece el intervalo de raspado por defecto (scrape_interval) en 15 segundos.
• scrape_configs: Define una lista de trabajos (job_name). Cada trabajo especifica un conjunto de targets que Prometheus debe monitorear.
  • El trabajo ‘prometheus’ se configura para raspar las métricas del propio servidor Prometheus en su puerto 9090. Esto es útil para monitorear la salud y el rendimiento del servidor de monitoreo.
  • El trabajo ‘cadvisor’ se configura para raspar las métricas de cAdvisor en el puerto 8080. Gracias a la red Docker, Prometheus puede referirse al contenedor cAdvisor simplemente por su nombre de servicio (cadvisor).
  • El trabajo ‘node-exporter’ se configura para raspar las métricas de Node Exporter en el puerto 9100, utilizando el nombre del servicio Docker (node-exporter).

Este archivo de configuración le indica a Prometheus que debe conectarse a los servicios prometheus, cadvisor y node-exporter dentro de la red monitoring_net (Docker maneja la resolución de nombres) en sus respectivos puertos para recolectar métricas cada 15 segundos.

Conclusión

Implementar una estrategia de observabilidad robusta es esencial para gestionar eficazmente infraestructuras basadas en servidores y Docker. La pila Prometheus, Grafana, Node Exporter y cAdvisor proporciona una base sólida para el monitoreo, permitiéndonos recopilar, almacenar y visualizar métricas cruciales sobre el rendimiento del sistema host y el consumo de recursos a nivel de contenedor. Al configurar estas herramientas mediante Docker Compose y definir correctamente los trabajos de raspado en Prometheus, podemos obtener la visibilidad necesaria para mantener nuestros sistemas saludables, identificar problemas rápidamente y optimizar nuestra infraestructura de manera proactiva.

Este setup es un excelente punto de partida. Para una observabilidad completa, se deberían integrar soluciones de logging (como ELK stack o Loki) y tracing (como Jaeger o Zipkin) para complementar la información proporcionada por el monitoreo.