Beszel: Lightweight Server Monitoring for Your Homelab

If you’ve ever tried setting up server monitoring for your homelab, you know the drill: install Prometheus, configure exporters, spend hours building Grafana dashboards, and watch your Raspberry Pi choke on the memory overhead. There’s a better way.

Beszel is a lightweight, self-hosted monitoring solution designed specifically for homelabs and self-hosted environments. It gives you CPU, memory, disk, and Docker container metrics without the complexity of traditional monitoring stacks.

Why Beszel for Your Homelab?

Traditional monitoring solutions overkill for most homelabs. Prometheus with Grafana is powerful, but requires deep knowledge of PromQL, exporter configuration, and dashboard design. Netdata is great for deep system analysis but can consume 100-300MB of RAM per node—significant when you’re running on Raspberry Pis or small VPS instances.

Beszel takes a different approach:

• Truly lightweight — Combined hub and agent use 30-50MB of RAM total
• Zero-configuration Docker monitoring — Automatically discovers and tracks containers
• No public internet required — SSH-based communication works on private networks
• Ready out of the box — Pre-built dashboards, no query language to learn
• Multi-user support — OAuth/OIDC integration built-in

For homelab operators running multiple servers—especially with limited resources—this matters. That’s less than a single browser tab, leaving room for your actual workloads.

Architecture: Hub and Agent Model

Beszel uses a hub-and-agent architecture that’s simple to understand and deploy:

┌─────────────────────────────────────────┐
│            BESZEL HUB                    │
│        (Web Dashboard)                   │
│    Built on PocketBase (Go)              │
│        Port 8090                         │
└─────────────────────────────────────────┘
                   ▲
                   │ SSH or WebSocket
                   │
                   ▼
┌─────────────────────────────────────────┐
│           BESZEL AGENT                   │
│       (System Collector)                 │
│    Binary or Docker container            │
│        Port 45876                        │
│                                          │
│  • Collects system metrics               │
│  • Monitors Docker/Podman containers    │
│  • Sends data to hub                     │
└─────────────────────────────────────────┘

The Hub is a web application built on PocketBase that provides:

• Centralized dashboard for all connected systems
• User authentication and permission management
• Historical data storage
• Alerting configuration

The Agent is a lightweight Go binary (~30MB) that:

• Collects CPU, memory, disk, and network metrics
• Monitors Docker or Podman containers automatically
• Communicates with the hub via SSH tunnel or outgoing WebSocket

The agent can connect using either SSH tunneling (no hub URL needed) or outgoing WebSocket (useful for NAT traversal). Both options work on private networks like Tailscale—no public internet exposure required.

Installation: Docker Compose Setup

Quick Start: Hub and Local Agent

Create a docker-compose.yml for your main server that runs both the hub and an agent:

services:
  beszel:
    image: henrygd/beszel:latest
    container_name: beszel
    restart: unless-stopped
    ports:
      - "8090:8090"
    volumes:
      - ./beszel_data:/beszel_data

  beszel-agent:
    image: henrygd/beszel-agent:latest
    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:
      KEY: "your-public-key-here"
      HUB_URL: "http://beszel:8090"
      TOKEN: "your-token-here"
      LISTEN: 45876

:::tip The network_mode: host is required for the agent to accurately measure host metrics. Without it, Docker’s network isolation skews the readings. :::

Adding Remote Servers

For each additional server, create a docker-compose.yml with just the agent:

services:
  beszel-agent:
    image: henrygd/beszel-agent:latest
    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:
      KEY: "your-public-key-here"
      HUB_URL: "https://beszel.yourdomain.com"
      TOKEN: "your-token-here"
      LISTEN: 45876

The public key (KEY) and token (TOKEN) come from the hub when you add a new system through the web interface.

Proxmox and LXC Container Installation

If you’re running Proxmox, you’ll likely want to monitor both your host and individual LXC containers.

Option 1: Agent on Proxmox Host

Install the agent directly on the Proxmox host using the binary:

curl -sL https://get.beszel.dev | bash -s -- -k "your-public-key" -url "https://beszel.yourdomain.com"

This gives you host-level metrics for your Proxmox server.

Option 2: Agent in LXC Container

For monitoring individual containers, install the agent inside each LXC:

# Inside your LXC container
curl -sL https://get.beszel.dev -o /tmp/install-agent.sh
chmod +x /tmp/install-agent.sh
/tmp/install-agent.sh -k "your-public-key" -url "https://beszel.yourdomain.com" -p 45876

:::tip For privileged LXC containers, Docker socket mounting (/var/run/docker.sock) works as expected. For unprivileged containers, you’ll need to adjust device permissions or use binary installation instead. :::

Binary Installation Options

The install script supports several flags:

Flag	Description
-k	Public key from hub (required)
-p	Port number (default: 45876)
-t	Authentication token
-url	Hub URL for WebSocket connection
--auto-update	Enable automatic daily updates

Hub Configuration and First Setup

After starting the hub container, access it at http://your-server:8090. You’ll create an admin account and can then add systems:

1. Click “Add System” in the dashboard
2. Enter a name for your server
3. Copy the generated public key and token
4. Configure your agent with these credentials
5. The server appears in your dashboard within seconds

For production use, set the APP_URL environment variable to your public URL:

environment:
  APP_URL: https://beszel.yourdomain.com

This ensures proper link generation for alerts and notifications.

Docker Stats and Alerts

Beszel automatically discovers Docker containers running on agents. In the web interface, you’ll see:

• Per-container CPU usage — Historical graph of each container’s CPU
• Memory usage — RAM consumption per container over time
• Network I/O — Bandwidth in/out for each container
• Container status — Running, stopped, or restarting

No labels, no configuration files, no Prometheus exporters. Just metrics.

Setting Up Alerts

Navigate to the Alerts section to configure thresholds:

• CPU usage — Alert when CPU exceeds X% for Y minutes
• Memory usage — Alert on RAM consumption thresholds
• Disk usage — Warn before storage fills up
• Temperature — Hardware temperature alerts
• System status — Alert when systems go offline

Alerts deliver through the web UI and can be sent via email. While there’s no native Slack or Discord webhook integration yet, you can use the REST API to build custom integrations.

Comparison to Alternatives

Beszel vs Netdata

Feature	Beszel	Netdata
Memory Usage	30-50 MB	100-300 MB
Setup Time	Minutes	Minutes
Configuration	Minimal	Moderate
Metrics Depth	Core system + Docker	Extensive
Best For	Resource-constrained homelabs	Deep troubleshooting

Use Beszel when: You want simple monitoring for multiple servers with low overhead. Perfect for Raspberry Pis and small VPS instances.

Use Netdata when: You need detailed system analysis, real-time troubleshooting, and don’t mind the memory footprint.

Beszel vs Glances

Feature	Beszel	Glances
Interface	Web dashboard	Terminal-focused
Multi-system	Yes	No (single node)
Historical Data	Yes	No
Docker Stats	Yes	Yes
Memory Usage	30-50 MB	10-30 MB

Use Beszel when: You need multi-system monitoring with a web interface and historical graphs.

Use Glances when: You want quick terminal-based monitoring for a single machine. Glances is lighter but lacks persistence and multi-system support.

Beszel vs Prometheus + Grafana

Feature	Beszel	Prometheus + Grafana
Memory Usage	30-50 MB	200-400 MB combined
Setup Time	5-15 minutes	Hours
Custom Metrics	No	Yes
Dashboard Builder	No (pre-built)	Yes
Best For	Homelabs	Production clusters

Use Beszel when: You want monitoring that works immediately without building dashboards.

Use Prometheus + Grafana when: You need custom application metrics, complex alerting, or Kubernetes-native monitoring.

What Beszel Doesn’t Do

Beszel isn’t trying to be everything. It deliberately trades flexibility for simplicity:

• No custom metrics — If you need application-level metrics, use Prometheus
• No log aggregation — Pair it with Dozzle for container logs
• No Kubernetes support — Built for standalone hosts, not pods
• Limited alerting channels — Web UI and email; no native Slack/Discord webhooks

For a complete homelab observability stack, combine Beszel with complementary tools:

• Beszel — System and container metrics
• Dozzle — Real-time container logs
• Uptime Kuma — Service uptime monitoring and status pages

All three together use less than 150MB of RAM. That’s a monitoring stack that fits on a single Raspberry Pi.

Conclusion

Beszel fills a gap that’s existed for years: simple, lightweight monitoring for homelabs and self-hosted environments. It’s not trying to replace Prometheus or Netdata for complex production setups. Instead, it’s the monitoring solution you can actually afford to run on resource-constrained hardware.

The five-minute setup, automatic Docker discovery, and <50MB footprint make it ideal for homelab operators who just want to know their servers are healthy without building dashboards. Add the SSH-based communication that works on private networks, and you have a monitoring solution that respects both your time and your hardware.

If you’re tired of overengineered monitoring stacks or can’t justify the memory overhead on your Raspberry Pi cluster, give Beszel a try. Sometimes the best tool is the one that stays out of your way.