Homelab-Dashboard einrichten: Homarr und Glance im Vergleich

Sobald im Homelab mehr als fünf Dienste laufen, merkst du dir die ganzen IPs und Ports nicht mehr. Ein Dashboard löst das: eine Startseite im Browser mit Links zu allen Diensten, ihrem Status und ein paar Infos, die du sonst einzeln zusammensuchen würdest. In diesem Guide zeige ich dir zwei Tools, die ich selbst nutze: Homarr mit grafischem Editor und Glance mit einer einzigen YAML-Datei. Am Ende weißt du, welches besser zu dir passt, und hast es sicher eingerichtet.

Kurz erklärt

• Ein Dashboard ist eine selbst gehostete Startseite, auf der du deine Dienste verlinkst und ihren Zustand siehst.
• Homarr baust du per Drag and Drop im Browser und verbindest es über Integrationen mit Diensten wie Sonarr, Proxmox oder Pi-hole.
• Glance konfigurierst du komplett in einer YAML-Datei. Es ist sehr schlank und stark bei Feeds, Releases und einfachen Status-Checks.
• Du brauchst einen Proxmox-Host oder irgendeinen Rechner mit Docker. Beide Tools laufen mit sehr wenig Ressourcen.

Wofür ein Dashboard gut ist

Ein Dashboard ersetzt keine richtige Überwachung, es ist dein Einstiegspunkt. Typisch sind drei Aufgaben: Links zu allen Web-Oberflächen an einem Ort, ein schneller Blick, ob alles erreichbar ist, und Infos wie offene Downloads, neue Releases oder News-Feeds. Wenn du echte Alarme per Push willst, schau dir zusätzlich Uptime Kuma mit ntfy an. Das Dashboard zeigt dir den Zustand, wenn du draufschaust. Uptime Kuma meldet sich, wenn etwas ausfällt.

Bei mir laufen beide Tools parallel. Homarr steht an einem Standort für die Media-Dienste, Glance am anderen als Startseite mit Feeds, Server-Stats und Status-Checks für alle Hosts. Wie die Standorte zusammenhängen, steht in Mein Homelab an zwei Standorten.

Das brauchst du

• Einen Proxmox-VE-Host mit Zugriff auf die Shell, alternativ einen Linux-Rechner mit Docker und Docker Compose.
• Für Homarr: 2 Kerne, 2 GB RAM und 8 GB Disk (Standard des Community-Scripts).
• Für Glance: 1 Kern, 512 MB RAM und 2 GB Disk reichen.
• Eine feste IP für den Container, am einfachsten per DHCP-Reservierung im Router.
• Für Homarr-Integrationen die API-Keys der Dienste, die du einbinden willst.

Schritt 1: Homarr installieren

Ich habe Homarr mit den Proxmox VE Helper-Scripts der Community installiert. Das Script legt einen Debian-LXC an (LXC ist ein schlanker Linux-Container direkt auf dem Proxmox-Host) und richtet Homarr nativ ohne Docker ein, mit Redis und nginx davor. Du startest es in der Shell des Proxmox-Hosts:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/homarr.sh)"

Schau dir fremde Scripts vorher auf GitHub an, bevor du sie als root ausführst. Im Dialog kannst du die Standardwerte übernehmen. Danach erreichst du Homarr unter http://192.168.1.x:7575. Die Konfiguration liegt in /opt/homarr.env, die SQLite-Datenbank in /opt/homarr_db. Updates holst du später, indem du in der Konsole des LXC einfach update eingibst.

Ohne Proxmox nimmst du Docker Compose. Leg dafür einen Ordner an, zum Beispiel dashboard, und darin eine Datei docker-compose.yml. Das ist das offizielle Beispiel aus der Homarr-Doku, nur ohne den optionalen Docker-Socket. Homarr legt seine Daten dann im Unterordner homarr/appdata neben der Compose-Datei ab:

services:
  homarr:
    container_name: homarr
    image: ghcr.io/homarr-labs/homarr:latest
    restart: unless-stopped
    volumes:
      - ./homarr/appdata:/appdata
    environment:
      - SECRET_ENCRYPTION_KEY=<dein-key>
    ports:
      - '7575:7575'

Den Key erzeugst du mit openssl rand -hex 32. Homarr verschlüsselt damit die gespeicherten API-Keys deiner Dienste. Heb ihn gut auf, denn ohne denselben Key kannst du ein Backup nicht wiederherstellen. Gestartet wird mit docker compose up -d. Die Doku zeigt zusätzlich einen Mount von /var/run/docker.sock. Den brauchst du nur, wenn Homarr deine Docker-Container anzeigen und steuern soll. Lass ihn sonst weg, denn wer den Socket hat, hat praktisch root auf dem Host.

Ein Hinweis zur Version: Bei mir läuft noch Homarr 1.x in einem Debian-12-LXC. Am 2. Oktober 2026 ist Homarr 2.0 erschienen, mit neuem Onboarding, neu gebautem Board-Editor, Custom Widgets und dem Workshop zum Teilen von Widgets. Das Script und das Docker-Image mit dem Tag latest installieren heute immer eine 2.x-Version, und die Schritte in diesem Guide beziehen sich auf 2.x. Weil meine eigene Instanz noch auf 1.x läuft, habe ich das Onboarding in Schritt 2 nach der offiziellen Homarr-Doku beschrieben und nicht selbst durchgeklickt. Weicht bei dir ein Menüpunkt ab, gilt die Doku.

Hast du schon eine ältere 1.x-Installation, mach vor dem Update ein Backup, in Proxmox am einfachsten ein Backup oder Snapshot des LXC. Homarr 2 migriert die Datenbank beim ersten Start, und 1.x kann die migrierte Datenbank danach nicht mehr lesen. Zurück kommst du nur über das Backup. Wer Homarr 1.x mit MySQL betreibt, muss vorher auf SQLite umstellen, denn 2.x unterstützt MySQL nicht mehr.

Schritt 2: Homarr einrichten und Integrationen verbinden

Beim ersten Aufruf leitet dich Homarr auf /init weiter. Dort startest du mit „Get started“ und legst deinen Admin-Benutzer mit Passwort an. Danach führt dich der Assistent durch ein paar kurze Abschnitte: Sprache, Theme und Server-Adresse, dann ein Überblick, was Homarr erreichen kann, danach optional erste Integrationen und zum Schluss Name, Farben und Spaltenzahl deines ersten Boards. Integrationen, Workshop, Assistant und MCP kannst du dabei überspringen und später nachholen. Mit „Restore backup“ statt „Get started“ spielst du stattdessen ein vorhandenes Backup ein.

Ein Board ist eine Dashboard-Seite mit Apps und Widgets. Du kannst unter Management, Boards weitere anlegen, zum Beispiel eins für Media und eins für Infrastruktur. Landet die Docker-Version nach einem Neustart wieder im Onboarding, ist der /appdata-Ordner nicht beschreibbar oder nicht als Volume eingebunden.

Richtig nützlich wird Homarr durch Integrationen. Eine Integration ist eine gespeicherte Verbindung zu einem Dienst, über die Widgets Live-Daten holen, etwa die nächsten Folgen aus Sonarr oder die Auslastung deines Proxmox-Hosts. So legst du eine an:

1. Öffne Management und dort Integrations.
2. Wähle den Dienst aus, zum Beispiel Sonarr.
3. Trag die Basis-URL ein, also http://192.168.1.x:8989 ohne Unterseite, und den API-Key aus den Einstellungen des Dienstes.
4. Teste die Verbindung. Homarr speichert die Integration erst, wenn der Test klappt.

Die URL muss vom Homarr-Server aus erreichbar sein, nicht von deinem Browser. Wenn Homarr im LXC läuft, funktioniert also die interne IP des Dienstes. Danach wechselst du auf dem Board in den Bearbeitungsmodus, fügst eine App-Kachel oder ein Widget hinzu und wählst die passende Integration aus. Eine App ist nur ein Link mit Icon. Ein Widget zeigt Daten, etwa einen Kalender, Download-Queues oder Systemwerte.

Schritt 3: Glance installieren

Glance installierst du genauso über die Helper-Scripts. Es ist ein einzelnes Go-Binary, das als systemd-Service läuft:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/glance.sh)"

Das Script fragt dich, ob der Container Debian 13 oder Alpine bekommen soll. Nimm Debian, denn die Befehle in diesem Guide (systemctl, journalctl) setzen systemd voraus, und Alpine nutzt ein anderes Init-System. Danach läuft Glance auf http://192.168.1.x:8080. Die Config liegt im LXC unter /opt/glance_data/glance.yml, das Programm selbst unter /opt/glance/glance. Bei mir läuft Glance seit Monaten in einem LXC mit einem Kern und 512 MB RAM, und das ist schon großzügig.

Mit Docker lädst du am einfachsten das offizielle Compose-Template herunter. Es bringt einen config-Ordner mit Beispiel-Dateien mit:

mkdir glance && cd glance && curl -sL https://github.com/glanceapp/docker-compose-template/archive/refs/heads/main.tar.gz | tar -xzf - --strip-components 2
docker compose up -d

Im Docker-Setup liegt die Config in config/glance.yml, die Startseite bindet das Template dort per $include aus config/home.yml ein. Für das Beispiel im nächsten Schritt ersetzt du den Inhalt von config/glance.yml komplett, home.yml wird dann nicht mehr genutzt. Die Logs siehst du mit docker compose logs -f glance.

Schritt 4: Die Glance-Config schreiben

Glance besteht aus Pages, Columns und Widgets. Eine Page ist eine Seite in der Navigation. Jede Page hat bis zu drei Spalten, davon müssen eine oder zwei full sein. Eine small-Spalte ist fest 300 Pixel breit. In jede Spalte kommen Widgets. Hier ist eine Startseite mit Suche, Status-Checks, Feeds und Releases:

server:
  port: 8080

pages:
  - name: Start
    columns:
      - size: small
        widgets:
          - type: clock
            hour-format: 24h
          - type: weather
            location: Berlin, Germany
            units: metric
          - type: server-stats
            servers:
              - type: local
                name: Dashboard-LXC

      - size: full
        widgets:
          - type: search
            search-engine: duckduckgo
          - type: monitor
            cache: 1m
            title: Dienste
            sites:
              - title: Proxmox
                url: https://192.168.1.x:8006
                allow-insecure: true
              - title: Homarr
                url: http://192.168.1.x:7575
          - type: rss
            title: News
            feeds:
              - url: https://www.heise.de/rss/heise-atom.xml
                title: heise

      - size: small
        widgets:
          - type: releases
            repositories:
              - glanceapp/glance
              - homarr-labs/homarr
          - type: bookmarks
            groups:
              - title: Admin
                links:
                  - title: Router
                    url: http://192.168.1.1

Ein paar Erklärungen dazu. Der monitor-Widget schickt regelmäßig eine Anfrage an jede URL und zeigt grün, wenn eine Antwort mit Status 200 kommt. allow-insecure: true brauchst du für Dienste mit selbstsigniertem Zertifikat wie die Proxmox-Oberfläche. cache legt fest, wie lange Daten zwischengespeichert werden. server-stats mit type: local zeigt CPU, RAM und Disk des Rechners, auf dem Glance läuft. Für andere Hosts gibt es type: remote, dafür muss dort der Glance Agent laufen.

Glance lädt die Config automatisch neu, sobald du speicherst. Du musst den Service also nicht neu starten. Ein Fehler in der YAML führt dazu, dass die Änderung nicht greift, deshalb lohnt sich ein Blick in die Logs mit journalctl -u glance -f (Docker: docker compose logs -f glance), während du editierst. Wenn die Datei groß wird, teilst du sie mit $include auf. Ich habe zum Beispiel eigene Dateien für die Arr-Dienste und die Downloads:

pages:
  - $include: media.yml

API-Keys schreibst du am besten nicht direkt in die YAML. Glance ersetzt ${VARIABLE} überall in der Config durch Umgebungsvariablen. Gibt es eine Variable nicht, startet Glance nicht oder lädt die neue Config nicht. Im LXC setzt du die Variablen mit systemctl edit glance in einem Override für den Service:

[Service]
Environment=SONARR_KEY=<dein-api-key>

Danach lädst du den Service mit systemctl restart glance neu und schreibst in der Config ${SONARR_KEY}. Im Docker-Setup trägst du dieselbe Zeile als SONARR_KEY=<dein-api-key> in die Datei .env neben der docker-compose.yml ein und startest mit docker compose up -d neu. Für fortgeschrittene Sachen gibt es den custom-api-Widget, der beliebige JSON-APIs abfragt und über ein Template darstellt. Den nutze ich bei mir für die meisten Kacheln, das ist aber eher etwas für später.

Homarr oder Glance: Wer nimmt was?

	Homarr	Glance
Einrichtung	Im Browser per Drag and Drop	YAML-Datei
Ressourcen	Node.js, Redis, nginx, im Script 2 GB RAM	Ein Binary, 512 MB RAM reichen
Integrationen	Viele fertige Integrationen für Arr-Stack, Download-Clients, Proxmox, DNS-Filter und mehr	Wenige eingebaute, dafür flexibel per custom-api
Feeds und News	Eher Nebensache	Stark: RSS, Reddit, Hacker News, YouTube, Releases
Benutzer	Benutzer, Gruppen, Rechte, optional OIDC oder LDAP	Einfache Benutzer mit Passwort in der Config
Backup	Datenbank plus Encryption-Key	YAML-Dateien, ideal für Git

Nimm Homarr, wenn du lieber klickst als tippst, viele Arr-Dienste und Download-Clients hast oder mehrere Leute mit eigenen Rechten aufs Dashboard lässt. Nimm Glance, wenn du Configs gern als Datei versionierst, wenig Ressourcen verbrauchen willst und dir eine Startseite mit Feeds und Status-Checks reicht. Beide parallel zu betreiben ist auch völlig in Ordnung.

Schritt 5: Den Zugriff absichern

Ein Dashboard verrät viel über dein Netz: welche Dienste laufen, unter welchen Adressen, oft mit Live-Daten. Homarr speichert außerdem die API-Keys aller verbundenen Dienste. Behandle es deshalb wie eine Admin-Oberfläche.

• Stell das Dashboard nicht direkt per Portfreigabe ins Internet. Für unterwegs ist Tailscale (ein einfaches VPN zwischen deinen Geräten) der bequemste Weg. Mein Glance-LXC hängt zum Beispiel selbst im Tailscale-Netz, so komme ich von unterwegs ohne offene Ports dran.
• In Homarr sind öffentliche Boards ohne Login lesbar. Unter Management, Boards siehst du, welche Boards öffentlich sind. Umstellen kannst du das in den Einstellungen des Boards im Bereich Danger zone. Lass Boards mit internen Daten privat und gib sie nur bestimmten Benutzern oder Gruppen frei.
• In Glance aktivierst du den Login über einen auth-Block in der Config. Den Secret-Key erzeugst du im LXC mit /opt/glance/glance secret:make, einen Passwort-Hash mit /opt/glance/glance password:hash <dein-passwort>. Mit Docker heißen die Befehle docker run --rm glanceapp/glance secret:make und docker run --rm glanceapp/glance password:hash <dein-passwort>. Den Hash trägst du als password-hash beim Benutzer ein.
• Wenn du doch über einen Reverse Proxy wie Caddy veröffentlichst, setz in Glance server: proxied: true, damit die Sperre nach fünf Fehlversuchen die echte Client-IP sieht. Zusätzlicher Schutz durch CrowdSec ist sinnvoll, siehe CrowdSec mit Caddy.
• Gib Homarr nur API-Keys mit den nötigen Rechten, wo der Dienst das erlaubt, und mounte den Docker-Socket nur, wenn du ihn wirklich brauchst.

Der Glance-Login sieht so aus:

auth:
  secret-key: <ausgabe-von-secret-make>
  users:
    admin:
      password-hash: <ausgabe-von-password-hash>

So prüfst du, ob es läuft

In der Konsole des jeweiligen LXC zeigt dir systemd den Status:

systemctl status homarr
systemctl status glance
ss -tlnp

ss -tlnp listet alle offenen Ports. Bei Homarr solltest du nginx auf 7575 sehen (das startet der Homarr-Service selbst, der normale nginx-Dienst ist deaktiviert), bei Glance den Prozess glance auf 8080. Achte bei Homarr darauf, dass Redis auf Port 6379 nur an 127.0.0.1 lauscht. Aktuelle Versionen des Scripts setzen das so, bei älteren Installationen lohnt sich ein Blick. Im Browser sollten alle Monitore in Glance grün sein und die Homarr-Widgets Daten zeigen.

Mit Docker prüfst du im Ordner mit der docker-compose.yml, ob der Container läuft und was er meldet:

docker compose ps
docker compose logs --tail 50

Typische Probleme

• Homarr-Integration schlägt beim Test fehl: Meist stimmt die URL nicht. Nimm die interne IP mit Port und ohne Pfad. Prüf vom LXC aus mit curl http://192.168.1.x:8989, ob der Dienst überhaupt erreichbar ist.
• Glance zeigt nach dem Speichern nichts Neues: Wahrscheinlich ein YAML-Fehler, oft falsche Einrückung. Die Logs mit journalctl -u glance -f zeigen die Zeile. Änderungen an Umgebungsvariablen brauchen dagegen einen Neustart mit systemctl restart glance.
• Monitor ist rot, obwohl der Dienst läuft: Bei selbstsigniertem Zertifikat fehlt allow-insecure: true. Manche Dienste antworten auf / mit einer Weiterleitung oder einem Login, dann hilft eine konkrete Health-URL.
• Homarr nach Restore ohne Integrationen: Der SECRET_ENCRYPTION_KEY war ein anderer. Sichere den Key immer zusammen mit der Datenbank, beim Script steht er in /opt/homarr.env, bei Docker in deiner docker-compose.yml.
• Feeds laden langsam oder gar nicht: Jeder Reload der Glance-Config leert den Cache. Wenn du oft speicherst, können APIs wie GitHub dich kurz drosseln.

Fazit

Beide Tools sind in zehn Minuten installiert. Homarr ist die bequemere Wahl, wenn du viele Dienste mit Live-Daten einbinden willst und lieber im Browser arbeitest. Glance ist schneller, sparsamer und passt zu dir, wenn du gern eine Datei pflegst. Fang mit einer einfachen Startseite an, ergänze nach und nach Widgets und halte das Dashboard im LAN oder hinter Tailscale. Für Alarme bei Ausfällen kombinierst du es am besten mit Uptime Kuma und ntfy.

Hat dir der Guide geholfen? Dann spendier mir gern einen Kaffee auf Ko-fi. Damit bleibt MappleBox werbefrei.

Weitere Guides

• Plex auf LG TV: kein Ton bei DTS und wie du es mit Apple TV löst
• Tailscale –accept-routes macht dein LAN kaputt? So fixt du es mit einer ip rule
• Docmost selbst hosten: Deine eigene Notion-Alternative für Familie und Projekte