RPi Network Monitor System

Sistema de monitorización de dispositivos Raspberry Pi en red que registra automáticamente las direcciones IP de cada RPi y las muestra en un dashboard web en tiempo real.

Copiar la carpeta ```RPI-CLIENT``en la raspberry

Descripción

Este proyecto permite centralizar el seguimiento de múltiples Raspberry Pi distribuidas en una red, manteniendo un registro actualizado de sus direcciones IP y mostrándolas en un dashboard web interactivo.

Arquitectura del Sistema

📁 rpi-monitor/
│
├── 📁 backend/                    # API FastAPI
│   ├── main.py                   # Puntos de entrada de la API
│   ├── database.py               # Conexión a MySQL
│   ├── models.py                 # Modelos de datos
│   ├── schemas.py                # Esquemas Pydantic
│   ├── requirements.txt          # Dependencias Python
│   └── Dockerfile                # Contenedor para API
│
├── 📁 frontend/                   # Dashboard Streamlit
│   ├── app.py                    # Aplicación web principal
│   ├── requirements.txt          # Dependencias Python
│   └── Dockerfile                # Contenedor para frontend
│
├── 📁 docker/                     # Configuración Docker
│   └── mysql-init/
│       └── init.sql              # Inicialización de BD
│
├── 📁 rpi-client/                 # Cliente para Raspberry Pi
│   ├── Dockerfile                # Contenedor para RPi
│   ├── docker-compose.yml        # Orquestación del cliente
│   ├── requirements.txt          # Dependencias Python
│   └── rpi_client.py             # Script de envío de datos
│
├── docker-compose.yml            # Orquestación principal
└── README.md                     # Este archivo

Componentes del Sistema

1. Backend (FastAPI + MySQL)

Puerto: 8000

• API REST que recibe datos POST de las Raspberry Pi
• Base de datos MySQL almacena: ID, Usuario, IP, Timestamp
• Endpoints:
  • POST /rpi-data/ - Recibir datos de RPi
  • GET /rpi-data/ - Obtener todos los registros
  • GET /rpi-data/{usuario} - Filtrar por usuario
  • GET /health - Estado del servicio

2. Frontend (Streamlit Dashboard)

Puerto: 8501

Dashboard web que muestra:

• Tabla con todos los dispositivos
• Métricas: Total RPi, Usuarios únicos, IPs únicas
• Formulario para añadir manualmente
• Datos ordenados por fecha (más nuevos primero)

3. Cliente Raspberry Pi

Script Python que se ejecuta en cada RPi:

• Detecta IP local con hostname -I
• Envía datos al servidor cada 5 minutos
• Reintentos automáticos en caso de error
• Identificación única por dispositivo

Flujo de Datos

Raspberry Pi → API FastAPI → MySQL → Dashboard Streamlit
     ↓             ↓           ↓            ↓
 Detecta IP    Recibe POST  Almacena    Muestra en
    cada         datos      en BD       tiempo real
  5 minutos

Despliegue con Docker

Servidor Principal

# 1. Clonar proyecto
git clone <repo>
cd rpi-monitor

# 2. Levantar todos los servicios
docker-compose up --build -d

# 3. Acceder a:
# Dashboard: http://localhost:8501
# API Docs: http://localhost:8000/docs
# MySQL: localhost:8080 (root/password)

Raspberry Pi (Cliente)

# 1. En RPi, configurar IP del servidor
cd ~/rpi-client
nano docker-compose.yml  # Cambiar SERVER_IP

# 2. Ejecutar cliente
sudo docker-compose up --build -d

# 3. Ver logs
docker logs -f rpi_monitor_client

Configuración

Variables de Entorno - Servidor

DB_HOST=mysql
DB_NAME=rpi_db
DB_USER=root
DB_PASSWORD=password

Variables de Entorno - Cliente RPi

SERVER_IP=192.168.1.100    # IP del servidor
SERVER_PORT=8000           # Puerto de la API
RPI_NAME=rpi_oficina_1     # Nombre único del dispositivo
INTERVAL_SECONDS=300       # Intervalo de envío (5 min)

Estructura de la Base de Datos

CREATE TABLE rpi_data (
    id INT AUTO_INCREMENT PRIMARY KEY,
    usuario VARCHAR(100) NOT NULL,
    ip VARCHAR(15) NOT NULL,
    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
    UNIQUE KEY unique_ip_per_user (usuario, ip)
);

Campos:

• id: Identificador único autoincremental
• usuario: Nombre del dispositivo RPi
• ip: Dirección IP actual
• timestamp: Fecha y hora de actualización

Uso y Operación

Agregar RPi manualmente

1. Ir a http://localhost:8501
2. En sidebar: Ingresar Usuario e IP
3. Click en "Registrar RPi"

Verificar estado del sistema

# Ver contenedores
docker-compose ps

# Ver logs del backend
docker-compose logs backend

# Probar API manualmente
curl http://localhost:8000/rpi-data/

Monitorear Raspberry Pi

# En cada RPi, ver logs del cliente
docker logs rpi_monitor_client

# Forzar envío manual
docker exec rpi_monitor_client python rpi_client.py

Troubleshooting

Problema: API no responde

# Verificar que el backend esté corriendo
docker-compose ps | grep backend

# Revisar logs
docker-compose logs backend --tail=50

# Probar conexión a MySQL desde backend
docker exec rpi_backend curl http://localhost:8000/health

Problema: RPi no envía datos

# En RPi, verificar conexión al servidor
docker exec rpi_monitor_client ping <SERVER_IP>

# Probar envío manual
docker exec rpi_monitor_client python -c "import requests; r=requests.get('http://<SERVER_IP>:8000/'); print(r.status_code)"

Problema: Dashboard no muestra datos

• Verificar console del navegador (F12)
• Revisar logs del frontend: docker-compose logs frontend
• Verificar CORS en backend

Características

• Monitorización automática - Las RPi envían datos cada 5 min
• Dashboard en tiempo real - Actualización automática
• Base de datos persistente - Histórico de cambios de IP
• Identificación única - Cada RPi tiene nombre único
• Dockerizado - Fácil despliegue y escalabilidad
• API REST documentada - Swagger en /docs
• Interfaz web intuitiva - Streamlit responsive

Próximas Mejoras

• Autenticación - Login para dashboard
• Alertas - Notificaciones cuando IP cambia
• Histórico - Gráficos de cambios de IP
• Backup automático - De base de datos

Mantenimiento

Backup de base de datos

docker exec rpi_mysql mysqldump -u root -ppassword rpi_db > backup_$(date +%Y%m%d).sql

Actualizar sistema

# Reconstruir imágenes
docker-compose build --no-cache

# Actualizar contenedores
docker-compose up -d --force-recreate

Limpiar datos antiguos

-- Eliminar registros con más de 30 días
DELETE FROM rpi_data WHERE timestamp < NOW() - INTERVAL 30 DAY;

Comandos útiles

# Reiniciar servicio específico
docker-compose restart backend

# Ver uso de recursos
docker stats

# Acceder a MySQL
docker exec -it rpi_mysql mysql -u root -p rpi_db

# Borrar todo y empezar fresco
docker-compose down -v
docker-compose up --build -d