NetMonitor

Versión actual: 2026-11-03 · una sola imagen de aplicación (ghcr.io/alexmysterio/netmonitor:latest) más PostgreSQL y Redis.

Monitorización de red visual, self-hosted y open source.

NetMonitor es una alternativa web a los clásicos paneles de monitorización de red: mapas jerárquicos en tiempo real, polling multiprotocolo, alertas con supresión por dependencias, traps SNMP, informes y gestión de RouterOS. Está pensado para redes pequeñas y medianas que necesitan una visión clara sin depender de servicios externos.

Interfaz en español. El stack se ejecuta íntegramente en Docker Compose.

Características

Mapas visuales jerárquicos: mapas y submapas, zonas, etiquetas dinámicas centradas, formas que se adaptan al texto, enlaces con tráfico RX/TX, modo NOC y edición arrastrando nodos. El estado ACK se propaga a submapas y al listado de mapas.
Descubrimiento de red: uno o varios rangos CIDR, ICMP + SNMP + TCP, hasta 65.536 direcciones por barrido; crea la sonda según el método de detección, reutiliza equipos existentes y permite añadirlos al mapa.
Polling multiprotocolo: ICMP, SNMP v1/v2c/v3, TCP, HTTP/HTTPS, DNS y sondas lógicas.
Acciones masivas: selecciona varios dispositivos para asignar perfil SNMP, añadir/quitar etiquetas, activar/pausar monitorización, reconocer, sondear o eliminar.
Inventario SNMP: sistema, interfaces, direcciones IP, ARP, rutas, LLDP/CDP/MNDP, FDB, Q-BRIDGE, STP y topología L2.
Alertas: reglas por dispositivo/mapa/etiqueta, retardos, reintentos, ventanas de mantenimiento, festivos, antitormenta, dependencias Parents y reconocimiento (ACK).
Notificaciones: Telegram interactivo, email, webhooks, Slack, Discord, Teams, ntfy, Syslog, PagerDuty, Opsgenie y SMS.
SNMP Traps y Syslog: recepción, decodificación con MIBs, reglas y feed de eventos.
Correlación de causa raíz: supresión de alertas derivadas de una caída padre o de un fallo de topología L2.
RouterOS: inventario, plantillas, despliegues con aprobación obligatoria, dry-run y snapshots antes/después.
Accesos por equipo: credenciales cifradas por servicio (Winbox, Web/HTTP y SSH), con respaldo de la credencial RouterOS. Abre Winbox con el puente local, lanza SSH/Web y permite copiar usuario o contraseña como fuente de verdad.
Informes: PDF/CSV, SLA por cliente, disponibilidad por interfaz, comparativa mensual, programación y exportación local/S3.
Importación de The Dude: mapas, submapas, dispositivos, enlaces y elementos decorativos desde la base SQLite (dude.db) o XML, incluidas las bases modernas con objetos Nova en la tabla objs. Los mapas generales que solo contienen submapas reconstruyen la jerarquía padre/hijo, y los enlaces de The Dude se recrean como enlaces reales entre equipos y submapas (no como etiquetas de texto). También importa credenciales RouterOS cifradas y perfiles SNMP de Dude, que se asignan automáticamente sin sobrescribir por defecto las credenciales ni los perfiles ya asignados; los enlaces con equipo e interfaz maestra se convierten en enlaces monitorizados por SNMP si el equipo maestro tiene un perfil SNMP (si no, quedan como enlaces simples y la importación añade un aviso). Los perfiles SNMPv3 pueden requerir completar los secretos a mano. Antes de aplicar se pueden asignar perfiles SNMP, sondas y tipo de dispositivo por equipo o a todos.
Seguridad: RBAC por mapa/grupo/dispositivo, API keys, auditoría, cifrado AES-256-GCM de secretos, JWT revocable y sesiones con refresco de permisos.
Agentes remotos: sondeo desde otras redes, cuotas, reconexión y mTLS opcional.
Alta disponibilidad: elección de líder por advisory lock de PostgreSQL y fanout de WebSocket con Redis.

Stack

Componente	Tecnología
Backend, poller y receptores	Go
Frontend	React + TypeScript + Vite
Base de datos	PostgreSQL 16 + TimescaleDB
Estado en vivo y Pub/Sub	Redis 7
Proxy y estáticos	nginx
TLS opcional	Caddy
Backups	`pg_dump` + sidecar de verificación

Inicio rápido

Requisitos:

Docker Engine 24+ con Compose v2 (Docker Desktop en Windows/macOS).
2 GB de RAM recomendados.
Puertos libres: 8080 (web). Los puertos 162/udp y 514/udp solo son necesarios si activas traps y Syslog con el compose avanzado; en Linux los puertos menores de 1024 requieren privilegios.

git clone https://github.com/Alexmysterio/NetMonitor.git
cd NetMonitor
cp .env.example .env

Edita .env y define valores aleatorios para POSTGRES_PASSWORD, JWT_SECRET, ENCRYPTION_KEY y ADMIN_PASSWORD. Más abajo tienes un .env de ejemplo listo para copiar.

Puedes generarlos con OpenSSL:

openssl rand -hex 32

O en PowerShell:

$bytes = New-Object byte[] 32
[Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
($bytes | ForEach-Object { $_.ToString('x2') }) -join ''

Arranca el stack:

docker compose up -d
docker compose ps

Abre http://localhost:8080 y entra con el usuario admin y la contraseña de ADMIN_PASSWORD.

ADMIN_PASSWORD se usa únicamente al crear la base de datos. Si el stack ya tenía usuarios, cambia la contraseña desde Usuarios o actualiza el hash en la base de datos.

El stack rechaza los valores de ejemplo en producción. Para un laboratorio desechable puedes usar ALLOW_INSECURE_DEFAULTS=true, pero nunca en un entorno accesible. SEED_DEMO=true crea una topología de demostración solo si la base de datos está vacía; ponlo a false en producción.

Usar la imagen publicada en GHCR

La imagen se publica automáticamente en GitHub Container Registry desde la rama main:

ghcr.io/alexmysterio/netmonitor:latest — API, poller, frontend, nginx y binario del agente opcional en una sola imagen.

La imagen se compila para linux/amd64 y linux/arm64.

El compose básico levanta PostgreSQL, Redis y una única imagen de NetMonitor, sin compilar nada. La aplicación (API, poller, frontend y nginx) corre en un solo contenedor; PostgreSQL y Redis se mantienen como servicios oficiales de infraestructura. El contenedor netmonitor solo recibe las variables imprescindibles; el resto se activa con el compose avanzado. Puedes copiar el compose tal cual en un archivo docker-compose.yml.

Archivo `.env` de ejemplo

Todas las variables que usa el compose están definidas aquí; no hay valores por defecto ocultos. Cambia los cuatro valores CAMBIA_ESTO y ajusta lo que necesites. POSTGRES_DB y POSTGRES_USER puedes dejarlos así:

POSTGRES_DB=netmonitor
POSTGRES_USER=netmonitor
POSTGRES_PASSWORD=CAMBIA_ESTO

JWT_SECRET=CAMBIA_ESTO
ENCRYPTION_KEY=CAMBIA_ESTO
ADMIN_PASSWORD=CAMBIA_ESTO

HTTP_BIND=127.0.0.1
HTTP_PORT=8080
SEED_DEMO=true
TZ=Europe/Madrid
PUBLIC_URL=http://localhost:8080

# Rutas hacia redes privadas (RFC1918) desde la interfaz LAN del contenedor.
# Deja el gateway vacío para mantener el enrutado por defecto de Docker.
PRIVATE_ROUTE_GATEWAY=
PRIVATE_ROUTE_DEV=
PRIVATE_ROUTES=10.0.0.0/8,172.16.0.0/12,192.168.0.0/16

SNMP_TRAP_PORT=162
SYSLOG_PORT=514
AGENT_MTLS_PORT=8443
POLLER_WORKERS=64
POLL_INTERVAL_SEC=30
ALERT_MAX_PER_MINUTE=120
CORE_LEADER_ELECTION=false

BACKUP_INTERVAL_HOURS=24
BACKUP_RETENTION_DAYS=14
BACKUP_VERIFY=true

DOMAIN=localhost
TLS_EMAIL=internal

AGENT_TOKEN=
AGENT_CORE_WS_URL=ws://netmonitor:8080/api/v1/agent/ws
AGENT_INSECURE_TLS=false
AGENT_TLS_ENABLED=false
AGENT_TLS_SERVER_NAME=netmonitor
AGENT_TLS_CERT=
AGENT_TLS_KEY=
AGENT_TLS_CA=
AGENT_UPDATE_PUBLIC_KEY=

Genera cada secreto con openssl rand -hex 32 o con el comando de PowerShell de más arriba. El archivo completo con opciones adicionales está en .env.example.

Los datos persistentes quedan en ./data/postgres, ./data/redis, ./data/backups, ./map-backgrounds, ./notification-sounds y ./reports; no se usan volúmenes gestionados por Docker.

Si vienes de una versión anterior con volúmenes Docker, copia networkmonitor_pgdata, networkmonitor_redisdata y networkmonitor_backups a ./data antes de arrancar y no borres los volúmenes antiguos hasta comprobar la migración.

Después guarda este docker-compose.yml:

services:
  netmonitor-db:
    image: timescale/timescaledb:latest-pg16
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB:?Set POSTGRES_DB in .env}
      POSTGRES_USER: ${POSTGRES_USER:?Set POSTGRES_USER in .env}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
      TIMESCALEDB_TELEMETRY: "off"
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    networks:
      - netmonitor-net
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
      interval: 5s
      timeout: 5s
      retries: 20

  netmonitor-redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: ["redis-server", "--appendonly", "yes", "--maxmemory", "512mb", "--maxmemory-policy", "allkeys-lru"]
    volumes:
      - ./data/redis:/data
    networks:
      - netmonitor-net
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 20

  netmonitor:
    image: ghcr.io/alexmysterio/netmonitor:latest
    restart: unless-stopped
    depends_on:
      netmonitor-db:
        condition: service_healthy
      netmonitor-redis:
        condition: service_healthy
    cap_add:
      - NET_RAW
      - NET_ADMIN
    environment:
      APP_ENV: production
      DATABASE_URL: postgres://${POSTGRES_USER:?Set POSTGRES_USER in .env}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@netmonitor-db:5432/${POSTGRES_DB:?Set POSTGRES_DB in .env}?sslmode=disable
      REDIS_URL: redis://netmonitor-redis:6379/0
      JWT_SECRET: ${JWT_SECRET:?Set JWT_SECRET in .env}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY:?Set ENCRYPTION_KEY in .env}
      ADMIN_PASSWORD: ${ADMIN_PASSWORD:?Set ADMIN_PASSWORD in .env}
      SEED_DEMO: ${SEED_DEMO:?Set SEED_DEMO in .env}
      PRIVATE_ROUTE_GATEWAY: ${PRIVATE_ROUTE_GATEWAY?Set PRIVATE_ROUTE_GATEWAY in .env (empty disables)}
      PRIVATE_ROUTE_DEV: ${PRIVATE_ROUTE_DEV?Set PRIVATE_ROUTE_DEV in .env (empty autodetects)}
      PRIVATE_ROUTES: ${PRIVATE_ROUTES?Set PRIVATE_ROUTES in .env}
    ports:
      - "${HTTP_BIND:?Set HTTP_BIND in .env}:${HTTP_PORT:?Set HTTP_PORT in .env}:80"
    volumes:
      - ./map-backgrounds:/app/uploads/map-backgrounds
      - ./notification-sounds:/app/uploads/notification-sounds
      - ./reports:/app/reports
    networks:
      - netmonitor-net
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://127.0.0.1/api/v1/health"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 15s

networks:
  netmonitor-net:
    driver: bridge

Arranca:

docker compose up -d

Si guardas el archivo con otro nombre, usa docker compose -f <archivo> up -d.

El mismo archivo está versionado en docker-compose.yml.

Para descargar la imagen principal por separado:

docker pull ghcr.io/alexmysterio/netmonitor:latest

La imagen netmonitor:latest está publicada como pública: no necesitas iniciar sesión en GHCR para descargarla.

Rutas a redes privadas (opcional)

Por defecto el contenedor usa la red bridge de Docker. Si el host ya enruta a la LAN/VPN, no hay que configurar nada: el contenedor sale por el host. Deja PRIVATE_ROUTE_GATEWAY vacío.

Si el contenedor tiene una interfaz propia en la LAN/VPN (macvlan/ipvlan, por ejemplo una VLAN de Unraid), configura el gateway de esa red para que el tráfico privado salga por ella:

PRIVATE_ROUTE_GATEWAY=<gateway-de-la-VLAN>
PRIVATE_ROUTE_DEV=
PRIVATE_ROUTES=10.0.0.0/8,172.16.0.0/12,192.168.0.0/16

PRIVATE_ROUTE_GATEWAY: gateway de la VLAN/LAN. Vacío = rutas desactivadas y todo sale por Docker.
PRIVATE_ROUTE_DEV: interfaz (eth0, eth1...). Vacío = se detecta por la ruta al gateway.
PRIVATE_ROUTES: redes que salen por ese gateway. Para enviar también Internet: 0.0.0.0/0.
NET_ADMIN ya está en docker-compose.yml; las rutas de PostgreSQL/Redis (172.x/16) son más específicas y no se rompen.

Unraid / VLAN: si ya has creado la red macvlan/ipvlan y el contenedor la tiene adjunta, no uses docker-compose.lan.yml: solo configura las tres variables y recrea el contenedor (en la UI de Unraid, añádelas y pulsa Aplicar; con Compose Manager, edita el .env y ejecuta docker compose up -d). Comprueba el driver y el parent con:

docker network inspect <red> --format '{{.Driver}} {{json .Options}}'

Si el gateway responde desde el contenedor, la VLAN está bien. Con macvlan el host de Unraid no puede hacer ping al contenedor; pruébalo desde otro equipo de la LAN. Si no responde, revisa que el parent sea la interfaz que lleva la VLAN y que el switch permita esa VLAN.

Si la red aún no está en tu compose, usa el overlay docker-compose.lan.yml:

# LAN_NETWORK=<nombre-de-la-red> en .env
docker compose -f docker-compose.yml -f docker-compose.lan.yml up -d

No uses un bridge de Docker con la misma subred que la LAN real: Docker lo aísla y el contenedor no verá los equipos reales, aunque el host sí.

Comprobar:

docker compose exec netmonitor ip route get <IP_PRIVADA>
docker compose exec netmonitor ping -c 3 <IP_PRIVADA>

Debe salir via <gateway> dev <interfaz> y, si usas VLAN, src <IP-del-contenedor>. Si sale por el gateway de Docker y el ping funciona, el host está enrutando; si quieres forzar la VLAN, revisa PRIVATE_ROUTE_GATEWAY.

El compose básico no incluye backups, agente remoto, traps/Syslog publicados, iconos personalizados ni TLS/mTLS. Esas piezas están en archivos opcionales para que cada usuario elija. El overlay principal es docker-compose.advanced.yml:

# Añade traps, Syslog, certificados e iconos personalizados
docker compose -f docker-compose.yml -f docker-compose.advanced.yml up -d

# Añade además el sidecar de backups
docker compose -f docker-compose.yml -f docker-compose.advanced.yml --profile backup up -d

# Añade además un agente remoto
docker compose -f docker-compose.yml -f docker-compose.advanced.yml --profile agent up -d

# HTTPS con Caddy
docker compose -f docker-compose.yml -f docker-compose.advanced.yml -f docker-compose.tls.yml --profile tls up -d

Configuración

Toda la configuración se pasa por variables de entorno. Las principales:

Variable	Descripción	Valor por defecto
`HTTP_BIND`	Interfaz donde se publica la web	`127.0.0.1`
`HTTP_PORT`	Puerto HTTP publicado	`8080`
`PRIVATE_ROUTE_GATEWAY`	Gateway LAN/VPN para el tráfico RFC1918; vacío lo desactiva	Vacío
`PRIVATE_ROUTE_DEV`	Interfaz del contenedor; vacío la autodetecta	Vacío
`PRIVATE_ROUTES`	CIDR privados que usan ese gateway	`10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`
`LAN_NETWORK`	Red externa para el overlay `docker-compose.lan.yml`; sin IP fija	Vacío
`POSTGRES_PASSWORD`	Contraseña de PostgreSQL	Cambiar obligatoriamente
`JWT_SECRET`	Firma de sesiones JWT	Cambiar obligatoriamente
`ENCRYPTION_KEY`	Clave de cifrado en reposo	Cambiar obligatoriamente
`ADMIN_USERNAME`	Usuario inicial	`admin`
`ADMIN_PASSWORD`	Contraseña inicial	Cambiar obligatoriamente
`SEED_DEMO`	Crea datos de demostración al inicio	`true`
`PUBLIC_URL`	URL pública para botones de Telegram (avanzado)	`http://localhost:8080`
`SNMP_TRAP_PORT`	Puerto UDP de traps en el host (avanzado)	`162`
`SYSLOG_PORT`	Puerto UDP de Syslog en el host (avanzado)	`514`
`BACKUP_INTERVAL_HOURS`	Frecuencia de backup (avanzado)	`24`
`BACKUP_RETENTION_DAYS`	Retención de backups (avanzado)	`14`
`CORE_LEADER_ELECTION`	Activa elección de líder para HA (avanzado)	`false`

El resto de opciones está documentado en .env.example. Las variables de ajuste TZ, PUBLIC_URL, POLLER_WORKERS, POLL_INTERVAL_SEC, ALERT_MAX_PER_MINUTE y CORE_LEADER_ELECTION se aplican con docker-compose.advanced.yml.

Operación

# Estado y logs
docker compose ps
docker compose logs -f netmonitor

# Salud de la API
curl http://localhost:8080/api/v1/health

# Backup manual (requiere el overlay avanzado y el perfil backup)
docker compose -f docker-compose.yml -f docker-compose.advanced.yml --profile backup run --rm netmonitor-backup once

# Actualizar imágenes
docker compose pull
docker compose up -d

Los backups se guardan en ./data/backups (/backups dentro del contenedor) y se verifica su restauración en una base temporal.

Rotación de `ENCRYPTION_KEY`

La rotación vuelve a cifrar credenciales SNMP, credenciales RouterOS, canales de notificación y almacenamiento de informes. Haz un backup antes y ejecuta el rotador con el contenedor parado:

docker compose stop netmonitor

docker compose run --rm --entrypoint /app/netmonitor-keyrotate \
  -e OLD_ENCRYPTION_KEY='clave_actual' \
  -e NEW_ENCRYPTION_KEY='clave_nueva' \
  netmonitor

Actualiza ENCRYPTION_KEY en .env y vuelve a arrancar:

docker compose up -d netmonitor

Si algún secreto no se puede descifrar con la clave anterior, el proceso aborta sin dejar la base de datos a medias.

HTTPS

Para un dominio público con certificado automático de Caddy:

$env:DOMAIN="monitor.example.com"
$env:TLS_EMAIL="ops@example.com"
docker compose -f docker-compose.yml -f docker-compose.tls.yml --profile tls up -d

Para un certificado local autofirmado usa TLS_EMAIL=internal y abre https://localhost.

Agentes remotos

El agente remoto reutiliza la misma imagen netmonitor: el overlay avanzado cambia el entrypoint a /app/netmonitor-agent.

Crea un agente en Ajustes → Agentes, copia el token y arranca el perfil:

$env:AGENT_TOKEN="tu_token"
docker compose -f docker-compose.yml -f docker-compose.advanced.yml --profile agent up -d

Para mTLS, genera los certificados con:

cd backend
go run ./cmd/certgen -out ..\deploy\certs -hosts netmonitor,localhost -ips 127.0.0.1

y activa AGENT_TLS_ENABLED=true en .env. El puerto 8443 exige certificado de cliente firmado por la CA. Si usas mTLS, configura también AGENT_CORE_WS_URL=wss://netmonitor:8443/api/v1/agent/ws y descomenta AGENT_TLS_CERT, AGENT_TLS_KEY y AGENT_TLS_CA.

Desarrollo

Requiere Go 1.23+ y Node.js 20+.

# Imagen all-in-one
docker build -f deploy/allinone/Dockerfile -t netmonitor:dev .

# Backend
cd backend
go build ./...
go vet ./...
go test ./...

# Frontend
cd ../frontend
npm ci
npm run build

La especificación OpenAPI está disponible en /api/v1/openapi.json con el stack arrancado.

Accesos y credenciales

Cada equipo tiene una sección Accesos con credenciales independientes para Winbox, Web/HTTP y SSH. Si un servicio no tiene credencial propia, se reutiliza la credencial RouterOS asignada al equipo. Las contraseñas se cifran en reposo y no se devuelven en los listados.

Winbox: abre Winbox con el usuario y la contraseña guardados.
SSH: el puente abre PuTTY con usuario y contraseña si está instalado; si no, abre OpenSSH y copia la contraseña al portapapeles.
Web: abre HTTP/HTTPS y copia la contraseña al portapapeles. Los navegadores no permiten rellenar automáticamente formularios como WebFig por seguridad; para autollenado real haría falta una extensión o un userscript.
Copiar usuario/contraseña: botones explícitos para usar la credencial en cualquier cliente.
La API RouterOS sigue usando la credencial RouterOS de la sección RouterOS.

Winbox con credenciales

En Accesos → Winbox puedes abrir Winbox con el usuario y la contraseña del equipo. El navegador solo recibe un ticket de un solo uso (90 segundos); el puente local canjea el ticket contra NetMonitor y ejecuta winbox.exe con las credenciales.

En el equipo Windows donde tengas instalado Winbox, pulsa Instalar o actualizar puente y ejecuta el .vbs una vez. El instalador descarga un helper en PowerShell y un lanzador, se instala en HKCU (no requiere administrador), arranca en segundo plano y no abre ventanas de consola. No descarga ningún .exe.
Vuelve a NetMonitor y pulsa Abrir Winbox o SSH. El navegador habla con el puente por 127.0.0.1, así que no pide permiso para abrir un protocolo externo en cada clic.
Si cambias de dominio o de URL de NetMonitor, vuelve a instalar el puente para actualizar el servidor incrustado.

La primera vez, Windows puede pedir confirmación para ejecutar el instalador .vbs; es solo durante la instalación. Si el puente no está arrancado, NetMonitor ofrece el protocolo como alternativa manual y avisa de que el navegador pedirá permiso.

El puente solo se instala en el puesto cliente; no se ejecuta nada en el servidor. Escucha únicamente en 127.0.0.1:47821, no abre puertos a la red y no muestra ventanas de consola. Usa HTTPS si el panel es accesible desde fuera de la red local, porque el puente recibe la credencial RouterOS en esa conexión. Si Windows bloquea el .vbs descargado, desbloquéalo en las propiedades del archivo. Si Winbox o SSH no se abren, revisa el diagnóstico en %LOCALAPPDATA%\NetMonitor\bridge.log.

Importación desde The Dude

La importación acepta la base SQLite de The Dude (dude.db o cualquier .sqlite/.sqlite3) y exportaciones XML, con un límite de 256 MB. El archivo se procesa primero en un preview: revisa los mapas, equipos, submapas, decoraciones y enlaces detectados, y elige qué importar antes de escribir en el inventario.

El preview permite:

Importar credenciales RouterOS: crea credenciales a partir del usuario y la contraseña de cada equipo de The Dude y las asigna a los equipos importados.
Importar perfiles SNMP: crea los perfiles SNMP de The Dude y los asigna a los equipos que los referencian.
Sobrescribir credenciales RouterOS existentes: desactivado por defecto; solo reemplaza la credencial RouterOS de los equipos seleccionados que tengan una contraseña de Dude no vacía. Las contraseñas vacías o que no se pueden descifrar nunca sustituyen una credencial RouterOS ya asignada. Las asignaciones automáticas de perfiles SNMP nunca sobrescriben perfiles existentes; solo una selección manual de SNMP en el preview lo hace.
Monitorizar enlaces con interfaz: los enlaces de The Dude que tengan equipo e interfaz maestra se crean como enlaces monitorizados por SNMP solo si el equipo maestro tiene un perfil SNMP (asignado automáticamente en la importación, elegido a mano en el preview o ya existente); si no lo tiene, se crean como enlace simple y la importación añade un aviso.

Las credenciales y los perfiles SNMP de The Dude son opcionales: puedes desactivar su importación en el preview y mantener únicamente mapas, equipos y enlaces.

Las credenciales RouterOS se guardan en routeros_credentials y se enlazan al equipo mediante devices.routeros_credential_id. Los accesos por equipo (Winbox, Web/HTTP y SSH) siguen usando la credencial propia si existe y, si no, la credencial RouterOS asignada.

Los perfiles SNMP se crean con el nombre Dude · <nombre> [<source_id>] y la community se almacena cifrada. Solo se asignan automáticamente a equipos que no tengan ya un perfil SNMP; si eliges un perfil manualmente en el preview, esa selección tiene prioridad sobre el perfil importado y sobre el perfil existente.

Si The Dude tiene equipo e interfaz maestra en el enlace y ese equipo dispone de un perfil SNMP (importado y asignado automáticamente, elegido a mano en el preview o ya existente), NetMonitor crea el enlace con mastering_type='snmp', master_device_id y snmp_if_index. La monitorización usa el índice de interfaz tal como aparece en The Dude, que puede no coincidir con el ifIndex SNMP real; si el tráfico no aparece, ajusta el índice en el enlace. Si falta el equipo o la interfaz maestra, o el equipo maestro no tiene perfil SNMP, el enlace se crea como enlace simple; en el último caso la importación añade un aviso. El poller omite los enlaces cuyo equipo maestro no tenga perfil SNMP en lugar de usar una community por defecto.

Los secretos se cifran en reposo y no se devuelven en el preview ni en el historial de importaciones. Los perfiles SNMPv3 se importan como un perfil base (versión, puerto, tiempo de espera y reintentos) y puede que tengas que completar a mano el usuario y las claves de autenticación y privacidad.

Seguridad

No subas .env ni deploy/certs/ al repositorio. Ya están excluidos en .gitignore.
Usa HTTPS si el panel es accesible desde fuera de la red local.
Mantén ALLOW_INSECURE_DEFAULTS=false en producción.
Si usas el compose avanzado, restringe los puertos 162/udp y 514/udp a la red de gestión.
Crea API keys con el rol mínimo necesario y rótalas periódicamente.
Los despliegues RouterOS requieren aprobación; con más de un administrador, el creador no puede aprobar su propio trabajo.
Rota en origen las credenciales externas (Telegram, SNMP, S3) si alguna vez pudieron quedar expuestas.

Licencia

Distribuido bajo licencia MIT. Consulta LICENSE.

Los iconos de topología Cisco incluidos en frontend/src/assets/cisco/ son marcas de Cisco Systems, Inc. y se redistribuyen sin modificaciones únicamente para identificación de dispositivos. No están cubiertos por la licencia MIT. Consulta THIRD_PARTY_NOTICES.md.

Contribuir

Las issues y pull requests son bienvenidas. Antes de enviar cambios:

Ejecuta go test ./... y npm run build.
No incluyas secretos, certificados, backups ni datos reales de clientes.
Mantén el estilo y los mensajes existentes.

Estado

Proyecto en desarrollo activo. Las funciones principales de monitorización, mapas, alertas, traps, RouterOS e informes están implementadas y verificadas sobre Docker Compose. Las limitaciones conocidas se irán documentando en las issues del repositorio.

Navigation Menu

Repository navigation

About

Repository files navigation

NetMonitor

Características

Stack

Inicio rápido

Usar la imagen publicada en GHCR

Archivo `.env` de ejemplo

Rutas a redes privadas (opcional)

Configuración

Operación

Rotación de `ENCRYPTION_KEY`

HTTPS

Agentes remotos

Desarrollo

Accesos y credenciales

Winbox con credenciales

Importación desde The Dude

Seguridad

Licencia

Contribuir

Estado

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
backend		backend
custom-icons		custom-icons
deploy		deploy
docs/plans		docs/plans
frontend		frontend
map-backgrounds		map-backgrounds
notification-sounds		notification-sounds
reports		reports
.dockerignore		.dockerignore
.env.example		.env.example
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
THIRD_PARTY_NOTICES.md		THIRD_PARTY_NOTICES.md
docker-compose.advanced.yml		docker-compose.advanced.yml
docker-compose.dev.yml		docker-compose.dev.yml
docker-compose.lan.yml		docker-compose.lan.yml
docker-compose.tls.yml		docker-compose.tls.yml
docker-compose.yml		docker-compose.yml

Latest commit

History

Folders and files

Repository files navigation

NetMonitor

Características

Stack

Inicio rápido

Usar la imagen publicada en GHCR

Archivo .env de ejemplo

Rutas a redes privadas (opcional)

Configuración

Operación

Rotación de ENCRYPTION_KEY

HTTPS

Agentes remotos

Desarrollo

Accesos y credenciales

Winbox con credenciales

Importación desde The Dude

Seguridad

Licencia

Contribuir

Estado

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Archivo `.env` de ejemplo

Rotación de `ENCRYPTION_KEY`