Los monitores de servidor completos como Prometheus o Netdata son potentes, pero pesan y hay que configurarlos; a veces solo quieres ver de un vistazo la CPU, la RAM, el disco y los contenedores de varias máquinas sin montar una pila entera. Para eso está Beszel, una plataforma de monitorización de servidores ligera construida sobre PocketBase que se divide en dos piezas: un hub con panel web y un agente que instalas en cada sistema. En esta guía levantas ambos con Docker Compose, los emparejas con una clave, añades tus sistemas al panel y configuras alertas. La misma explicación está disponible en inglés.

Puntos clave

  • Beszel es un monitor de servidores ligero con licencia MIT y unas 23.500 estrellas en GitHub; su última versión es la v0.18.7, publicada el 5 de abril de 2026.
  • Tiene dos componentes: el hub (el panel web, construido sobre PocketBase) que escucha en el puerto 8090, y el agent (el agente), un binario de Go que corre en cada máquina vigilada y escucha en el puerto 45876.
  • El agente reporta CPU, memoria, disco, red, temperatura y GPU del anfitrión, además de las estadísticas de cada contenedor de Docker o Podman.
  • El emparejamiento se basa en una clave ED25519 que el hub genera al arrancar por primera vez, más un token de registro por cada sistema; el agente puede conectarse por WebSocket (lo inicia el agente) o por SSH (lo inicia el hub).
  • Es mucho más ligero que Netdata o que una pila de Prometheus y Grafana: el agente es un único binario que apenas consume unas decenas de MB de RAM.

¿Qué es Beszel y por qué es tan ligero?

Beszel es un monitor de servidores pensado para homelabs y flotas pequeñas de máquinas. Su repositorio oficial lo describe como "una plataforma de monitorización de servidores ligera con estadísticas de Docker, datos históricos y alertas". La palabra clave es ligera: mientras que una solución como Prometheus más Grafana implica varios contenedores, archivos de configuración y un lenguaje de consultas propio, Beszel se reduce a dos binarios y un panel que funciona nada más arrancar.

El secreto de su ligereza es la arquitectura. El hub está construido sobre PocketBase, un backend en Go que incluye base de datos, API y autenticación en un solo ejecutable, así que no necesitas una base de datos externa. El agente es igualmente un binario de Go, sin dependencias, que recoge las métricas del sistema y las envía al hub. No hay recolector intermedio ni almacén de series temporales que administrar. Por eso el agente apenas consume recursos y puedes instalarlo en máquinas modestas, incluso en una Raspberry Pi, sin que se note. Si vienes de probar monitores más completos como Glances, Beszel es el extremo opuesto: menos métricas por segundo, pero una visión centralizada de muchos servidores a la vez y casi cero mantenimiento.

¿Cómo funciona la arquitectura de hub y agente?

Esta es la parte que conviene tener clara antes de tocar el docker-compose.yml, porque Beszel no es una sola aplicación, sino dos que se hablan entre sí.

El hub es el cerebro y la cara visible. Es la aplicación web donde inicias sesión, ves los paneles, revisas el historial y defines las alertas. Guarda todos los datos en su volumen (beszel_data) y no necesita nada más para arrancar. Normalmente lo instalas una sola vez, en el servidor que quieras usar como central de monitorización.

El agent (agente) es el sensor. Lo instalas en cada máquina que quieras vigilar, incluida la propia máquina del hub si también deseas monitorizarla. Lee las métricas del anfitrión y, montando el socket de Docker en modo solo lectura, también las de cada contenedor. Por defecto escucha en el puerto 45876.

El emparejamiento entre ambos es lo más cuidado del diseño. Al arrancar por primera vez, el hub genera una clave ED25519. Cada vez que añades un sistema en el panel, el hub te da esa clave pública y un token único para ese sistema. Hay dos formas de conectar:

  • Por WebSocket: el agente inicia la conexión hacia la URL del hub e incluye el token en la cabecera; el hub verifica el token y firma un reto con su clave privada para demostrar su identidad. Es ideal cuando el agente está detrás de un NAT o un cortafuegos, porque no expone ningún puerto entrante.
  • Por SSH: el hub inicia la conexión contra el servidor SSH del agente en el puerto 45876, autenticándose con su clave pública. El servidor SSH del agente no ofrece pseudoterminal ni acepta entrada, de modo que es imposible ejecutar comandos en él aunque la clave se filtre.

¿Cómo es el docker-compose.yml del hub y del agente?

Vamos a levantar primero el hub y luego el agente. Ambos son servicios independientes; lo habitual es que el hub viva en un servidor y el agente en cada máquina vigilada, pero puedes tenerlos en el mismo anfitrión sin problema.

El hub

Crea una carpeta para el proyecto del hub y guarda dentro este docker-compose.yml. Publica el puerto 8090 y persiste sus datos en un volumen con nombre. Se fija la versión 0.18.7 en lugar de :latest, porque una etiqueta flotante puede cambiar de versión durante un simple reinicio y descolocar el panel:

services:
  beszel:
    image: henrygd/beszel:0.18.7
    container_name: beszel
    restart: unless-stopped
    ports:
      - "8090:8090"
    volumes:
      - beszel_data:/beszel_data
    healthcheck:
      test: ["CMD", "/beszel", "health", "--url", "http://localhost:8090"]
      interval: 120s
      timeout: 10s
      retries: 3

volumes:
  beszel_data:

Arráncalo y comprueba que responde:

docker compose up -d
docker compose ps

Abre http://IP-DEL-SERVIDOR:8090 en el navegador. La primera pantalla te pedirá crear la cuenta de administrador; esa cuenta es la dueña del panel, así que usa una contraseña fuerte. Si vas a exponer el hub fuera de tu red local, no publiques el puerto 8090 directamente: ponlo detrás de un proxy inverso con HTTPS, como se explica en la guía de cómo instalar Docker en Ubuntu 24.04 y los artículos de proxy de esta misma serie.

El agente

En cada máquina que quieras monitorizar, crea otra carpeta y guarda este docker-compose.yml. El agente usa network_mode: host para leer bien las métricas de red del anfitrión, monta el socket de Docker en modo solo lectura para ver los contenedores, y recibe la clave pública y el token que te da el hub:

services:
  beszel-agent:
    image: henrygd/beszel-agent:0.18.7
    container_name: beszel-agent
    restart: unless-stopped
    network_mode: host
    volumes:
      - beszel_agent_data:/var/lib/beszel-agent
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      LISTEN: 45876
      HUB_URL: "http://IP-DEL-HUB:8090"
      TOKEN: "PEGA-AQUI-EL-TOKEN"
      KEY: "PEGA-AQUI-LA-CLAVE-PUBLICA"

volumes:
  beszel_agent_data:

Rellena HUB_URL con la dirección de tu hub, y TOKEN y KEY con los valores que copiaste del panel al añadir el sistema (lo verás en el apartado siguiente). Después, arranca el agente:

docker compose up -d
docker compose logs -f beszel-agent

En los registros deberías ver que el agente se conecta al hub. Si el hub y el agente comparten la misma máquina, Beszel puede comunicarse por un socket Unix compartido en lugar de la red; para empezar, la conexión por red que ves aquí es más que suficiente.

¿Cómo añadir sistemas y configurar alertas?

Con el hub en marcha, entra en su panel y pulsa el botón de añadir un sistema (Add system). Te pedirá un nombre, la dirección del anfitrión y el puerto del agente (45876 por defecto). Al confirmar, el hub te muestra el token y la clave pública que debes pegar en el docker-compose.yml del agente; ese es el paso que cierra el emparejamiento. En cuanto el agente arranca con esos valores, el sistema pasa a estado activo en el panel y empiezas a ver sus gráficas de CPU, memoria, disco, red y contenedores en cuestión de segundos.

Para vigilar varias máquinas, repites el proceso: añades un sistema nuevo por cada una y despliegas su agente. Si gestionas muchos servidores, Beszel admite un token universal que te permite dar de alta agentes sin registrar cada uno de antemano, muy cómodo para aprovisionar máquinas de forma automática.

Las alertas se configuran por sistema o de forma global. Puedes definir umbrales para CPU, memoria, disco, temperatura y también avisar si un agente deja de responder, lo que te sirve como comprobación de que la máquina sigue viva. Beszel envía las notificaciones por correo o por servicios de mensajería mediante Shoutrrr, así que puedes encaminarlas a tu propio servidor de notificaciones push; si usas ntfy, recibirás los avisos en el móvil sin depender de terceros.

¿Cuándo elegir Beszel frente a monitores más pesados?

Beszel no compite en profundidad con Prometheus más Grafana ni con Netdata, y no pretende hacerlo. Su terreno es otro: dar una visión centralizada, clara y de bajo mantenimiento de un puñado de servidores. Elige Beszel cuando quieras un panel único para varias máquinas, con historial y alertas, sin dedicar tiempo a configurar recolectores, cuadros de mando ni consultas.

Quédate con una herramienta más pesada cuando necesites métricas por segundo y un diagnóstico muy fino de un único servidor, terreno donde brilla Netdata, o cuando quieras construir cuadros de mando y alertas a medida sobre cientos de series, que es justo lo que ofrece la pila de Prometheus y Grafana. Muchos homelabs acaban usando las dos cosas: Beszel como semáforo general de toda la flota, y un monitor detallado en las máquinas críticas. La ventaja de Beszel es que su coste de entrada es tan bajo que casi siempre merece la pena tenerlo, aunque ya uses otro sistema.

Preguntas frecuentes

¿Necesito instalar un agente en cada servidor?

Sí. El hub solo dibuja los datos; quien los recoge es el agente, y hay que instalar uno en cada máquina que quieras vigilar, incluida la del propio hub si también deseas sus métricas. La buena noticia es que el agente es un contenedor diminuto: se despliega en segundos con el docker-compose.yml de esta guía y consume muy pocos recursos, así que ponerlo en diez servidores no supone apenas carga.

¿Es seguro exponer el hub a Internet?

El hub tiene autenticación propia y admite OAuth u OIDC, pero no conviene publicar el puerto 8090 en crudo. Ponlo siempre detrás de un proxy inverso con HTTPS o accede a él por una VPN. El canal entre hub y agente ya es seguro por diseño: se autentica con la clave ED25519 y, en el modo SSH, el agente ni siquiera permite ejecutar comandos, de modo que una clave filtrada no da acceso a la máquina.

¿Puedo monitorizar contenedores de Docker con Beszel?

Sí, esa es una de sus bazas principales. Al montar el socket de Docker en el agente (/var/run/docker.sock en modo solo lectura), Beszel detecta automáticamente los contenedores en ejecución y muestra el uso de CPU, memoria y red de cada uno. También funciona con Podman. No hace falta configurar nada extra: en cuanto el agente arranca con el socket montado, los contenedores aparecen en el panel.

Conclusión

Beszel es la forma más rápida de tener una visión centralizada de varios servidores sin montar una pila de monitorización completa. Con dos docker-compose.yml, uno para el hub y otro para cada agente, y un emparejamiento por clave, en pocos minutos tienes CPU, memoria, disco, red y contenedores de toda tu flota en un solo panel, con historial y alertas. El siguiente paso natural es encaminar esas alertas a ntfy para recibirlas en el móvil, y reservar un monitor más detallado como Netdata para las máquinas donde de verdad necesites el detalle al segundo.

Fuentes: [1] Documentación oficial de Beszel: primeros pasos[1], [2] Beszel: seguridad y modelo de conexión[2], [3] Repositorio oficial de Beszel en GitHub[3], [4] Qué es Beszel (documentación oficial)[4], [5] Imagen henrygd/beszel en Docker Hub[5].

Visitas: 0

Fuentes

  1. Documentación oficial de Beszel: primeros pasos
  2. Beszel: seguridad y modelo de conexión
  3. Repositorio oficial de Beszel en GitHub
  4. Qué es Beszel (documentación oficial)
  5. Imagen henrygd/beszel en Docker Hub

Ruta: Monitorización y observabilidad con Docker