Enterarte de que un servidor está caído porque un usuario te llama es la peor forma de monitorear infraestructura. Un sistema de monitoreo profesional te muestra el estado de todos tus servidores en tiempo real, te avisa antes de que los problemas impacten a los usuarios y te da datos históricos para tomar decisiones de capacidad.
En esta guía vas a instalar Prometheus + Grafana desde cero, configurar la recolección de métricas de tus servidores Linux y crear un dashboard profesional — todo en menos de una hora.
Arquitectura
Antes de instalar, entiende cómo funcionan las piezas juntas:
┌──────────────────────────────────────────────────┐
│ Tu navegador │
│ (dashboards Grafana) │
└────────────────────┬─────────────────────────────┘
│ :3000
┌────────────────────▼─────────────────────────────┐
│ Grafana │
│ Visualización, dashboards, alertas │
└────────────────────┬─────────────────────────────┘
│ consulta métricas
┌────────────────────▼─────────────────────────────┐
│ Prometheus │
│ Recolección y almacenamiento de métricas │
│ (scraping cada 15s) │
└───┬────────────────┬──────────────────┬──────────┘
│ :9100 │ :9100 │ :9100
┌───▼───┐ ┌────▼────┐ ┌────▼────┐
│Servidor│ │Servidor │ │Servidor │
│ App │ │ DB │ │ Web │
│(node_ │ │(node_ │ │(node_ │
│exporter│ │exporter)│ │exporter)│
└────────┘ └─────────┘ └─────────┘
node_exporter corre en cada servidor que quieres monitorear y expone métricas (CPU, RAM, disco, red) en un endpoint HTTP. Prometheus hace scraping de esos endpoints cada 15 segundos y almacena las métricas. Grafana consulta Prometheus y muestra los datos en dashboards.
Requisitos previos
Un servidor Ubuntu 24.04 dedicado al monitoreo (puede ser el mismo que corras otros servicios si es pequeño). Recomendamos al menos 2 GB de RAM y 20 GB de disco.
Paso 1: Instalar node_exporter en los servidores a monitorear
Instala node_exporter en cada servidor que quieras monitorear. Es un binario ligero que expone métricas del sistema operativo:
# Descargar la última versión
cd /tmp
curl -LO https://github.com/prometheus/node_exporter/releases/download/v1.8.2/node_exporter-1.8.2.linux-amd64.tar.gz
tar xzf node_exporter-1.8.2.linux-amd64.tar.gz
# Instalar
sudo cp node_exporter-1.8.2.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /bin/false node_exporter
Crea el servicio de systemd:
sudo tee /etc/systemd/system/node_exporter.service > /dev/null <<EOF
[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
[Install]
WantedBy=multi-user.target
EOF
Arranca y habilita el servicio:
sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter
Verifica que está corriendo:
curl http://localhost:9100/metrics | head -20
Deberías ver líneas con métricas como node_cpu_seconds_total, node_memory_MemTotal_bytes, etc.
Firewall
node_exporter escucha en el puerto 9100. Asegúrate de que Prometheus pueda acceder a este puerto. Con UFW:
sudo ufw allow from 10.0.1.5 to any port 9100 comment 'Prometheus scraping'
Solo permite acceso desde la IP del servidor de Prometheus — no expongas el puerto a internet.
Paso 2: Instalar Prometheus
Ahora en el servidor de monitoreo, instala Prometheus:
cd /tmp
curl -LO https://github.com/prometheus/prometheus/releases/download/v2.54.0/prometheus-2.54.0.linux-amd64.tar.gz
tar xzf prometheus-2.54.0.linux-amd64.tar.gz
sudo cp prometheus-2.54.0.linux-amd64/{prometheus,promtool} /usr/local/bin/
sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo cp -r prometheus-2.54.0.linux-amd64/{consoles,console_libraries} /etc/prometheus/
sudo useradd --no-create-home --shell /bin/false prometheus
sudo chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus
Crea el archivo de configuración:
sudo tee /etc/prometheus/prometheus.yml > /dev/null <<EOF
global:
scrape_interval: 15s
evaluation_interval: 15s
scrape_configs:
# Monitorear el propio Prometheus
- job_name: 'prometheus'
static_configs:
- targets: ['localhost:9090']
# Servidores Linux
- job_name: 'servidores'
static_configs:
- targets:
- '10.0.1.10:9100' # Servidor App
- '10.0.1.11:9100' # Servidor DB
- '10.0.1.12:9100' # Servidor Web
labels:
env: 'produccion'
- targets:
- '10.0.1.20:9100' # Servidor Dev
labels:
env: 'desarrollo'
EOF
Crea el servicio de systemd:
sudo tee /etc/systemd/system/prometheus.service > /dev/null <<EOF
[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target
[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
--config.file=/etc/prometheus/prometheus.yml \
--storage.tsdb.path=/var/lib/prometheus \
--storage.tsdb.retention.time=30d \
--web.enable-lifecycle
[Install]
WantedBy=multi-user.target
EOF
Arranca Prometheus:
sudo systemctl daemon-reload
sudo systemctl enable --now prometheus
Verifica en tu navegador: http://tu-servidor:9090. Deberías ver la interfaz web de Prometheus. Ve a Status → Targets y confirma que todos tus servidores aparecen como UP.
Retención de datos
La configuración --storage.tsdb.retention.time=30d conserva 30 días de métricas. Ajusta según tu espacio en disco. Prometheus usa aproximadamente 1-2 bytes por sample, así que 3 servidores con scraping cada 15s generan ~500 MB/mes.
Paso 3: Instalar Grafana
En el mismo servidor de monitoreo:
# Agregar repositorio oficial de Grafana
sudo apt install -y apt-transport-https software-properties-common
sudo mkdir -p /etc/apt/keyrings/
wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null
echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
# Instalar
sudo apt update
sudo apt install grafana -y
# Arrancar
sudo systemctl enable --now grafana-server
Accede a Grafana en http://tu-servidor:3000. Las credenciales por defecto son admin / admin — te pedirá cambiar la contraseña al primer login.
Paso 4: Conectar Grafana con Prometheus
- En Grafana, ve a Connections → Data sources → Add data source
- Selecciona Prometheus
- En la URL pon:
http://localhost:9090 - Clic en Save & test — debería mostrar "Data source is working"
Paso 5: Importar un dashboard profesional
En lugar de crear un dashboard desde cero, Grafana tiene una biblioteca con miles de dashboards pre-construidos. El más popular para node_exporter es el Node Exporter Full (ID: 1860):
- Ve a Dashboards → Import
- Escribe el ID
1860y clic en Load - Selecciona tu data source de Prometheus
- Clic en Import
En segundos tendrás un dashboard profesional con métricas de CPU, RAM, disco, red, filesystem, I/O y más — para cada servidor.
Otros dashboards recomendados
| ID | Nombre | Uso |
|---|---|---|
| 1860 | Node Exporter Full | Métricas detalladas por servidor |
| 11074 | Node Exporter Dashboard | Vista compacta por servidor |
| 15172 | Node Exporter Overview | Vista general de múltiples servidores |
| 3662 | Prometheus 2.0 Overview | Métricas del propio Prometheus |
Paso 6: Configurar alertas
Grafana puede enviarte alertas cuando una métrica supera un umbral. Configura las alertas más importantes:
Alerta de disco al 85%
- En un panel del dashboard, clic en Edit
- Ve a la pestaña Alert
- Crea una nueva regla:
- Condición:
avg(1 - (node_filesystem_avail_bytes / node_filesystem_size_bytes)) > 0.85 - Evaluar cada:
1mpor5m - Mensaje: "Disco al en "
- Condición:
Alerta de memoria al 90%
(1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) > 0.90
Alerta de CPU sostenido al 90%
100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 90
Canal de notificación
Configura dónde quieres recibir las alertas en Alerting → Contact points:
- Slack — webhook a un canal de #alertas
- Email — requiere configurar SMTP en
/etc/grafana/grafana.ini - Telegram — bot de Telegram con chat ID
- Webhook — para integrar con cualquier sistema
Paso 7: Monitorear servicios adicionales
node_exporter cubre el sistema operativo. Para servicios específicos, agrega exporters:
PostgreSQL
# Instalar postgres_exporter
docker run -d --name pg_exporter \
-e DATA_SOURCE_NAME="postgresql://monitor:password@localhost:5432/postgres?sslmode=disable" \
-p 9187:9187 \
prometheuscommunity/postgres-exporter
Agregar a prometheus.yml:
- job_name: 'postgresql'
static_configs:
- targets: ['10.0.1.11:9187']
Dashboard recomendado: ID 9628 (PostgreSQL Database).
Nginx
Habilita stub_status en Nginx y usa nginx-prometheus-exporter:
docker run -d --name nginx_exporter \
-p 9113:9113 \
nginx/nginx-prometheus-exporter \
--nginx.scrape-uri=http://10.0.1.12/nginx_status
Redis
docker run -d --name redis_exporter \
-p 9121:9121 \
oliver006/redis_exporter \
--redis.addr=redis://10.0.1.11:6379
Asegurar Grafana en producción
Antes de exponer Grafana a tu equipo, aplica estas configuraciones de seguridad:
# /etc/grafana/grafana.ini
[security]
# Deshabilitar registro público
disable_initial_admin_creation = false
admin_user = admin
[users]
# No permitir que los usuarios se registren solos
allow_sign_up = false
[auth.anonymous]
# No permitir acceso anónimo
enabled = false
Reinicia Grafana después de cambiar la configuración:
sudo systemctl restart grafana-server
Para acceso externo, pon Grafana detrás de Nginx con HTTPS:
server {
listen 443 ssl;
server_name grafana.tuempresa.com;
ssl_certificate /etc/letsencrypt/live/grafana.tuempresa.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/grafana.tuempresa.com/privkey.pem;
location / {
proxy_pass http://localhost:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
# WebSocket para live dashboards
location /api/live/ws {
proxy_pass http://localhost:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
}
Siguientes pasos
Con Prometheus y Grafana corriendo, puedes expandir tu monitoreo:
- Alertmanager — gestión avanzada de alertas con silencing, agrupación y escalamiento
- Loki — agregación de logs que se integra nativamente con Grafana (como un "Prometheus para logs")
- Docker monitoring — cAdvisor para métricas de contenedores
- Blackbox Exporter — monitoreo de endpoints HTTP, TCP y DNS desde fuera (uptime monitoring)
- Monitoreo profesional con Zabbix para monitoreo SNMP de switches, firewalls y UPS
Monitoreo empresarial
¿Necesitas monitoreo profesional para toda tu infraestructura?
Implementamos Prometheus, Grafana y Zabbix con alertas proactivas, dashboards personalizados y soporte 24/7.
