Wer mehrere selbstgehostete Dienste betreibt, kennt das Problem: Bookmarks im Browser reichen irgendwann nicht mehr aus, und der Überblick über laufende Container geht verloren. Dashy löst das mit einem zentralen Homelab-Dashboard, das alle Dienste auf einer Seite versammelt, sie per HTTP-Ping auf Erreichbarkeit prüft und mit über 50 eingebauten Widgets (Wetter, RSS, Pi-Hole-Statistiken, Proxmox-Ressourcen, Krypto-Kurse u.v.m.) anreichert. Mit 25.400+ GitHub-Stars ist Dashy das feature-reichste Open-Source-Dashboard seiner Art – und benötigt keine externe Datenbank, nur eine einzige YAML-Datei. Diese Anleitung richtet sich an Linux-Administratoren und Heimserver-Betreiber, die Docker Compose bereits kennen und Dashy auf einem beliebigen Linux-Host, einer VM oder einem NAS mit Docker betreiben möchten.

Voraussetzungen

Linux-Host, VM oder NAS mit Docker Engine und Docker Compose v2 (Plugin oder Standalone). Falls noch nicht installiert: Docker und Docker Compose auf Linux installieren.
Mindestens 1 GB freier RAM (empfohlen: 2 GB), da Dashy beim ersten Start das Vue-Frontend kompiliert.
Mindestens 500 MB freier Speicherplatz für das Docker-Image (ca. 400 MB unkomprimiert).
Netzwerkzugriff auf den gewählten Host-Port (Standard: 4000) vom Browser aus.
Optional: ein Reverse Proxy (Traefik, Nginx, Caddy) für HTTPS. Die Grundkonfiguration dazu ist in Traefik als Docker-Reverse-Proxy beschrieben.
Texteditor (VS Code, Nano, Vim) für YAML-Dateien sowie curl zur CLI-Verifikation.

Schritt 1: Projektordner und Verzeichnisstruktur anlegen

Lege einen eigenen Projektordner für Dashy an und erstelle darin das Verzeichnis user-data, das später als Volume in den Container gemountet wird. Das Volume muss zwingend als Verzeichnis eingebunden werden, nicht als einzelne Datei – andernfalls schlägt das Laden von Sub-Konfigurationen, Icons und Custom-CSS fehl. Ältere Anleitungen im Netz zeigen noch den veralteten Pfad /app/public/conf.yml – der korrekte Pfad seit Version 3.x lautet /app/user-data.

mkdir -p /opt/dashy/user-data
cd /opt/dashy

Setze die Eigentümerschaft auf UID 1000, unter der Dashy im Container läuft. Gehört das Verzeichnis einem anderen Benutzer, kommt es beim Speichern der Konfiguration zu einem EACCES-Fehler:

sudo chown -R 1000:1000 /opt/dashy/user-data

Verifizieren: Das Verzeichnis /opt/dashy/user-data muss existieren und UID/GID 1000 gehören:

ls -la /opt/dashy/
# Erwartete Ausgabe (Auszug):
# drwxr-xr-x  2 1000 1000 4096 Jun 11 10:00 user-data

Schritt 2: .env-Datei anlegen

Alle umgebungsabhängigen Werte gehören in eine .env-Datei, damit compose.yaml portabel bleibt. Dashy benötigt keine Datenbank-Passwörter oder API-Secrets als Pflichtparameter – der wichtigste Wert ist der externe Host-Port:

# /opt/dashy/.env

# Externer Host-Port fuer die Dashy Web-UI (interner Container-Port ist immer 8080)
DASHY_PORT=4000

# Optional: UID/GID des Host-Benutzers, dem das user-data-Verzeichnis gehoert
# Nur aendern, wenn der Host-User eine andere UID als 1000 hat
UID=1000
GID=1000

Verifizieren: Die Datei muss vorhanden und lesbar sein:

ls -la /opt/dashy/.env
# -rw-r--r-- 1 root root ... .env

Schritt 3: compose.yaml erstellen

Erstelle die compose.yaml im Projektordner. Das Image lissy93/dashy:latest ist ein Multi-Arch-Manifest und unterstützt amd64, arm64 und arm/v7 – kein separates Tag für Raspberry Pi oder andere ARM-Geräte nötig. Wer eine feste Version bevorzugt, kann :4.3.0 pinnen. Als Alternative bei Docker-Hub-Rate-Limits steht ghcr.io/lissy93/dashy:latest bereit.

Parameter	Wert	Hinweis
Image	lissy93/dashy:latest	Multi-Arch; alternativ ghcr.io/lissy93/dashy:latest
Interner Port	8080	Fest; nicht änderbar
Externer Port	4000 (via .env)	Frei wählbar
Volume	./user-data:/app/user-data	Verzeichnis, NICHT Einzeldatei
NODE_ENV	production	Pflicht für Produktivbetrieb
Healthcheck	node /app/services/healthcheck.js	Eingebaut, kein extra Tool nötig

# /opt/dashy/compose.yaml

services:
  dashy:
    container_name: dashy
    image: lissy93/dashy:latest
    ports:
      - "${DASHY_PORT:-4000}:8080"
    volumes:
      - ./user-data:/app/user-data
    environment:
      - NODE_ENV=production
    restart: unless-stopped
    healthcheck:
      test: ['CMD', 'node', '/app/services/healthcheck.js']
      interval: 1m30s
      timeout: 10s
      retries: 3
      start_period: 30s

Verifizieren: YAML-Syntax prüfen, bevor der Container gestartet wird:

docker compose config
# Erwartete Ausgabe: die geparste compose.yaml ohne Fehlermeldung

Schritt 4: Container starten

Starte Dashy im Hintergrund. Beim allerersten Start lädt Docker zuerst das Image (ca. 400 MB) und kompiliert dann das Vue-Frontend – dieser Vorgang benötigt 1–2 Minuten und bis zu 1,5 GB RAM. Auf Systemen mit weniger als 1 GB freiem RAM kommt es zu einem Heap Limit Allocation Failed-Fehler oder einem SIGKILL. In diesem Fall mem_limit: 1536m in der compose.yaml unter dem Service ergänzen oder Docker Desktop mehr RAM zuweisen.

cd /opt/dashy
docker compose up -d

Den Build-Fortschritt live verfolgen:

docker compose logs -f dashy

Das Dashboard ist startklar, sobald in den Logs eine Zeile wie Dashy is up and running oder Server started erscheint.

Verifizieren:

docker compose ps
# NAME    IMAGE                    COMMAND   SERVICE   STATUS          PORTS
# dashy   lissy93/dashy:latest     ...       dashy     Up (healthy)    0.0.0.0:4000->8080/tcp

curl -I http://localhost:4000
# HTTP/1.1 200 OK

Solange der Healthcheck noch im start_period liegt, zeigt docker compose ps den Status Up (health: starting) – das ist normal und kein Fehler. Nach 30 Sekunden wechselt er zu Up (healthy).

Schritt 5: Erste Konfiguration im Browser

Öffne http://<HOST-IP>:4000 im Browser. Beim ersten Aufruf zeigt Dashy eine Demo-Konfiguration mit Beispiel-Links. Es gibt zwei Wege, das Dashboard anzupassen:

Visueller UI-Editor: Klicke auf das Zahnrad-Symbol oben rechts, dann auf „Edit". Hier lassen sich Abschnitte, Links und Widgets per Formular hinzufügen, ohne YAML anfassen zu müssen. Änderungen werden direkt in ./user-data/conf.yml geschrieben.
Direkte YAML-Bearbeitung: Bearbeite /opt/dashy/user-data/conf.yml mit einem Texteditor und lade die Seite neu. Tipp: Validiere die Datei vorher unter yamllint.com, da ein YAML-Syntaxfehler zu einer leeren Dashboard-Ansicht führt.

Eine minimale conf.yml mit zwei Dienst-Links und aktiviertem Status-Check sieht so aus:

# /opt/dashy/user-data/conf.yml

appConfig:
  theme: colorful
  statusCheckInterval: 30
  enableFontAwesome: true

pageInfo:
  title: Mein Homelab

sections:
  - name: Infrastruktur
    items:
      - title: Portainer
        url: http://192.168.1.10:9000
        icon: fab fa-docker
        statusCheck: true
      - title: Proxmox
        url: https://192.168.1.20:8006
        icon: fas fa-server
        statusCheck: true
        statusCheckUrl: https://192.168.1.20:8006/api2/json/version
        statusCheckAllowInsecure: true

Wichtig: Verwende für lokale Dienste niemals localhost oder 127.0.0.1 – aus dem Container heraus ist damit der Container selbst gemeint, nicht der Host. Nutze stattdessen die LAN-IP des Hosts (z.B. 192.168.1.10) oder host.docker.internal (nur Docker Desktop).

Verifizieren: Nach dem Speichern der conf.yml die Seite im Browser neu laden. Die Status-Indikatoren neben den Links sollten nach wenigen Sekunden grün aufleuchten, wenn die Dienste erreichbar sind. Bei Konfigurationsänderungen, die nicht sichtbar werden: im Inkognito-Modus testen oder den Local-Storage-Cache über das Dashy-Menü leeren.

Schritt 6: Widgets einrichten

Dashy bietet über 50 eingebaute Widgets, die direkt in conf.yml unter einem widgets-Schlüssel in einem Abschnitt konfiguriert werden. Hier ein Beispiel mit einem Wetter-Widget und einem Pi-Hole-Widget:

sections:
  - name: Übersicht
    widgets:
      - type: weather
        options:
          apiKey: DEIN_OPENWEATHERMAP_KEY
          city: Berlin
          units: metric
          lang: de
      - type: pi-hole-stats
        options:
          hostname: http://192.168.1.5
          hideStatus: false

API-Keys für Widgets können statt direkt in conf.yml auch als Umgebungsvariablen im Container gesetzt werden – das ist sicherer, weil die Keys dann nicht in der Konfigurationsdatei landen. Dazu die Variable in .env eintragen und unter environment in compose.yaml referenzieren.

Verifizieren: Nach einem Browser-Reload sollte das Widget im Dashboard erscheinen und Daten laden. Falls ein Widget leer bleibt, in den Browser-Entwicklertools (F12 → Konsole) auf CORS- oder API-Fehler prüfen.

Schritt 7: Authentifizierung einrichten (optional)

Ohne Authentifizierung ist das Dashboard öffentlich zugänglich – für ein rein lokales Heimnetz oft ausreichend. Für den Zugriff über das Internet ist ein Passwortschutz Pflicht. Dashy bietet eine eingebaute Nutzerverwaltung über appConfig.auth:

appConfig:
  auth:
    enableGuestAccess: false
    users:
      - name: admin
        credentials: SHA256_HASH_DES_PASSWORTS
        type: admin

Den SHA-256-Hash des gewünschten Passworts erzeugen:

echo -n "MeinPasswort123" | sha256sum
# Ausgabe: a1b2c3d4...  (Hash kopieren und als credentials eintragen)

Hinweis: Die eingebaute Authentifizierung ist client-seitig und gilt daher als leichtgewichtig. Für produktive Umgebungen empfiehlt sich Keycloak oder Header-Auth über einen vorgelagerten Reverse Proxy – beide Varianten unterstützt Dashy nativ. Eine umfassende Lösung für Single Sign-On bietet Authentik oder Authelia mit Traefik Forward-Auth.

Verifizieren: Nach dem Neuladen der Seite erscheint ein Login-Formular. Mit dem konfigurierten Benutzernamen und Passwort sollte der Zugang zum Dashboard möglich sein.

Schritt 8: Updates und Backup

Dashy aktualisieren:

cd /opt/dashy
docker compose pull
docker compose up -d

Das einzige Backup-relevante Verzeichnis ist ./user-data. Es enthält conf.yml, benutzerdefinierte Icons, Fonts und CSS. Eine einfache Sicherung:

tar -czf dashy-backup-$(date +%Y%m%d).tar.gz /opt/dashy/user-data/

Für eine durchdachte automatische Backup-Strategie: 3-2-1-Backup-Strategie umsetzen mit Restic.

Verifizieren:

docker compose ps
# NAME    IMAGE                    COMMAND   SERVICE   STATUS          PORTS
# dashy   lissy93/dashy:latest     ...       dashy     Up (healthy)    0.0.0.0:4000->8080/tcp

docker compose logs --tail=20 dashy
# Keine Fehlerzeilen; letzte Zeile zeigt Server-Start

Troubleshooting / Typische Fehler

Error, unable to find config oder leeres Dashboard: Das Volume wurde als einzelne Datei statt als Verzeichnis gemountet (z.B. -v ~/conf.yml:/app/user-data/conf.yml). Fix: Volume auf ./user-data:/app/user-data (Verzeichnis) ändern und Container neu erstellen.
EACCES oder EROFS beim Speichern der Konfiguration: Das Host-Verzeichnis gehört nicht UID 1000. Fix: sudo chown -R 1000:1000 ./user-data ausführen und Container neu starten.
Heap Limit Allocation Failed oder SIGKILL beim ersten Start: Zu wenig freier RAM für den Vue-Build. Fix: mem_limit: 1536m unter dem Service in compose.yaml ergänzen oder Docker Desktop mindestens 2 GB RAM zuweisen.
HTTP 429 beim Image-Pull: Docker-Hub-Rate-Limit erreicht. Fix: ghcr.io/lissy93/dashy:latest als Image-Quelle verwenden oder docker login ausführen.
Error, unable to validate conf.yml: YAML-Syntaxfehler (falsche Einrückung, fehlendes Leerzeichen). Fix: Datei unter yamllint.com validieren, Fehler beheben, Browser neu laden.
Widgets oder Status-Checks erreichen lokale Dienste nicht: localhost oder 127.0.0.1 als Zieladresse verwendet. Fix: LAN-IP des Hosts (z.B. 192.168.1.10) oder host.docker.internal (Docker Desktop) verwenden.
Konfigurationsänderungen nicht sichtbar: Browser-Local-Storage cached die alte Konfiguration. Fix: Seite im Inkognito-Modus öffnen oder über das Dashy-Menü den Cache leeren.
Font-Awesome-Icons fehlen: Standard ist enableFontAwesome: false. Fix: enableFontAwesome: true unter appConfig in conf.yml setzen.
SELinux blockiert Schreibzugriff (Fedora, RHEL): Das Speichern der Konfiguration schlägt still fehl. Fix: Volume-Mount mit :Z-Flag versehen: ./user-data:/app/user-data:Z.

Häufige Fragen

Braucht Dashy eine Datenbank (PostgreSQL, MySQL, Redis)?

Nein. Dashy ist vollständig datenbanklos. Die gesamte Konfiguration liegt in einer einzigen Datei: ./user-data/conf.yml. Es gibt keine externe Datenbankabhängigkeit – das ist einer der Hauptgründe, warum der Betrieb so unkompliziert ist.

Wie ändere ich die Konfiguration nach dem ersten Start?

Entweder direkt die Datei ./user-data/conf.yml auf dem Host bearbeiten und danach den Browser-Cache leeren, oder den eingebauten visuellen UI-Editor im Browser unter dem Zahnrad-Symbol nutzen. Änderungen über den UI-Editor werden sofort in conf.yml geschrieben, sofern Schreibrechte korrekt gesetzt sind. Ein Containerneustart ist für Konfigurationsänderungen nicht erforderlich.

Läuft Dashy auf dem Raspberry Pi?

Ja. Das :latest-Image ist ein Multi-Arch-Manifest und unterstützt nativ amd64, arm64 und arm/v7. Kein separates Image oder Tag nötig – docker compose up -d funktioniert direkt auf allen unterstützten Architekturen. Auf einem Raspberry Pi 3 oder älter mit wenig RAM ist mem_limit: 1536m in der compose.yaml empfehlenswert.

Wie richte ich Status-Checks für meine Dienste ein?

In conf.yml unter items das Flag statusCheck: true setzen – dann wird die url des Links als Ping-Endpunkt genutzt. Mit statusCheckUrl lässt sich eine abweichende URL prüfen (z.B. ein Health-Endpoint statt der UI-URL). Das globale Prüfintervall steuert statusCheckInterval (Sekunden) unter appConfig.

Kann Dashy hinter einem Reverse Proxy laufen?

Ja, problemlos. Den externen Port auf 80/443 leiten und Dashy intern auf Port 8080 lassen. Wenn Dashy unter einem Sub-Pfad erreichbar sein soll (z.B. /dashy), die Umgebungsvariable BASE_URL=/dashy in compose.yaml ergänzen – ohne abschließenden Slash.

Wie sichere ich Dashy mit einem Passwort ab?

Unter appConfig.auth.users einen Nutzer mit name, credentials (SHA-256-Hash des Passworts) und type (admin oder viewer) anlegen. Den Hash erzeugt echo -n "Passwort" | sha256sum. Für produktive Umgebungen empfiehlt sich zusätzlich ein vorgelagerter Reverse Proxy mit Header-Auth oder Keycloak/OIDC, da die eingebaute Authentifizierung client-seitig arbeitet.

Fazit

Dashy ist eine ausgereifte Wahl für alle, die ihren selbstgehosteten Dienste-Zoo unter einer einheitlichen Oberfläche vereinen wollen. Die datenbanklose Architektur, der visuelle UI-Editor und das breite Widget-Ökosystem machen den Einstieg niedrigschwellig – gleichzeitig bieten Theme-System, Multi-Page-Support und die Authentifizierungsoptionen genug Tiefe für anspruchsvollere Setups. Der einzige relevante Vorbehalt ist der Ressourcenbedarf beim ersten Start: Wer einen sehr kleinen Heimserver oder eine Micro-VM betreibt, sollte das RAM-Limit im Blick behalten. Wer ergänzend zur Dashboard-Übersicht tiefergehende Metriken seiner Container sammeln möchte, findet mit Beszel Server Monitoring mit Docker ein ideales Pendant.

Weiterführende Anleitungen und Quellen

Offizielle Quellen: Dashy GitHub Repository | Dashy Deployment-Dokumentation | Dashy Widget-Dokumentation