Si tienes un pequeño servidor en casa, ya sea para pruebas, almacenamiento, domótica o cualquier otro proyecto personal, seguro que más de una vez te has preguntado cómo está rindiendo. ¿Va la CPU a tope? ¿Queda poca memoria? Saber qué ocurre en tiempo real es fundamental, no solo para solucionar problemas, sino también para optimizar y entender mejor tu sistema. Hoy vamos a ver cómo montar una solución bastante potente y estándar en la industria para monitorizar servidor casero: Prometheus y Grafana. Y lo haremos paso a paso, ideal para principiantes.
¿Qué son Prometheus y Grafana (y por qué deberías usarlos)?
Antes de meternos en faena, aclaremos qué hace cada pieza:
- Prometheus: Es una base de datos de series temporales y un sistema de monitorización. Su trabajo principal es «preguntar» (hacer scraping) a diferentes servicios o sistemas (llamados targets) sobre sus métricas actuales (CPU, memoria, red, etc.) y almacenar esos datos con una marca de tiempo. Es muy eficiente para este tipo de datos.
- Grafana: Es una plataforma de visualización y análisis. Grafana se conecta a diferentes fuentes de datos (como Prometheus) y te permite crear paneles (dashboards) muy visuales con gráficos, medidores y tablas para entender fácilmente la información recopilada.
La combinación de ambos es un estándar de facto en muchos entornos profesionales, y perfectamente aplicable a nuestro servidor casero. Nos da una visión clara y gráfica del estado de nuestro sistema.
Preparando el Terreno: Lo que Necesitas
Para seguir esta guía Grafana Prometheus, asumiré que tienes:
- Un servidor casero: Lo más probable es que corra alguna distribución Linux (Ubuntu, Debian, CentOS…). Los comandos pueden variar ligeramente, pero la lógica es la misma.
- Acceso a la terminal: Necesitarás ejecutar comandos como administrador (root o usando
sudo). - Docker y Docker Compose (Recomendado): Aunque se pueden instalar directamente, usar Docker simplifica enormemente la gestión de Prometheus y Grafana, especialmente las actualizaciones y dependencias. Si no los tienes, su instalación suele ser sencilla (busca «install docker and docker compose» para tu distribución). Usaremos Docker Compose en esta guía por su simplicidad.
Paso 1: Instalación y Configuración de Prometheus
Vamos a empezar por el recolector de datos. Crearemos un archivo docker-compose.yml para definir cómo queremos que se ejecuten Prometheus y, más adelante, Grafana.
Crea un directorio para tu configuración, por ejemplo, ~/monitoring:
«`bash
mkdir ~/monitoring
cd ~/monitoring
Ahora, crea el archivo `prometheus.yml`. Este archivo le dice a Prometheus qué métricas debe recolectar (*scrape*). De momento, solo le diremos que se monitorice a sí mismo y a un servicio que instalaremos en el siguiente paso (Node Exporter).
```yaml
# prometheus.yml
global:
scrape_interval: 15s # Cada cuánto recoger métricas
scrape_configs:
- job_name: 'prometheus' # Métricas del propio Prometheus
static_configs:
- targets: ['localhost:9090']
- job_name: 'node_exporter' # Métricas del servidor (lo instalaremos luego)
static_configs:
- targets: ['localhost:9100'] # Asume que node_exporter corre en el mismo hostAhora, crea el archivo docker-compose.yml en el mismo directorio (~/monitoring):
«`yaml
docker-compose.yml
version: ‘3.8’
services:
prometheus:
image: prom/prometheus:latest
container_name: prometheus
ports:
- «9090:9090» # Puerto para acceder a la interfaz web de Prometheus
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml # Monta nuestro archivo de configuración
- prometheus_data:/prometheus # Volumen para persistir los datos
command:
- ‘–config.file=/etc/prometheus/prometheus.yml’
- ‘–storage.tsdb.path=/prometheus’
- ‘–web.console.libraries=/usr/share/prometheus/console_libraries’
- ‘–web.console.templates=/usr/share/prometheus/consoles’
restart: unless-stopped
volumes:
prometheus_data: {} # Define el volumen
**Explicación rápida:**
* Usamos la imagen oficial de Prometheus.
* Mapeamos el puerto 9090 del contenedor al 9090 de tu servidor.
* Montamos nuestro `prometheus.yml` dentro del contenedor.
* Creamos un volumen `prometheus_data` para que las métricas no se pierdan si reinicias el contenedor.
* Le pasamos comandos para que use nuestro archivo de configuración y almacene los datos en el volumen.
Ahora, levanta Prometheus:
```bash
sudo docker-compose up -d prometheusSi todo va bien, deberías poder acceder a la interfaz web de Prometheus en tu navegador: http://<IP_DE_TU_SERVIDOR>:9090. Ve a la sección «Status» -> «Targets». Verás el target ‘prometheus’ como UP, pero ‘node_exporter’ estará DOWN (aún no lo hemos instalado).
Paso 2: Instalando el «Chivato» de Métricas – Node Exporter
Prometheus necesita de dónde sacar las métricas del sistema operativo (CPU, RAM, disco, red…). Para eso se usan los exporters. El más común para métricas de host Linux es node_exporter.
Vamos a añadirlo a nuestro docker-compose.yml:
«`yaml
docker-compose.yml (añade esto al archivo existente)
version: ‘3.8’
services:
prometheus:
… (definición anterior sin cambios) …
node_exporter:
image: prom/node-exporter:latest
container_name: node_exporter
ports:
- «9100:9100» # Puerto donde node_exporter expone las métricas
volumes:
- /proc:/host/proc:ro # Acceso de solo lectura al /proc del host
- /sys:/host/sys:ro # Acceso de solo lectura al /sys del host
- /:/rootfs:ro # Acceso de solo lectura al filesystem raíz del host
command:
- ‘–path.procfs=/host/proc’
- ‘–path.sysfs=/host/sys’
- ‘–path.rootfs=/rootfs’
- '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)' # Evita monitorizar puntos de montaje virtuales
restart: unless-stopped
volumes:
prometheus_data: {}
No necesitamos volumen para node_exporter, solo lee datos del host
**Importante:** Hemos añadido el servicio `node_exporter`.
* Usa la imagen oficial.
* Expone el puerto 9100.
* **Clave:** Monta directorios importantes del *host* (`/proc`, `/sys`, `/`) como solo lectura dentro del contenedor para que `node_exporter` pueda leer las métricas del sistema.
* Le pasamos comandos para que sepa dónde encontrar esos directorios montados.
Ahora, actualiza y levanta los servicios (Docker Compose es inteligente y solo recreará lo necesario):
```bash
sudo docker-compose up -dEspera unos segundos y vuelve a la interfaz de Prometheus (http://<IP_DE_TU_SERVIDOR>:9090), en «Status» -> «Targets». Ahora, el target node_exporter debería aparecer como UP. ¡Prometheus ya está recogiendo métricas de tu servidor! 🎉
Puedes incluso ver las métricas crudas que expone el node_exporter visitando http://<IP_DE_TU_SERVIDOR>:9100/metrics. Verás un montón de texto, que son los datos que Prometheus está guardando.
Paso 3: Instalación de Grafana
Ahora toca la parte visual. Añadimos Grafana a nuestro docker-compose.yml:
«`yaml
docker-compose.yml (añade esto al archivo existente)
version: ‘3.8’
services:
prometheus:
… (definición anterior sin cambios) …
node_exporter:
… (definición anterior sin cambios) …
grafana:
image: grafana/grafana-oss:latest # Usamos la versión Open Source
container_name: grafana
ports:
- «3000:3000» # Puerto estándar de Grafana
volumes:
- grafana_data:/var/lib/grafana # Volumen para persistir dashboards y configuraciones
restart: unless-stopped
volumes:
prometheus_data: {}
grafana_data: {} # Define el volumen para Grafana
**Explicación:**
* Usamos la imagen oficial de Grafana (versión Open Source).
* Mapeamos el puerto 3000.
* Creamos un volumen `grafana_data` para guardar la configuración, los dashboards, etc.
Levantamos todo de nuevo:
```bash
sudo docker-compose up -dAhora, accede a Grafana en tu navegador: http://<IP_DE_TU_SERVIDOR>:3000.
El usuario y contraseña por defecto suelen ser admin / admin. Te pedirá cambiar la contraseña la primera vez que entres.
Paso 4: Conectando Grafana con Prometheus
Una vez dentro de Grafana, necesitamos decirle dónde está nuestra fuente de datos (Prometheus).
- Ve al icono de engranaje (⚙️) en el menú lateral izquierdo -> «Data Sources».
- Haz clic en «Add data source».
- Busca y selecciona «Prometheus».
- En la configuración, lo más importante es el campo URL. Como Grafana y Prometheus están corriendo en la misma red Docker (gracias a Docker Compose), podemos usar el nombre del servicio definido en
docker-compose.ymly el puerto interno. Escribe:http://prometheus:9090. - Deja el resto de opciones por defecto por ahora.
- Haz clic en «Save & test». Debería aparecer un mensaje verde indicando «Data source is working».
¡Listo! Grafana ya sabe cómo hablar con Prometheus.
Paso 5: Creando tu Primer Dashboard (La Forma Fácil)
Podrías crear gráficos desde cero, pero para empezar, lo más rápido es importar un dashboard ya hecho por la comunidad, diseñado específicamente para node_exporter.
- En el menú lateral izquierdo, ve al icono de «+» -> «Import».
- Hay un campo que dice «Import via grafana.com dashboard ID or URL». Uno muy popular y completo para
node_exporteres el ID1860(Node Exporter Full). Escribe1860en ese campo y haz clic en «Load». - Grafana te mostrará los detalles del dashboard. Abajo, te pedirá seleccionar la fuente de datos Prometheus que acabamos de configurar. Selecciónala en el desplegable.
- Haz clic en «Import».
¡Tachán! ✨ Deberías tener ante ti un dashboard completo con un montón de gráficos mostrando el uso de CPU, memoria, disco, red y mucho más de tu servidor casero. Explóralo un poco para familiarizarte con la visualización datos Grafana.
Siguientes Pasos
Esto es solo el principio. A partir de aquí puedes:
- Explorar otros exporters: Hay exporters para casi todo (bases de datos, aplicaciones específicas, métricas de Docker…).
- Crear tus propios paneles: Intenta modificar el dashboard importado o crear uno nuevo desde cero seleccionando métricas específicas que te interesen.
- Configurar Alertas: Grafana permite definir alertas (ej: si la CPU supera el 90% durante 5 minutos) y notificarte por diferentes canales (email, Slack, Telegram…).
- Aprender PromQL: Es el lenguaje de consulta de Prometheus. Te permite hacer cálculos y selecciones muy potentes sobre tus métricas.
Conclusión
Montar un sistema básico para monitorizar servidor casero con Prometheus y Grafana no es tan complicado como podría parecer, especialmente usando Docker. Con esta guía Grafana Prometheus tienes una base sólida para empezar a entender qué pasa en tu máquina. Ver los datos de forma gráfica te da una perspectiva completamente nueva y te ayuda a detectar problemas o cuellos de botella que de otra forma pasarían desapercibidos.
Espero que esta guía te sea útil. Ahora te toca a ti explorar y adaptar la monitorización a tus necesidades específicas. ¿Te animas a probarlo? Si tienes alguna duda, déjala en los comentarios.
Deja una respuesta