Prometheus por sí solo no sabe cuánta CPU usa tu servidor ni cuánta RAM consume cada contenedor: necesita exportadores que traduzcan el estado del sistema a métricas. Los dos imprescindibles son Node Exporter, para el sistema anfitrión, y cAdvisor, para los contenedores. En esta guía levantas ambos con un único docker-compose.yml, los conectas a Prometheus para que los recoja de forma automática, repasas las métricas clave de CPU, memoria, disco y red, y aseguras los exportadores para que no queden expuestos. La misma explicación está disponible en inglés.

Puntos clave

  • Node Exporter expone métricas del sistema anfitrión (CPU, RAM, disco, red, carga) en el puerto 9100; su última versión es la v1.12.1, publicada el 14 de julio de 2026.
  • cAdvisor (Container Advisor, de Google) expone métricas por contenedor en el puerto 8080; la última versión estable es la v0.60.5.
  • Node Exporter es muy ligero (unos 20 MB de RAM en reposo), mientras que cAdvisor pesa más (en torno a 150 MB) porque analiza todos los contenedores en tiempo real.
  • Ambos se conectan a Prometheus como targets dentro de la misma red de Docker, y se descubren por el nombre del servicio (node-exporter:9100, cadvisor:8080).
  • El panel de Grafana más usado para Node Exporter es el número 1860 (Node Exporter Full), que se importa por su identificador y muestra decenas de gráficas sin configuración manual.

¿Qué mide Node Exporter y qué mide cAdvisor?

Son complementarios, no intercambiables, y esa es la confusión más habitual. Node Exporter mide la máquina física o virtual completa: el uso de CPU por núcleo y por modo (usuario, sistema, espera de disco), la memoria total y disponible, el espacio y la actividad de cada sistema de archivos, el tráfico de red por interfaz, la carga media y el tiempo de actividad. No sabe nada de contenedores; ve el servidor como un todo. Es el proyecto oficial de Prometheus para métricas de host en Linux y expone varios cientos de series distintas mediante sus colectores.

cAdvisor mide cada contenedor por separado: cuánta CPU y memoria consume, su tráfico de red y su uso de disco, con etiquetas por nombre de contenedor e imagen. Su propia documentación lo resume así: "cAdvisor ofrece a los usuarios de contenedores una comprensión del uso de recursos y las características de rendimiento de sus contenedores en ejecución". En la práctica, Node Exporter responde a "¿le queda RAM al servidor?" y cAdvisor a "¿qué contenedor se está comiendo esa RAM?". Por eso se despliegan juntos: uno da la foto global y el otro, el desglose. Si vienes de fijar límites de recursos y logs en Docker, cAdvisor es la herramienta que te confirma si esos límites se están respetando.

¿Cómo es el docker-compose.yml de los dos exportadores?

Crea una carpeta para el proyecto y guarda dentro este docker-compose.yml. Levanta los dos exportadores en una red llamada monitoring, la misma a la que después conectarás Prometheus, y no publica sus puertos a Internet: solo los expone dentro de la red de Docker.

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

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:v0.60.5
    restart: unless-stopped
    privileged: true
    devices:
      - /dev/kmsg
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
    expose:
      - 8080
    networks:
      - monitoring

networks:
  monitoring:
    name: monitoring

Conviene entender los montajes, porque son lo que hace que un contenedor pueda ver el estado de todo el servidor. Node Exporter necesita /proc y /sys del anfitrión (de ahí --path.procfs y --path.sysfs) y la raíz del sistema de archivos en /rootfs para calcular el espacio en disco real. La opción --collector.filesystem.mount-points-exclude evita que cuente los puntos de montaje internos del propio contenedor. El doble símbolo $$ no es un error: en Docker Compose escapa un $ literal para que la expresión regular llegue intacta.

cAdvisor pide más acceso: monta la raíz, el socket de Docker en /var/run, /sys y el directorio /var/lib/docker, y necesita privileged: true junto con el dispositivo /dev/kmsg para vigilar los eventos de falta de memoria (OOM). Fija siempre una versión concreta como v0.60.5 en lugar de :latest, porque una etiqueta flotante puede cambiar de versión durante un simple reinicio y romper el panel. Con el archivo listo, arranca la pila y comprueba que los dos exportadores responden:

docker compose up -d
docker compose ps
curl -s localhost:9100/metrics | head    # solo si publicas el puerto

¿Cómo conectarlos a Prometheus?

Los exportadores solo generan las métricas; quien las recoge y las guarda es Prometheus, que las lee cada cierto intervalo (el modelo pull). Basta con añadir los dos trabajos a tu prometheus.yml y unir Prometheus a la red monitoring. Como comparten red, Prometheus los alcanza por el nombre del servicio, sin publicar ningún puerto:

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

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

Recarga Prometheus y entra en su interfaz (Status, luego Targets): los dos trabajos deben aparecer en estado UP. Si ves DOWN, casi siempre es porque Prometheus y los exportadores no están en la misma red de Docker o porque el nombre del servicio no coincide. Todo el proceso de instalar y configurar el recolector está en la guía de cómo instalar Prometheus con Docker.

A partir de ahí, la forma cómoda de ver los datos es con paneles. En Grafana añades Prometheus como fuente de datos e importas el panel 1860 (Node Exporter Full) por su identificador: en segundos tienes CPU, memoria, disco y red del anfitrión en gráficas. Para los contenedores existen paneles equivalentes basados en las métricas de cAdvisor.

¿Cuáles son las métricas clave de CPU, RAM, disco y contenedores?

No hace falta memorizar los cientos de series disponibles; con un puñado cubres el 90 % de la monitorización diaria. Del lado del host (Node Exporter):

  • node_cpu_seconds_total: segundos de CPU por núcleo y modo. El porcentaje de uso se calcula sobre el modo idle.
  • node_memory_MemAvailable_bytes: memoria realmente disponible, más fiable que la memoria libre.
  • node_filesystem_avail_bytes: espacio libre por sistema de archivos; ideal para alertar antes de que un disco se llene.
  • node_load1 y node_network_receive_bytes_total: carga media a un minuto y tráfico de red entrante.

Del lado de los contenedores (cAdvisor), las series llevan las etiquetas name e image:

  • container_cpu_usage_seconds_total: CPU acumulada por contenedor.
  • container_memory_working_set_bytes: memoria en uso real de cada contenedor, la que cuenta para el límite y para el OOM.
  • container_network_receive_bytes_total y container_fs_usage_bytes: red y disco por contenedor.

Con estas dos familias montas alertas útiles desde el primer día: "queda menos del 10 % de disco", "la RAM disponible baja de 500 MB" o "un contenedor supera el 90 % de su límite de memoria".

¿Cómo proteger los exportadores?

Aquí está el error de seguridad más común de los homelabs. Las métricas de Node Exporter y, sobre todo, de cAdvisor revelan mucho sobre tu infraestructura: nombres de contenedores, imágenes, rutas y volumen de tráfico. No publiques nunca los puertos 9100 y 8080 directamente a Internet. En el docker-compose.yml anterior se usa expose en lugar de ports precisamente por eso: los exportadores quedan accesibles solo dentro de la red de Docker, que es todo lo que Prometheus necesita.

Hay un riesgo adicional específico de cAdvisor: al montar el socket de Docker y correr con privileged: true, tiene un acceso muy amplio al anfitrión. Trátalo como un componente sensible, mantenlo dentro de la red interna y no lo expongas nunca sin autenticación. Si necesitas consultar la interfaz web de cualquiera de los dos desde fuera, hazlo a través de un proxy inverso con contraseña o detrás de una VPN, nunca abriendo el puerto en el cortafuegos. La regla es sencilla: los exportadores hablan con Prometheus por la red interna, y solo Grafana (protegido con su propio inicio de sesión) mira al exterior.

Preguntas frecuentes

¿Necesito los dos exportadores o me basta con uno?

Depende de qué quieras vigilar. Si solo te importa la salud del servidor (CPU, RAM y disco del host), con Node Exporter es suficiente. Si además quieres saber qué consume cada contenedor por separado, necesitas cAdvisor. En un servidor que ejecuta varios servicios en Docker lo normal es desplegar los dos, porque responden preguntas distintas: uno mide la máquina y el otro, cada contenedor.

¿Por qué cAdvisor consume tanta CPU?

Porque recorre y analiza en tiempo real todos los contenedores en ejecución, y ese trabajo crece con el número de contenedores. Es un consumo conocido del proyecto. Puedes reducirlo desactivando colectores que no uses (por ejemplo, con --disable_metrics=disk,tcp,udp) o subiendo el intervalo de recogida en Prometheus de 15 a 30 segundos, lo que baja la frecuencia con la que se le pregunta.

¿Puedo usar cAdvisor sin Prometheus?

Sí. cAdvisor trae su propia interfaz web en el puerto 8080, donde ves gráficas básicas de uso por contenedor en vivo. Es útil para una comprobación rápida, pero no guarda historial: en cuanto cierras la página, los datos desaparecen. Para conservar métricas a lo largo del tiempo, crear alertas y hacer paneles, necesitas que Prometheus las recoja y almacene.

Conclusión

Con un único docker-compose.yml tienes los dos exportadores que necesita cualquier stack de monitorización: Node Exporter para el sistema anfitrión y cAdvisor para los contenedores, ambos en la red interna y listos para que Prometheus los recoja. El siguiente paso es conectarlos a Prometheus y visualizar los datos en Grafana importando el panel 1860. A partir de ahí, deja de adivinar por qué va lento tu servidor: lo verás en una gráfica, con nombre y apellidos del contenedor culpable.

Fuentes

  1. Prometheus Node Exporter (repositorio oficial en GitHub)
  2. cAdvisor de Google (repositorio oficial en GitHub)
  3. Guía oficial de Prometheus: monitorizar un host con Node Exporter
  4. Panel Node Exporter Full en Grafana Labs
  5. Imagen prom/node-exporter en Docker Hub

Ruta: Monitorización y observabilidad con Docker