🍓 Pi Dashboard

Real-time, responsive system monitoring dashboard for any Linux system — with built-in watchdog.

Live WebSocket metrics, service management, auto-restart on crash, HTTPS, token auth. Works on Raspberry Pi, Ubuntu servers, Debian, Arch, Proxmox — anything running systemd.

Features

• Real-time metrics — WebSocket updates every 2 seconds
  • CPU usage (per-core breakdown)
  • CPU temperature (ARM /sys/class/thermal, x86 lm-sensors/hwmon, auto-detected)
  • RAM + Swap
  • Disk usage
  • Network speed (upload/download rate)
  • System uptime
  • Load average
  • Top processes by CPU
• Service management — view, restart, and stop systemd services from the UI
• Watchdog — automatically restarts crashed services (configurable threshold)
• System health alerts — logs warnings for high temp, disk, and memory
• Responsive UI — works on phone, tablet, and desktop (dark theme, PWA-ready)
• Secure — HTTPS (self-signed cert), token-based auth, Tailscale VPN access
• One-command install — ./install.sh sets up everything
• Cross-platform — ARM (Pi, Odroid, NanoPi) and x86 (Intel/AMD servers, VPS)

Quick Start

git clone https://github.com/pitee33/pi-dashboard.git
cd pi-dashboard
chmod +x install.sh
./install.sh

The installer will:

1. Create a Python venv and install dependencies
2. Generate a self-signed TLS certificate
3. Create config.json with a random token
4. Install systemd services (pi-dashboard + pi-watchdog)
5. Set up sudoers for service restart permissions
6. Start everything

After install, open:

https://localhost:8443

Enter the token shown at the end of the install script.

Configuration

Edit config.json (created from config.example.json):

{
    "token": "your-secure-token",
    "host": "0.0.0.0",
    "port": 8443,
    "services": {
        "SSH": "ssh.service",
        "Docker": "docker.service",
        "Nginx": "nginx.service",
        "PostgreSQL": "postgresql.service"
    },
    "watchdog_services": {
        "Nginx": "nginx.service",
        "PostgreSQL": "postgresql.service"
    },
    "watchdog_max_fails": 3,
    "watchdog_check_interval": 30,
    "temp_threshold": 85,
    "disk_threshold": 95,
    "mem_threshold": 95
}

Key	Description
token	Auth token for dashboard access
host	Bind address (0.0.0.0 = all interfaces)
port	HTTP/HTTPS port
services	Services shown in the dashboard UI
watchdog_services	Services the watchdog monitors and auto-restarts
watchdog_max_fails	Consecutive failures before restart
watchdog_check_interval	Seconds between service checks
temp_threshold	°C — log warning above this
disk_threshold	% — log warning above this
mem_threshold	% — log warning above this

After editing, restart:

sudo systemctl restart pi-dashboard pi-watchdog

Temperature Sensor Support

The dashboard auto-detects CPU temperature from multiple sources:

Platform	Source	Requirements
Raspberry Pi (ARM)	/sys/class/thermal/thermal_zone0/temp	None (built-in)
x86 (Intel/AMD)	psutil.sensors_temperatures()	lm-sensors installed (sudo apt install lm-sensors && sudo sensors-detect)
Other ARM (Odroid, NanoPi)	/sys/class/hwmon/hwmon*/temp1_input	None
VPS / Cloud	Often not available	Shows "N/A" in the UI

If temperature shows "N/A" on an x86 system, install lm-sensors:

sudo apt install lm-sensors
sudo sensors-detect --auto
# Restart the dashboard:
sudo systemctl restart pi-dashboard

Remote Access

Via Tailscale (recommended)

The dashboard listens on all interfaces, so if Tailscale is running:

tailscale up
# Then access from any device on your tailnet:
https://<tailscale-ip>:8443

Tailscale provides WireGuard encryption, so the self-signed cert is fine — the connection is secured by the VPN tunnel.

Via Tailscale Serve (public HTTPS with valid cert)

To expose the dashboard publicly with a Tailscale-issued certificate:

1. Enable Serve on your tailnet: https://login.tailscale.com/f/serve
2. Run:

tailscale serve --bg --https 8443 http://127.0.0.1:8443

3. Access via https://<hostname>.<tailnet>.ts.net

Via reverse proxy (Nginx/Caddy)

For internet-facing deployments, put a reverse proxy with a real TLS cert (Let's Encrypt) in front:

server {
    listen 443 ssl;
    server_name monitor.example.com;
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass https://127.0.0.1:8443;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Never expose the dashboard directly to the internet without a strong token.

Usage

Action	Command
View dashboard	https://<ip>:8443
Dashboard logs	journalctl -u pi-dashboard -f
Watchdog logs	journalctl -u pi-watchdog -f
Watchdog log file	cat ~/pi-dashboard/watchdog.log
Stop	sudo systemctl stop pi-dashboard pi-watchdog
Start	sudo systemctl start pi-dashboard pi-watchdog
Restart	sudo systemctl restart pi-dashboard
Check status	systemctl is-active pi-dashboard pi-watchdog

How It Works

┌─────────────────────────────────────────┐
│  Browser (phone/desktop)                │
│  https://<ip>:8443?token=...            │
└──────────────┬──────────────────────────┘
               │ HTTPS + WebSocket (2s updates)
               │
┌──────────────▼──────────────────────────┐
│  Dashboard (FastAPI + Uvicorn)          │
│  ├── /api/metrics  → JSON snapshot       │
│  ├── /ws          → WebSocket stream    │
│  ├── /api/service → restart/stop        │
│  └── /            → HTML dashboard       │
└──────────────┬──────────────────────────┘
               │ psutil + systemctl
               │
┌──────────────▼──────────────────────────┐
│  Watchdog (background daemon)           │
│  ├── Checks services every 30s          │
│  ├── Restarts after 3 consecutive fails  │
│  ├── Checks dashboard health every 10s  │
│  └── Logs CPU temp / disk / mem warnings │
└─────────────────────────────────────────┘

Requirements

• Python 3.11+
• Linux (systemd-based — Debian, Ubuntu, Raspberry Pi OS, Arch, Proxmox, etc.)
• systemd (for service management)
• Optional: Tailscale for remote access
• Optional: uv for faster dependency installation
• Optional: lm-sensors for CPU temperature on x86

Supported Platforms

Platform	Status	Notes
Raspberry Pi (all models)	✅ Full	Temp works out of the box
Ubuntu / Debian servers	✅ Full	Install lm-sensors for temp
Arch Linux	✅ Full	Install lm-sensors for temp
Proxmox VE	✅ Full	Run in a VM or CT with systemd
Odroid / NanoPi (ARM)	✅ Full	Temp via hwmon
VPS (DigitalOcean, Hetzner)	✅ Full	Temp usually N/A (no sensor)
Non-systemd (Alpine, Void)	⚠️ Partial	Service management won't work

Project Structure

pi-dashboard/
├── app.py              # FastAPI dashboard backend + embedded frontend
├── watchdog.py         # Service watchdog daemon
├── install.sh          # One-command installer
├── requirements.txt    # Python dependencies
├── config.example.json # Template config (committed)
├── config.json         # Your config (gitignored)
├── certs/              # TLS certs (gitignored, auto-generated)
├── LICENSE             # MIT
└── README.md

License

MIT — free for personal and commercial use.

Contributing

PRs welcome! Fork → branch → PR.

git checkout -b feat/my-feature
# ... changes ...
git commit -m "feat: add my feature"
git push -u origin feat/my-feature
# Then create a PR on GitHub

Author

Built by pitee33.