Monitorizar la CPU, la RAM y la red de servidores autoalojados con Prometheus y Grafana en Ubuntu Server

Cualquiera que gestione aunque sean un par de servidores autoalojados —un NAS, un VPS para proyectos personales, un pequeño homelab con dos o tres máquinas— termina haciéndose la misma pregunta: ¿cómo saber si un nodo está a punto de quedarse sin RAM, si la CPU está bajo mucha carga, o si el tráfico de red tiene un pico anómalo, sin tener que conectarse manualmente cada vez? La respuesta más extendida en el mundo del software libre es un dúo de herramientas que se ha convertido en un estándar de facto: Prometheus para recopilar las métricas y Grafana para mostrarlas en paneles claros y personalizables.

En esta guía vamos a montar un clúster de monitorización ligero sobre Ubuntu Server, pensado para vigilar la CPU, la RAM y el tráfico de red de varios nodos autoalojados, con un impacto mínimo en los recursos de las máquinas monitorizadas. No es necesario ser un administrador de sistemas experimentado: cada paso se explica junto con los conceptos básicos que lo sustentan.

Por qué monitorizar tus servidores autoalojados

Quien aloja sus propios servicios —un sitio web, un servidor de correo, un NAS, una instancia de Nextcloud o un pequeño clúster para proyectos personales— a menudo solo descubre los problemas cuando el servicio ya es inaccesible: disco lleno, memoria agotada por un proceso con fugas, una interfaz de red saturada de tráfico. Un sistema de monitorización permite:

• Detectar señales de alerta con antelación: un uso de RAM que crece de forma constante durante varios días antes de una caída, por ejemplo, es visible en una gráfica mucho antes de que se convierta en un problema real.
• Entender las causas de las ralentizaciones: si un sitio responde lentamente, una gráfica histórica de CPU e I/O de red ayuda a determinar si la causa es un pico de carga u otra cosa.
• Planificar las mejoras: observar el uso de los recursos a lo largo del tiempo es la forma más sencilla de saber cuándo realmente se necesita más RAM o más ancho de banda, en lugar de actualizar "a ojo".
• Recibir avisos: una vez recopiladas las métricas, es posible configurar alertas automáticas (por ejemplo mediante Alertmanager, la herramienta complementaria de Prometheus) cuando se supera un umbral.

Las herramientas: Prometheus, Node Exporter y Grafana

Antes de instalar nada, conviene entender qué hace cada componente, ya que el stack está formado por tres piezas distintas que trabajan juntas:

• Prometheus es una base de datos de series temporales especializada en la recopilación de métricas. A diferencia de muchos sistemas de monitorización más antiguos, Prometheus funciona con un modelo de "pull" (extracción): a intervalos regulares, es él quien consulta a las máquinas monitorizadas para pedir los datos más recientes, en lugar de esperar a que esas máquinas se los envíen.
• Node Exporter es un pequeño programa que hay que instalar en cada máquina que se quiera monitorizar. Su función es exponer las métricas del sistema (uso de CPU, RAM, disco, interfaces de red, etc.) en un formato que Prometheus pueda leer, a través de una simple página web interna en el puerto 9100.
• Grafana es la capa visual: se conecta a Prometheus como "fuente de datos" y permite construir paneles con gráficos, umbrales de colores, alertas visuales y mucho más, sin necesidad de escribir código.

En la práctica: Node Exporter recopila los datos en bruto en cada nodo, Prometheus los recoge periódicamente y los almacena, y Grafana los lee desde Prometheus y los representa.

Requisitos y arquitectura del clúster ligero

Para esta guía partimos de una arquitectura sencilla pero realista para un homelab o un pequeño conjunto de VPS:

• Un nodo "central" con Ubuntu Server (sirve tanto la versión 24.04 LTS, todavía la más extendida en muchos homelabs, como la más reciente 26.04 LTS), en el que instalaremos Prometheus y Grafana. Con 1 vCPU y 1-2 GB de RAM es suficiente para monitorizar una decena de nodos con métricas básicas.
• Uno o varios nodos "a monitorizar" (incluyendo opcionalmente el propio nodo central), en cada uno de los cuales instalaremos solo Node Exporter, un proceso extremadamente ligero (apenas unos MB de RAM).
• Acceso SSH con privilegios sudo en todas las máquinas implicadas.

La gran ventaja de esta combinación es precisamente su ligereza: a diferencia de soluciones más pesadas basadas en agentes complejos o bases de datos relacionales, Prometheus y Node Exporter están escritos en Go, se compilan como binarios únicos sin dependencias que instalar, y están pensados para consumir muy pocos recursos incluso en hardware modesto (una Raspberry Pi o un VPS económico funcionan perfectamente).

Paso 1: instalar Prometheus en el nodo central

Conectémonos por SSH al nodo central y creemos primero un usuario de sistema dedicado, para que Prometheus no se ejecute con privilegios de root:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus /var/lib/prometheus

A continuación, descargamos la última versión estable de Prometheus (la serie 3.x en el momento de escribir esto) desde la página oficial de descargas. Es buena práctica comprobar siempre la versión más reciente disponible en prometheus.io/download antes de continuar:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v3.15.1/prometheus-3.15.1.linux-amd64.tar.gz
tar xvf prometheus-3.15.1.linux-amd64.tar.gz
cd prometheus-3.15.1.linux-amd64

sudo cp prometheus promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool

sudo cp -r consoles/ console_libraries/ /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus/consoles /etc/prometheus/console_libraries

Paso 2: crear el servicio systemd de Prometheus

Para que Prometheus se inicie automáticamente al arrancar el servidor y sea gestionado por systemd (el componente de Ubuntu encargado de iniciar y supervisar los servicios en segundo plano), creamos un archivo de unidad:

sudo nano /etc/systemd/system/prometheus.service

con este contenido:

[Unit]
Description=Prometheus Monitoring System
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
Group=prometheus
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --web.listen-address=0.0.0.0:9090
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Creamos también un archivo prometheus.yml mínimo para empezar (lo completaremos en el Paso 4):

sudo nano /etc/prometheus/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

Después, iniciamos y habilitamos el servicio:

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
sudo systemctl daemon-reload
sudo systemctl enable --now prometheus

Comprobamos que esté activo con sudo systemctl status prometheus: debería mostrar active (running) en verde. En este punto, la interfaz web de Prometheus ya es accesible en http://IP-DEL-NODO-CENTRAL:9090.

Paso 3: instalar Node Exporter en cada nodo a monitorizar

Este paso debe repetirse en cada nodo que se quiera monitorizar (incluido el nodo central, si también se quieren monitorizar sus propios recursos). Creamos un usuario dedicado e instalamos el binario:

sudo useradd --no-create-home --shell /bin/false node_exporter

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.12.1/node_exporter-1.12.1.linux-amd64.tar.gz
tar xvf node_exporter-1.12.1.linux-amd64.tar.gz
sudo cp node_exporter-1.12.1.linux-amd64/node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Creamos también el servicio systemd para Node Exporter:

sudo nano /etc/systemd/system/node_exporter.service

[Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter

Node Exporter ahora expone las métricas en bruto en el puerto 9100: podemos comprobarlo con curl http://localhost:9100/metrics, que debería devolver cientos de líneas de datos sobre CPU, memoria, sistemas de archivos e interfaces de red.

Paso 4: configurar Prometheus para recopilar las métricas de todos los nodos

Volvemos al nodo central y actualizamos /etc/prometheus/prometheus.yml añadiendo un "job" para cada nodo a monitorizar, con su dirección IP y el puerto 9100 de Node Exporter:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

  - job_name: "node_exporter"
    static_configs:
      - targets:
          - "localhost:9100"
          - "192.168.1.11:9100"
          - "192.168.1.12:9100"

Después de cada cambio en este archivo, conviene comprobar su sintaxis con promtool check config /etc/prometheus/prometheus.yml, y luego recargar la configuración sin reiniciar el servicio:

sudo systemctl reload prometheus

Desde la interfaz de Prometheus (http://IP-DEL-NODO-CENTRAL:9090/targets) podemos comprobar que todos los nodos aparecen con estado UP: es la señal de que Prometheus los está consultando con éxito.

Paso 5: abrir los puertos necesarios en el firewall

Si ufw (el firewall predeterminado de Ubuntu) está activo en los nodos, hay que abrir los puertos necesarios. En el nodo central, para permitir el acceso a la interfaz de Prometheus y, más adelante, a la de Grafana:

sudo ufw allow 9090/tcp
sudo ufw allow 3000/tcp

En cada nodo monitorizado, en cambio, el puerto 9100 de Node Exporter debe abrirse solo hacia la dirección IP del nodo central, no hacia todo Internet, para no exponer las métricas del sistema a cualquiera:

sudo ufw allow from 192.168.1.10 to any port 9100 proto tcp

(sustituyendo 192.168.1.10 por la IP real del nodo central).

Paso 6: instalar Grafana

Grafana se instala más cómodamente a través del repositorio APT oficial, lo que facilita futuras actualizaciones con apt upgrade. En el nodo central:

sudo apt-get install -y apt-transport-https wget gnupg

sudo mkdir -p /etc/apt/keyrings
sudo wget -q -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc

echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list

sudo apt-get update
sudo apt-get install -y grafana

Iniciamos y habilitamos el servicio:

sudo systemctl daemon-reload
sudo systemctl enable --now grafana-server

Grafana ya es accesible en http://IP-DEL-NODO-CENTRAL:3000. Las credenciales predeterminadas en el primer acceso son admin / admin: Grafana pedirá de inmediato cambiar la contraseña, algo que siempre conviene hacer, especialmente si el servidor está expuesto a Internet.

Paso 7: conectar Grafana con Prometheus

Una vez dentro de la interfaz de Grafana:

• En el menú lateral, vamos a Connections > Data sources y elegimos Add data source.
• Seleccionamos Prometheus de la lista.
• En el campo URL introducimos http://localhost:9090 (dado que Prometheus se ejecuta en la misma máquina; si estuviera en otro lugar, habría que usar su dirección IP).
• Hacemos clic en Save & test: si todo está configurado correctamente, aparecerá un mensaje de conexión correcta.

Paso 8: importar un panel ya preparado para CPU, RAM y tráfico de red

No es necesario construir los gráficos desde cero: la comunidad de Grafana comparte paneles ya hechos y gratuitos. El más utilizado para Node Exporter es el panel "Node Exporter Full" (ID 1860), que muestra en un único panel la CPU, la RAM, el espacio de disco, la I/O y el tráfico de red de cada nodo monitorizado.

Para importarlo:

• En el menú lateral, Dashboards > New > Import.
• En el campo "Import via grafana.com" introducimos 1860 y hacemos clic en Load.
• Seleccionamos como fuente de datos la de Prometheus que acabamos de crear, y después Import.

En pocos segundos, el panel se llena con datos reales de todos los nodos monitorizados, con la posibilidad de elegir el nodo a mostrar desde un menú desplegable en la parte superior.

Consejos para una monitorización segura y sostenible

• No expongas Prometheus ni Node Exporter directamente a Internet. Ninguno de los dos tiene, por defecto, un sistema de autenticación: deben mantenerse en una red privada (LAN, VPN como WireGuard o Tailscale) o detrás de un proxy inverso con autenticación.
• Pon Grafana detrás de HTTPS si es accesible desde Internet, por ejemplo con un proxy inverso Nginx y un certificado de Let's Encrypt.
• Establece un periodo de retención de datos razonable. Por defecto, Prometheus conserva los datos durante 15 días; en un homelab con poco espacio en disco puede ser útil reducirlo con la opción --storage.tsdb.retention.time, o aumentarlo si se dispone de más espacio.
• Considera Alertmanager para recibir notificaciones automáticas (correo electrónico, Telegram, etc.) cuando una métrica supere un umbral crítico, en lugar de tener que revisar los paneles manualmente.
• Actualiza periódicamente Prometheus y Node Exporter: al ser binarios únicos, actualizarlos consiste simplemente en repetir los pasos de descarga y sustitución del archivo, mientras que Grafana se actualiza con apt upgrade una vez configurado el repositorio.

Conclusión

Con apenas unos comandos y un impacto mínimo en los recursos, Prometheus, Node Exporter y Grafana permiten construir un sistema de monitorización de nivel profesional incluso para un simple homelab o un pequeño conjunto de servidores personales. Una vez que se domina el stack, es fácil ampliarlo con nuevos jobs de scraping (por ejemplo para monitorizar también servicios de aplicación, no solo el hardware), nuevos paneles de la comunidad y alertas automáticas a través de Alertmanager.

Fuentes oficiales

• Prometheus — Monitoring Linux host metrics with the Node Exporter
• Prometheus — página oficial de descargas
• Grafana — instalación en Debian/Ubuntu (documentación oficial)
• Grafana — panel comunitario "Node Exporter Full" (ID 1860)