DEV Community: Youssef Boubli

Real-Time Homelab Telemetry Without Spawning Shell Scripts

Youssef Boubli — Sun, 21 Jun 2026 06:44:04 +0000

BODY — copy from here ↓

Series: Building AMUD — Part 4 of 12
Part 1: Why I Built AMUD in Rust
GitHub: https://github.com/boubli/AMUD-Dashboard

Most homelab dashboards get CPU and container stats by running docker stats, pvesh, or curl in a loop. Every poll = new subprocess = wasted CPU.

AMUD collects telemetry natively in Rust.

Quick facts

Component	Role
`amud-agent`	Collects host + container metrics
`amud-server`	Broadcasts to browsers via WebSocket
Tokio	Async polling on green threads
IPC	Unix domain socket (or TCP on Windows)

Idle footprint: ~26–35MB for server + agent combined.

The old way vs AMUD

Approach	Problem
Shell out to `pvesh get ...`	New process every few seconds
`curl` Proxmox API in bash	Parsing overhead, fragile
Docker CLI polling	Slow, permission-heavy

The AMUD way

Host metrics: read directly from /proc and /sys — no subprocess.

Proxmox LXC/VM status: native HTTPS REST calls via hyper + rustls to the Proxmox API (port 8006).

Docker: read the Docker daemon over the Unix socket via hyperlocal — no docker stats CLI.

Browser updates: amud-server uses a tokio::sync::watch channel. One poll tick → serialize once → push to all WebSocket clients.

Result: live CPU, RAM, disk, and network graphs that update smoothly without freezing the UI.

Agent ↔ server security

The agent must authenticate before sending telemetry — challenge-response with a shared secret (AMUD_AGENT_SECRET). Random processes can't inject fake metrics.

Architecture docs: https://boubli.github.io/AMUD-Dashboard/docs/ARCHITECTURE

What you see on the dashboard

Host CPU / RAM / disk bars (real-time)
Per-app RUNNING / STOPPED when linked to LXC CTID or Docker name
Integration badges (Plex streams, Pi-hole queries, etc.) polled concurrently

Setup reminder

Install AMUD (Proxmox or Docker)
Ensure amud-agent is running
Add Proxmox API token in Settings if you use LXC status

Next: Green/red LXC badges and start/stop from the dashboard.

⭐ https://github.com/boubli/AMUD-Dashboard

Install AMUD on Proxmox in One Command (No Docker Required)

Youssef Boubli — Sun, 21 Jun 2026 06:40:33 +0000

BODY — copy from here ↓

Series: Building AMUD — Part 2 of 12
Previous: Why I Ditched Heavy Dashboards and Built My Own in Pure Rust

If you run Proxmox, you probably have 20+ services and no single place to open them. Most dashboards assume Docker. AMUD (Advanced Modern Unified Dashboard) is different: native Rust binaries, ~26–35MB RAM idle, and a one-line Proxmox installer.

Quick facts


Stack	Rust, Axum, Tokio, SQLite
Config	Web UI only — no YAML
RAM	~26–35MB (server + agent)
GitHub	https://github.com/boubli/AMUD-Dashboard
Docs	https://boubli.github.io/AMUD-Dashboard/docs/installation/proxmox

How it works on Proxmox

AMUD splits into two tiny daemons:

amud-agent — runs on the Proxmox host. Reads CPU/RAM/disk from /proc, queries the Proxmox API for LXC/VM status, writes metrics to a Unix socket.
amud-server — runs in a Debian 12 LXC. Serves the web UI on port 8000, stores config in SQLite, streams live telemetry over WebSockets.

No Docker layer. No PHP. No Node runtime sitting idle.

One-command install

SSH into your Proxmox host as root and run:

curl -sSL https://raw.githubusercontent.com/boubli/AMUD-Dashboard/main/setup-amud.sh | bash

The script will:

Install amud-agent as a systemd service on the host
Create an LXC named amud-dashboard (1 CPU, 256MB RAM, 4GB disk)
Bind-mount /opt/amud/run so server and agent share the IPC socket
Deploy amud-server and print the container IP when done

First login

Open:

http://<LXC-IP>:8000/

Default credentials:

Username: admin
Password: password

Change the password immediately under Settings → Admin Profile.

Enable live LXC status (green/red badges)

Without a Proxmox API token, host metrics work but app cards stay on CHECKING...

Quick CLI setup on the Proxmox host:

pveum role add AMUDAgentRole -privs "VM.Audit Sys.Audit VM.PowerMgmt"
pveum group add amud-group
pveum user add amud@pve -group amud-group -comment "Telemetry Agent User"
pveum aclmod / -group amud-group -role AMUDAgentRole
pveum user token add amud@pve amud-token --privsep 0

Copy the token line that looks like:

PVEAPIToken=amud@pve!amud-token=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

Paste it in AMUD → Settings → Proxmox VE.

Now link app cards to container IDs and watch RUNNING / STOPPED update in real time. You can start/stop containers from the dashboard if you included VM.PowerMgmt.

Prefer Docker?

AMUD supports Docker Compose too — but on Proxmox, native LXC is the lightest path. Docker guide: https://boubli.github.io/AMUD-Dashboard/docs/installation/docker

What's next

Part 3: Why I replaced Homepage YAML with a SQLite UI.

⭐ If this helped: https://github.com/boubli/AMUD-Dashboard

Questions welcome in GitHub Discussions.

I Replaced Homepage YAML with a SQLite UI — Here's Why

Youssef Boubli — Sun, 21 Jun 2026 06:39:54 +0000

BODY — copy from here ↓

Series: Building AMUD — Part 3 of 12
Part 1: Why I Built AMUD in Rust
Part 2: Install AMUD on Proxmox in One Command (No Docker Required)*

Homepage and Homarr are great — until you miss one YAML indent and the whole dashboard breaks. I built AMUD with a different rule: no YAML as primary config.

Quick facts

AMUD = Advanced Modern Unified Dashboard
Config lives in SQLite (amud.db), edited through the web UI
Layouts, tabs, apps, settings — all managed visually
Repo: https://github.com/boubli/AMUD-Dashboard

The YAML pain (you've felt it)

services:
  - Media:
      - Plex:
          href: http://plex.local:32400
           icon: plex.png

One wrong space and the page is blank.

With Homepage/Homarr you often:

Edit files on disk or in Git
Restart or reload to see changes
Debug syntax errors in nested YAML
Keep config in sync across machines

What AMUD does instead

Everything goes into SQLite in WAL mode (fast concurrent reads/writes):

Setting	Where
App cards and URLs	UI — drag, edit, save
Category tabs	UI
Grid columns, accent color	Settings → Appearance
Integrations (Plex, Jellyfin, HA)	Settings → Integrations
Proxmox token	Settings → Proxmox VE

No file to SSH into. No restart after adding a bookmark.

Backup is one file

Your entire dashboard config:

/opt/amud/data/amud.db

Copy that file = full backup. Restore it = full restore.

Docs: https://boubli.github.io/AMUD-Dashboard/docs/troubleshooting

When YAML dashboards still win

Be honest:

GitOps workflows — you want config in Git and PR reviews
Huge static service lists generated from Ansible/Terraform
Multi-environment configs from templates

AMUD is for homelabbers who want a living control panel you tweak from the browser — not a config repo.

AMUD's hard rule

From the roadmap — things AMUD will not do:

YAML as primary config. SQLite + UI is the whole point.

Try it

Install: https://boubli.github.io/AMUD-Dashboard/docs/installation/proxmox

Next: Real-time telemetry without shell scripts.

⭐ Star the repo: https://github.com/boubli/AMUD-Dashboard

Why I Ditched Heavy Dashboards and Built My Own in Pure Rust

Youssef Boubli — Thu, 11 Jun 2026 15:01:04 +0000

Why I Ditched Heavy Dashboards and Built My Own in Pure Rust

If you run a home lab, you know the feeling: you spend hours setting up the perfect stack of services, only to realize you need a centralized way to access them. You reach for a dashboard, install it, and suddenly realize your simple link portal is eating up 150MB of RAM and requires a crash course in YAML just to add a new shortcut.

I decided I was done with that. So, I built AMUD (Advanced Modern Unified Dashboard).

You can check out the source code and the final result here: https://github.com/boubli/AMUD-Dashboard.

Here is a look at why I built it, the architecture behind it, and how it completely changed my server workflow.

The Problem: Bloatware in the Home Lab
The current landscape of self-hosted dashboards is generally split into two frustrating camps.

On one side, you have applications like Heimdall. While it looks great, it brings the entire weight of a PHP/Laravel lifecycle with it. A dashboard's primary job is to sit idle 99% of the time, yet these setups consume significant server resources just existing in the background.

On the other side, you have highly customizable tools like Homepage. The catch? You are forced to manage complex YAML configuration files. If you make a single indentation error, the whole interface breaks.

As someone who values highly optimized system architecture, wasting CPU cycles on a heavy runtime—or wasting my own time writing YAML to add a simple URL—felt unacceptable. I wanted a control center that was microscopic in size but massive in functionality.

The Solution: Enter AMUD and Pure Rust
I built AMUD entirely from scratch using pure, compiled Rust. By stepping away from heavy web frameworks and Docker-dependent networking layers, the results were exactly what I was aiming for.

AMUD operates as a single-binary ecosystem with an embedded SQLite architecture. Because it executes as native machine code, the entire dashboard, database, and telemetry layer idle at roughly 26MB of RAM.

Performance and memory safety were the biggest reasons for choosing Rust, but the real magic happens in the telemetry. AMUD utilizes Tokio to handle asynchronous threads. This allows the dashboard to stream live CPU, RAM, and disk metrics to your screen in real-time without locking up the UI or taxing the host system.

Best of all? Zero YAML. Everything from advanced layouts to tagging and sub-pages is managed entirely through a clean, reactive user interface.

The Proxmox Advantage: Bypassing Docker Overhead
A lot of self-hosted software assumes you want to run everything in Docker. While Docker is great, wrapping a simple dashboard in a containerized network layer adds unnecessary overhead, especially if you are running a bare-metal hypervisor like Proxmox.

I designed AMUD to be a first-class citizen in Proxmox LXC (Linux Container) environments.

To make deployment seamless, I wrote a native Proxmox Autopilot setup script. Instead of wrestling with container registries and port forwarding, you simply run the script. It provisions a minimal Debian 12 LXC, installs the compiled Rust binary, configures the services, and launches AMUD instantly. Furthermore, if you link your apps to your LXC containers, AMUD's live telemetry will dynamically turn your dashboard icons green or red based on the container's true running state.

Call to Action: Let's Build This Together
AMUD is completely open-source, and I am actively looking to grow the community around it. Whether you are a Rust developer looking for a new open-source project to contribute to, or a homelab enthusiast who just wants a faster, lighter dashboard, I would love for you to try it out.

Check out the repository, test the Proxmox installation script, and let me know what you think:
👉 https://github.com/boubli/AMUD-Dashboard

If you like the architecture or find the tool useful, dropping a Star on the repo helps tremendously. Feel free to fork the code, open an issue for feature requests, or submit a pull request!