Crea tu Propio Panel de Monitoreo de Red con Raspberry Pi y Grafana

🚀 Introducción al Monitoreo de Red con Raspberry Pi

¿Alguna vez te has preguntado qué está pasando exactamente en tu red doméstica o de oficina? ¿Cuántos datos se están consumiendo, qué dispositivos están conectados y si tu conexión a Internet es estable? En este tutorial completo, vamos a aprovechar la versatilidad de una Raspberry Pi para construir un sistema de monitoreo de red profesional y visualmente impresionante utilizando herramientas estándar de la industria: Prometheus para la recolección de métricas y Grafana para la visualización de datos.

Al finalizar este tutorial, serás capaz de:

• Recopilar métricas de red en tiempo real (latencia, uso de ancho de banda, dispositivos activos).
• Almacenar y procesar datos históricos de rendimiento.
• Diseñar paneles interactivos personalizados en Grafana.
• Configurar alertas automatizadas para detectar anomalías.

🛠️ Materiales y Requisitos Previos

Para llevar a cabo este proyecto con éxito, necesitarás reunir los siguientes componentes de hardware y software:

Nivel: Intermedio Tiempo estimado: 2 horas

📋 Paso 1: Preparación del Sistema y Actualización

Antes de instalar cualquier software en nuestra Raspberry Pi, es fundamental asegurarnos de que el sistema operativo esté completamente actualizado. Conéctate a tu Raspberry Pi a través de SSH y ejecuta los siguientes comandos:

sudo apt update
sudo apt upgrade -y
sudo apt install -y curl apt-transport-https software-properties-common

Es recomendable también establecer una dirección IP estática en tu Raspberry Pi para asegurarte de que el panel de Grafana y las métricas de Prometheus estén siempre accesibles en la misma dirección dentro de tu red local.

⚙️ Paso 2: Instalación y Configuración de Prometheus

Prometheus es un sistema de monitoreo de código abierto diseñado para registrar métricas en bases de datos de series temporales. Vamos a instalarlo en nuestra Raspberry Pi.

Creación de usuario y directorios

Por razones de seguridad, es una buena práctica ejecutar Prometheus bajo su propio usuario del sistema:

sudo groupadd --system prometheus
sudo useradd -s /sbin/nologin --system -g prometheus prometheus
sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus

Descarga de Prometheus para arquitectura ARM

Asegúrate de descargar la versión correcta para la arquitectura de tu Raspberry Pi (generalmente linux-arm64 para Raspberry Pi OS de 64 bits):

curl -LO https://github.com/prometheus/prometheus/releases/download/v2.45.0/prometheus-2.45.0.linux-arm64.tar.gz
tar xvf prometheus-2.45.0.linux-arm64.tar.gz
cd prometheus-2.45.0.linux-arm64

Mueve los binarios y archivos de configuración a sus respectivas ubicaciones:

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

sudo cp -r consoles /etc/prometheus/
sudo cp -r console_libraries /etc/prometheus/
sudo cp prometheus.yml /etc/prometheus/prometheus.yml

sudo chown -R prometheus:prometheus /etc/prometheus/
sudo chown -R prometheus:prometheus /var/lib/prometheus

Configuración del servicio systemd para Prometheus

Crea un archivo de servicio para que Prometheus se ejecute automáticamente al iniciar el sistema:

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

Pega el siguiente contenido en el archivo:

[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/ \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --web.console.templates=/etc/prometheus/consoles

[Install]
WantedBy=multi-user.target

Guarda el archivo y recarga systemd para iniciar Prometheus:

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus

Puedes verificar que Prometheus está funcionando correctamente abriendo tu navegador web e ingresando a http://<IP_DE_TU_RASPBERRY_PI>:9090.

📊 Paso 3: Instalación de Grafana en la Raspberry Pi

Ahora que tenemos el recolector de métricas funcionando, necesitamos una interfaz visual potente. Grafana es la herramienta perfecta para esto.

Añadir el repositorio oficial de Grafana

Ejecuta los siguientes comandos para agregar la clave GPG y el repositorio:

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 Grafana

Actualiza la lista de paquetes e instala Grafana:

sudo apt update
sudo apt install -y grafana

Inicia y habilita el servicio de Grafana:

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

Ya puedes acceder a Grafana desde tu navegador web escribiendo http://<IP_DE_TU_RASPBERRY_PI>:3000. Las credenciales predeterminadas tanto para el usuario como para la contraseña son admin.

🔌 Paso 4: Configuración de Exportadores de Red

Para que Prometheus pueda recopilar datos de red, necesitamos utilizar exportadores. Instalaremos el Node Exporter para métricas del sistema de la Raspberry Pi y configuraremos un script personalizado en Python para monitorear la latencia de Internet.

Instalación de Node Exporter

Descarga la versión para ARM de Node Exporter:

curl -LO https://github.com/prometheus/node_exporter/releases/download/v1.6.0/node_exporter-1.6.0.linux-arm64.tar.gz
tar xvf node_exporter-1.6.0.linux-arm64.tar.gz
sudo cp node_exporter-1.6.0.linux-arm64/node_exporter /usr/local/bin/

Crea un usuario para Node Exporter:

sudo useradd -s /sbin/nologin --system node_exporter

Crea el archivo de servicio systemd:

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

Añade la siguiente configuración:

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

Inicia el servicio:

sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter

Conectando Prometheus con Node Exporter

Edita el archivo de configuración de Prometheus para incluir Node Exporter como objetivo (target):

sudo nano /etc/prometheus/prometheus.yml

Añade la siguiente sección al final del archivo scrape_configs:

  - job_name: 'raspberry_pi_node'
    static_configs:
      - targets: ['localhost:9100']

Reinicia Prometheus para aplicar los cambios:

sudo systemctl restart prometheus

🎨 Paso 5: Creación del Panel de Control en Grafana

Una vez que Prometheus está recolectando datos de Node Exporter, es momento de diseñar nuestro panel visual en Grafana.

1. Inicia sesión en Grafana (http://<IP_DE_TU_RASPBERRY_PI>:3000).
2. En el menú lateral izquierdo, haz clic en Connections y luego en Data sources.
3. Selecciona Add data source y elige Prometheus.
4. En el campo de URL, introduce http://localhost:9090 y haz clic en Save & test al final de la página.
5. Ve al menú lateral, selecciona Dashboards y haz clic en Create dashboard.
6. Añade una nueva visualización (Add visualization), selecciona tu fuente de datos Prometheus y utiliza métricas como node_memory_Active_bytes o node_cpu_seconds_total para crear gráficos de uso de CPU y memoria de tu Raspberry Pi.

🧪 Paso 6: Monitoreo de Latencia y Conectividad con Python

Para llevar nuestro monitoreo de red al siguiente nivel, vamos a crear un script ligero en Python que mida la latencia hacia servidores externos (como 8.8.8.8) y exponga estas métricas para que Prometheus las lea.

Crea un archivo llamado network_monitor.py:

import time
import subprocess
from prometheus_client import start_http_server, Gauge

# Definir métricas personalizadas
PING_LATENCY = Gauge('net_ping_latency_seconds', 'Latencia de red en segundos', ['target'])

def measure_ping(target):
    try:
        output = subprocess.run(['ping', '-c', '1', target], capture_output=True, text=True, timeout=2)
        if output.returncode == 0:
            for line in output.stdout.split('\n'):
                if 'time=' in line:
                    time_str = line.split('time=')[1].split(' ')[0]
                    return float(time_str) / 1000.0
    except Exception as e:
        print(f"Error al hacer ping a {target}: {e}")
    return None

if __name__ == '__main__':
    # Iniciar servidor HTTP en el puerto 8000 para Prometheus
    start_http_server(8000)
    print("Exportador de red personalizado ejecutándose en el puerto 8000...")
    
    targets = ['8.8.8.8', '1.1.1.1']
    
    while True:
        for target in targets:
            latency = measure_ping(target)
            if latency is not None:
                PING_LATENCY.labels(target=target).set(latency)
        time.sleep(15)

Puedes ejecutar este script en segundo plano utilizando screen o configurándolo como un servicio systemd dedicado.

🔍 Preguntas Frecuentes (FAQ)

🎯 Conclusión

¡Felicitaciones! Has construido con éxito tu propio sistema centralizado de monitoreo de red utilizando una Raspberry Pi, Prometheus y Grafana. Ahora tienes una visibilidad completa del rendimiento de tu infraestructura de red y de los recursos de tu dispositivo.