Glance Dashboard V2 Ga

Posted Apr 27, 2026

By Usman Masood Ashraf

views 9 min read

#Glance Dashboard V2 Ga: A Comprehensive Guide to Self‑Hosted Infrastructure Monitoring on a Raspberry Pi 5

INTRODUCTION

In the modern DevOps landscape, visibility into every layer of an infrastructure is no longer a luxury — it’s a necessity. Homelab enthusiasts and professional sysadmins alike are constantly seeking tools that can aggregate Docker metrics, network health, service status, and custom automation triggers into a single, intuitive interface. The recent Reddit thread “After a lot of trial & error (and a few docker restart moments 😅), I finally got my dashboard where I want it: Full monitoring (Docker, services, network), Tailscale + WireGuard integration, Custom API widgets (live stats & device tracking), Home Assistant + automation layer, Custom themes & UI tweaks” resonates with anyone who has wrestled with fragmented monitoring solutions.

Enter Glance Dashboard V2 Ga — a modular, Docker‑native dashboard that brings together real‑time container telemetry, network overlay integration, and extensible widget architecture. Built to run on a Raspberry Pi 5 with a lean Docker stack, this release (Ga) focuses on stability, performance, and a themeable UI that can be tailored to both personal homelabs and production‑grade environments.

This guide walks you through every facet of Glance Dashboard V2 Ga: what it is, why it matters for self‑hosted infrastructure, the prerequisites for deployment, a step‑by‑step installation and configuration workflow, operational best practices, and troubleshooting tips. By the end of this article, you’ll have a clear roadmap to deploy, customize, and maintain a dashboard that consolidates Docker, service, and network monitoring while seamlessly integrating with Tailscale, WireGuard, and Home Assistant.

Key takeaways:

Understand the architecture and core components of Glance Dashboard V2 Ga.
Learn how to install it on a Raspberry Pi 5 using Docker Compose without relying on templating placeholders.
Discover how to extend its functionality with custom API widgets and automation hooks.
Master security hardening and performance tuning for a production‑ready setup.
Gain practical troubleshooting strategies for common deployment hiccups.

Whether you’re a seasoned DevOps engineer looking to streamline homelab observability or a curious sysadmin eager to experiment with a modern dashboard, this guide equips you with the knowledge to harness Glance Dashboard V2 Ga effectively.

UNDERSTANDING THE TOPIC

What Is Glance Dashboard V2 Ga?

Glance Dashboard V2 Ga is an open‑source, self‑hosted monitoring platform designed to provide a unified view of containerized workloads, host services, and network overlays. It distinguishes itself from traditional monitoring stacks by offering:

Modular widget architecture – Developers can create custom API widgets that pull live metrics, device tracking data, or any JSON‑serializable information. - Themeable UI – Multiple built‑in themes and a CSS hook system enable visual customization without touching core code.
Native Docker integration – Direct querying of container metadata, logs, and statistics via the Docker Engine API.
Tailscale & WireGuard support – Built‑in discovery of devices within a Tailscale network and optional WireGuard peer status checks.
Home Assistant automation hooks – Webhook endpoints that trigger Home Assistant scenes, scripts, or automations based on dashboard events.

Historical Context The original Glance Dashboard emerged as a lightweight alternative to Grafana for small‑scale Docker environments. Early adopters appreciated its simplicity but faced limitations in extensibility and theming. The V2 rewrite introduced a plugin system, allowing third‑party widget development, and added support for overlay networks (Tailscale, WireGuard). The Ga release represents the first stable “General Availability” build, consolidating community feedback, hardening security, and optimizing resource consumption for low‑power hardware like the Raspberry Pi 5.

Core Features | Feature | Description | Typical Use Case |

|———|————-|——————| | Container Metrics | Real‑time CPU, memory, network I/O, and restart counts per container. | Identify noisy containers that impact host stability. | | Service Health | Checks of systemd‑managed services, health‑check endpoints, and custom health APIs. | Ensure critical services like Pi‑hole or Nextcloud stay up. | | Network Overlay Insight | Displays Tailscale node status, WireGuard peer health, and bandwidth usage. | Monitor remote site connectivity without external tools. | | Custom API Widgets | User‑defined JSON endpoints that can query any REST API or internal service. | Show live device tracking from Home Assistant or custom IoT sensors. | | Theme Engine | SCSS‑based theming with optional dark/light modes and font adjustments. | Align dashboard aesthetics with personal preferences or brand colors. | | Automation Triggers | Webhook URLs that fire on widget state changes. | Auto‑scale a service or trigger a Home Assistant scene on high CPU usage. |

Pros and Cons

Pros - Lightweight: Runs comfortably on a Raspberry Pi 5 with ~256 MiB RAM allocation.

Extensible: Plugin system encourages community‑driven widget creation.
Unified View: Consolidates Docker, service, and network data without disparate tools.
Security‑First: Runs in isolated containers; no privileged access required for most widgets.

Cons

Learning Curve: Custom widget development requires familiarity with Docker APIs and JSON schemas. - Limited Built‑In Alerting: Alerting must be implemented via external scripts or Home Assistant automations.
UI Customization: Advanced theming may involve editing CSS files directly.

Use Cases and Scenarios

Homelab Ops Center – A single pane of glass to monitor Pi‑hole, Home Assistant, and personal CI runners.
Edge Deployments – Deploy on edge devices (e.g., Raspberry Pi 5) to oversee IoT gateways with Tailscale connectivity. 3. Hybrid Cloud Monitoring – Combine on‑premises container metrics with cloud‑based service health checks via custom widgets. 4. Automation‑Driven Ops – Trigger Home Assistant scenes when a container exceeds a memory threshold, enabling self‑healing workflows.

Current State and Future Trends

The Glance Dashboard community is actively expanding widget libraries, with contributions ranging from Grafana‑style panel components to IoT sensor dashboards. Upcoming milestones include:

Native Prometheus Scraping – Direct integration for metrics‑centric workflows. - Multi‑Node Federation – Ability to aggregate dashboards across multiple Raspberry Pi clusters.
Enhanced Security Policies – Role‑based access control (RBAC) for widget execution.

These developments aim to solidify Glance Dashboard V2 Ga as a viable alternative to heavier monitoring stacks while retaining its lightweight footprint.

PREREQUISITES

Hardware Requirements

Raspberry Pi 5 (4 GB or 8 GB RAM recommended)
MicroSD Card: Minimum 32 GB, Class 10 or UHS‑I for fast Docker image pulls.
Power Supply: 5 V 3 A USB‑C to ensure stable operation under load.
Network: Ethernet connection preferred; Wi‑Fi is acceptable if the Pi is within the Tailscale network. ### Software Dependencies

Component	Minimum Version	Rationale
Docker Engine	24.0.x	Provides the latest container runtime features and security patches.
Docker Compose	2.20.x	Enables multi‑service orchestration with proper versioning.
Tailscale CLI	1.44.0	Required for establishing secure overlay network connections.
WireGuard	1.0.20231015	Used for optional peer health checks; can be installed via package manager.
Home Assistant OS (optional)	2023.12.0	For automation integration; can also run as a Docker container.
Node.js (for custom widget development)	20.x	Facilitates modern JavaScript tooling for widget APIs.

Network and Security Considerations - Static IP: Assign a static IP to the Pi to avoid DNS changes that break Tailscale node discovery.

Firewall: Open only necessary ports (e.g., 8080 for the dashboard UI, 41641 for Tailscale, 51820 for WireGuard).
TLS: While Tailscale handles encryption, you may expose the dashboard behind an HTTPS reverse proxy (e.g., Caddy) for added security.
User Permissions: Run Docker commands as a non‑root user with sudo privileges; avoid using root inside containers.

Pre‑Installation Checklist

Update the OS: sudo apt update && sudo apt upgrade -y
Install Docker Engine and Compose: Follow the official Docker documentation for Debian‑based systems.
Install Tailscale: curl -fsSL https://tailscale.com/install.sh | sh and authenticate with your account.
Verify Docker daemon accessibility: docker ps should list running containers without sudo. 5. Create a dedicated Docker network for Glance Dashboard components: docker network create glance-net.

INSTALLATION & SETUP

1. Directory Structure

Create a dedicated directory for the Glance Dashboard stack:

  
mkdir -p $HOME/glance-dashboard/{config,widgets,theme}
cd $HOME/glance-dashboard

config – Holds Docker Compose files and environment variables.
widgets – Directory for custom widget source code.
theme – Stores SCSS/CSS theme files.

2. Docker Compose File

Below is a production‑ready docker-compose.yml that launches the core Glance Dashboard services, integrates Tailscale, and provisions a Home Assistant container for automation hooks.

```yamlversion: “3.9”

services: glance: image: ghcr.io/glance-dashboard/glance:latest container_name: $CONTAINER_NAMES_glance restart: unless-stopped environment: - DOCKER_HOST=$DOCKER_SOCKET - TAILSCALE_API_KEY=$TAILSCALE_API_KEY - WEBHOOK_SECRET=$WEBHOOK_SECRET ports: - “8080:8080” networks: - glance-net volumes: - ./config:/app/config - ./widgets:/app/widgets - ./theme:/app/theme healthcheck: test: [“CMD”, “curl”, “-f”, “http://localhost:8080/health”] interval: 30s timeout: 10s retries: 3

tailscale: image: tslabs/tailscale:latest container_name: $CONTAINER_NAMES_tailscale restart: unless-stopped environment: - TAILSCALE_AUTH_KEY=$TAILSCALE_AUTH_KEY cap_add: - NET_ADMIN network_mode: host restart: unless-stopped

homeassistant: image: ghcr.io/home-assistant/home-assistant:stable container_name: $CONTAINER_NAMES_ha restart: unless-stopped volumes: - ./ha_config:/config ports: - “8123:8123” network_mode: host restart: unless-stopped

networks: glance-net: driver: bridge

**Explanation of Key Elements**  

- **`$CONTAINER_NAMES_*`** – Placeholder variables that should be replaced with meaningful names (e.g., `glance_dashboard`).  - **`$DOCKER_SOCKET`** – Path to the Docker socket (`/var/run/docker.sock`) enabling the dashboard to query container metadata.  
- **`$TAILSCALE_API_KEY`** – Generated from your Tailscale admin console; used for node authentication.  
- **`$WEBHOOK_SECRET`** – Random string used to sign incoming webhook payloads, preventing tampering.  
- **`network_mode: host`** – Required for Tailscale to access the host network and register node routes.  ### 3. Populate Environment Variables  Create a `.env` file in the project root:  

```dotenv
# Docker socket access
DOCKER_SOCKET=/var/run/docker.sock

# Tailscale authentication
TAILSCALE_AUTH_KEY=tskey-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# Optional webhook secret for Home Assistant triggers
WEBHOOK_SECRET=$(openssl rand -hex 16)

# Home Assistant token (if you plan to use HA automations)
HA_TOKEN=long_lived_access_token

4. Pull Images and Start Stack

docker compose pull
docker compose up -d

Verify that all services are healthy:

  
docker ps
docker ps --filter "name=$CONTAINER_NAMES_glance" --format "table \t\t"

The dashboard UI should now be reachable at http://<PI_IP>:8080.

5. Initial Dashboard Configuration

Login – Default credentials are admin/admin; change the password immediately via the UI settings.
Add Docker Context – In the Docker widget settings, point to $DOCKER_SOCKET to enable container discovery.
Configure Tailscale Integration – Input your Tailscale API key and enable Node Discovery to automatically list overlay nodes.
Set Up Webhook Endpoint – In the Automation tab, add a new webhook with URL http://<HA_IP>:8123/api/webhook/glance_event and paste $WEBHOOK_SECRET as the secret.

6. Common Installation Pitfalls

Symptom	Likely Cause	Remedy
Dashboard fails to start (`port already in use`)	Another service bound to 8080	Stop conflicting container: `docker stop $(docker ps -qf "publish=8080")`
Tailscale node not appearing	Missing `NET_ADMIN` capability	Add `cap_add: - NET_ADMIN` to the Tailscale service definition
Webhook payload not received	Secret mismatch or incorrect URL	Verify `$WEBHOOK_SECRET` matches in both Glance and Home Assistant configurations
High CPU usage on Pi	Excessive widget polling interval	Reduce widget refresh rate in UI settings (e.g., from 5s to 30s)

CONFIGURATION & OPTIMIZATION ### 1. Theme Customization

Open Source, Reddit Guides, Docker

This post is licensed under CC BY 4.0 by the author.