---
title: "Homarr 2.13.0 mit Docker installieren: Homelab-Dashboard mit Drag-and-Drop und 40+ Integrationen"
date: 2026-07-05T06:54:19+02:00
modified: 2026-11-14T10:01:21+01:00
category: monitoring
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/homarr-docker-homelab-dashboard
reading_time: 14
personalize_url: "https://s-edv.com/anleitungen/homarr-docker-homelab-dashboard#pgid={pgid}&host_ip={host_ip}"
variables:
  - name: pgid
    label: "Gruppen-ID (PGID)"
    default: "1000"
  - name: secret_encryption_key
    label: "Schlüssel (secret encryption key)"
    generated_in_browser: true
  - name: host_ip
    label: "Host ip"
    default: "HOST-IP"
---

# Homarr 2.13.0 mit Docker installieren: Homelab-Dashboard mit Drag-and-Drop und 40+ Integrationen

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{pgid}}` | Gruppen-ID (PGID) | `1000` |
| `{{secret_encryption_key}}` | Schlüssel (secret encryption key) | wird im Browser des Lesers zufällig erzeugt |
| `{{host_ip}}` | Host ip | `HOST-IP` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/homarr-docker-homelab-dashboard#pgid=100&host_ip=HOST-IP

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Homarr fasst selbst gehostete Dienste wie Sonarr, Radarr, Jellyfin oder Pi-hole auf einer Seite zusammen. Die Konfiguration erfolgt per Drag-and-Drop, Integrationen zeigen Live-Daten, Benutzerverwaltung mit OIDC und LDAP ist dabei. Version 2.0 (Oktober 2026) bringt neuen Board-Editor, Container statt Gruppen, eigene Widgets und 31 weitere Integrationen.

**Kurzfassung:** Legen Sie einen Projektordner an, erzeugen Sie den `SECRET_ENCRYPTION_KEY` für die `.env` und richten Sie die `compose.yaml` ein. Nach `docker compose up -d` erreichen Sie Homarr unter Port 7575 und legen im Einrichtungsassistenten das Administratorkonto an. Bestehende 1.x-Installationen mit SQLite steigen per Image-Wechsel auf 2.0 um, die Datenbank wird beim Start automatisch migriert. Für HTTPS schalten Sie einen Reverse Proxy davor. Der `SECRET_ENCRYPTION_KEY` ist die einzige Pflichtvariable und darf nach dem ersten Start nicht mehr geändert werden, sonst sind die Zugangsdaten der Integrationen unlesbar.

## Voraussetzungen

- [ ] **Docker Engine >= 20.x** und **Docker Compose Plugin v2** auf dem Host, siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Linux-Host, VM oder NAS (x86_64 oder arm64, auch Raspberry Pi).
- [ ] 1 CPU-Kern und mindestens 512 MB freier RAM (im Test rund 190 MB), etwa 500 MB Speicherplatz.
- [ ] Internetzugang beim ersten Start (Image von `ghcr.io`).
- [ ] `openssl` auf dem Host (meist vorinstalliert).
- [ ] Zugriff vom Browser auf Port 7575 des Hosts.
- [ ] Optional: Reverse Proxy für HTTPS (Homarr bietet kein TLS).

## Schritt 1: Projektordner anlegen

Legen Sie einen Ordner an, etwa `/opt/homarr` oder `~/homarr`.

```bash
$ mkdir -p /opt/homarr
$ cd /opt/homarr
```

Den Unterordner für die Daten legt Docker selbst an.

> **Prüfen:** `ls -la /opt/homarr` zeigt den leeren Ordner ohne Fehler. Für späteren Betrieb mit PUID/PGID (z. B. {{pgid}}) setzen Sie jetzt die Rechte: `mkdir -p /opt/homarr/homarr/appdata && chown -R {{pgid}}:{{pgid}} /opt/homarr/homarr/appdata`.

## Schritt 2: SECRET_ENCRYPTION_KEY generieren und .env anlegen

Der `SECRET_ENCRYPTION_KEY` verschlüsselt alle Zugangsdaten der Integrationen in der SQLite-Datenbank. Erzeugen Sie den Schlüssel einmalig:

```bash
$ openssl rand -hex 32
```

Das Ergebnis ist ein 64-stelliger Hex-String. Speichern Sie ihn im Passwortmanager und legen Sie die `.env` an:

Datei: `.env`

```ini
# /opt/homarr/.env
# PFLICHT: 64-stelliger Hex-String (openssl rand -hex 32)
# WARNUNG: Diesen Wert NIEMALS nachträglich ändern!
# Alle gespeicherten Integrations-Zugangsdaten werden mit diesem Schlüssel
# verschlüsselt. Ein Wechsel macht diese Daten unlesbar.
SECRET_ENCRYPTION_KEY={{secret_encryption_key}}
```

Schützen Sie die Datei:

```bash
$ chmod 600 /opt/homarr/.env
```

> **Prüfen:** `grep SECRET_ENCRYPTION_KEY /opt/homarr/.env | awk -F= '{print length($2)}'` liefert `64`. Ein kürzerer Wert verhindert den Start.

## Schritt 3: compose.yaml anlegen

Image: `ghcr.io/homarr-labs/homarr`. Die Anleitung schreibt `v2.13.0` statt `latest` fest, damit `docker compose pull` keinen großen Versionssprung einspielt. Die Images `ghcr.io/ajnart/homarr` und `linuxserver/homarr` gehören zu 0.x und werden nicht mehr gepflegt.

```yaml
# /opt/homarr/compose.yaml
services:
  homarr:
    container_name: homarr
    image: ghcr.io/homarr-labs/homarr:v2.13.0
    restart: unless-stopped
    ports:
      - "7575:7575"
    volumes:
      # Pflicht: persistente Anwendungsdaten (SQLite-DB, Konfiguration, Logs)
      - ./homarr/appdata:/appdata
      # Optional: Docker-Socket für die Container-Integration (Starten/Stoppen,
      # Logs, Statistik-Widget). Gewährt volle Kontrolle über Docker!
      # Sicherere Alternative: Tecnativa/docker-socket-proxy vorschalten.
      # - /var/run/docker.sock:/var/run/docker.sock
    environment:
      # Pflicht: aus der .env-Datei lesen
      - SECRET_ENCRYPTION_KEY=${SECRET_ENCRYPTION_KEY}
      # Optional: Betrieb ohne root (Rechte auf appdata vorher setzen!)
      # - PUID={{pgid}}
      # - PGID={{pgid}}
      # Optional: Log-Level (debug, info, warn, error), Standard: info
      # - LOG_LEVEL=info
      # Optional: DNS-Caching (ab 2.7.0 wieder standardmäßig an),
      # false nutzt den nativen DNS-Resolver
      # - ENABLE_DNS_CACHING=false
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:7575"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
```

1. Docker-Socket: bewusst auskommentiert, ohne ihn gibt es keine Container-Steuerung. Mit Socket hat der Container faktisch Root-Zugriff auf den Docker-Daemon (Schritt 6).
2. `SQLite` läuft intern, kein Datenbank-Container nötig. Pfad: `./homarr/appdata/db/db.sqlite`.
3. `Redis` läuft intern, extern nur bei mehreren Instanzen oder Kubernetes.

> **Prüfen:** `docker compose -f /opt/homarr/compose.yaml config` gibt die aufgelöste Konfiguration ohne Fehler aus. Unter `environment` steht der Schlüssel aus der `.env`.

## Schritt 4: Container starten

Starten Sie Homarr im Projektordner:

```bash
$ cd /opt/homarr
$ docker compose up -d
```

Der erste Start legt die SQLite-Datenbank an und startet Redis (20 bis 30 Sekunden).

```bash
# Container-Status und Health-Check
```

```bash
$ docker compose ps
```

```bash
# Live-Logs verfolgen (Strg+C zum Beenden)
```

```bash
$ docker compose logs -f homarr
```

Erwartete Ausgabe von `docker compose ps`:

Ausgabe:

```plaintext
NAME      IMAGE                              COMMAND   SERVICE   CREATED         STATUS                   PORTS
homarr    ghcr.io/homarr-labs/homarr:v2.13.0 ...       homarr    2 minutes ago   Up 2 minutes (healthy)   0.0.0.0:7575->7575/tcp
```

Im Log erscheinen `Ready to accept connections` (Redis) und `WebSocket Server listening`, Zeilen mit `error` dürfen nicht auftauchen.

> **Prüfen:** `curl -sI http://localhost:7575` liefert beim ersten Start `HTTP/1.1 307 Temporary Redirect` mit `location: /init` (Einrichtungsassistent), `docker compose ps` zeigt nach etwa einer Minute `(healthy)`. Zeigen die Logs `SECRET_ENCRYPTION_KEY is required`, liegt die `.env` nicht neben der `compose.yaml` oder der Schlüssel hat nicht genau 64 Hex-Zeichen.

## Schritt 5: Ersteinrichtung im Browser

Öffnen Sie `http://<{{host_ip}}>:7575`. Beim ersten Aufruf leitet Homarr auf den Einrichtungsassistenten unter `/init` weiter. In 2.0 neu gebaut, sechs Stufen:

1. **Administratorkonto anlegen:** Benutzername und Passwort des ersten Administrators, mit vollem Zugriff.
2. **Grundeinstellungen:** Name der Instanz, Sprache.
3. **Docker-Erkennung:** nur mit eingebundenem Socket (Schritt 6).
4. **Apps und Integrationen:** erste Dienste, auch später möglich.
5. **Erstes Board:** das Dashboard nach der Anmeldung.

Im Bearbeitungsmodus platzieren Sie Apps und Widgets per Drag-and-Drop. Neu in 2.0: Container ersetzen Gruppen, Boards haben getrennte Layouts für Desktop und Mobilgeräte. Integrationen zu Sonarr, Radarr, Jellyfin und Co. richten Sie unter Management → Integrations mit URL und API-Schlüssel ein.

> **Prüfen:** Die Anmeldung mit dem Administratorkonto zeigt das Dashboard. `docker compose images` zeigt den Tag `v2.13.0`.

## Schritt 6: Docker-Socket-Integration einrichten (optional)

Entfernen Sie in der compose.yaml das Kommentarzeichen vor `- /var/run/docker.sock:/var/run/docker.sock` und führen Sie `docker compose up -d` erneut aus. Das Container-Widget zeigt Container mit CPU- und RAM-Verbrauch, Administratoren steuern sie. Docker-Endpunkte kommen in 2.0 aus Umgebungsvariablen: Der Socket wird erkannt, weitere Hosts oder Podman binden Sie mit `DOCKER_SOCKET_PATHS`, `DOCKER_HOSTNAMES` und `DOCKER_PORTS` oder als JSON in `DOCKER_ENDPOINTS` ein.

In sensiblen Umgebungen schalten Sie einen Socket Proxy dazwischen. Die Anleitung [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root) zeigt Maßnahmen.

> **Prüfen:** `docker compose exec homarr ls -l /var/run/docker.sock` zeigt den Socket im Container. Die Docker-Verwaltungsseite listet die Container, bleibt sie leer, fehlen Socket-Rechte.

## Schritt 7: HTTPS mit Reverse Proxy einrichten (empfohlen)

Homarr liefert kein HTTPS, für Internetzugriff und OIDC ist es Pflicht. Ein Reverse Proxy terminiert TLS und leitet an Port 7575 weiter:

| Proxy | Stärke | Anleitung |
| --- | --- | --- |
| Nginx Proxy Manager | Einsteigerfreundliche Web-UI, Let's Encrypt per Klick | [NPM auf Synology einrichten](https://s-edv.com/anleitungen/nginx-proxy-manager-synology-container-manager) |
| Traefik | Docker-native, Labels-basiert, automatisches HTTPS | [Traefik als Docker-Reverse-Proxy](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten) |
| Caddy | Minimale Konfiguration, automatisches HTTPS | [Caddy als Reverse Proxy](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung) |

Bei OIDC (z. B. Authentik, Keycloak) muss der Proxy die Header `X-Forwarded-For` und `X-Forwarded-Proto` setzen, damit Weiterleitungen auf HTTPS stimmen.

> **Prüfen:** `curl -I https://homarr.ihre-domain.de` liefert `HTTP/2 200` oder eine Weiterleitung auf die Anmeldeseite. Der Browser akzeptiert das Zertifikat.

**Update von 2.1 auf 2.6.0:** Stoppen Sie Homarr vor der Sicherung von `homarr/appdata` und `.env`. Übernehmen Sie den vorhandenen `SECRET_ENCRYPTION_KEY` unverändert, ändern Sie den Image-Tag auf `v2.6.0` und starten Sie den Dienst erneut. 2.2 bis 2.4 ergänzen unter anderem Unraid-Speicherpools, Beszel-GPU-Metriken und Filter für Docker-Namen. 2.4.1 korrigiert überlappende Widgets aus 2.4.0; gespeicherte Dashboard-Layouts müssen dafür nicht angepasst werden. 2.5.x bringt Fehlerbehebungen ohne neue Pflichtvariablen. 2.6.0 zeigt im Release-Widget die laufenden Versionen verknüpfter Integrationen an, unterstützt in eigenen Widgets alle Tabler-Icons und behebt unter anderem den Indexer-Test für Prowlarr; neue Pflichtvariablen gibt es auch hier nicht. Die vorübergehende Board-Snapshot-Funktion aus 2.4.0 ist wieder entfernt. Prüfen Sie nach dem Start Boards, Anmeldungen und Integrationen.

## Schritt 8: Update und Backup

Version v2.13.0, Lizenz Apache-2.0. Für ein Update tragen Sie den neuen Tag in der compose.yaml ein, lesen die Release-Notes und führen aus:

```bash
$ cd /opt/homarr
$ docker compose pull
$ docker compose up -d
```

```bash
# Alte Homarr-Images anzeigen und gezielt per ID entfernen
# (docker image prune würde alle ungenutzten Images löschen, nicht nur Homarr)
```

```bash
$ docker image ls ghcr.io/homarr-labs/homarr
```

Update von 2.0 auf 2.1: Tag auf `v2.1.1` ändern, dann `docker compose pull` und `docker compose up -d`; die Datenbank wird beim Start migriert. Wichtigste Änderung: Das DNS-Caching ist standardmäßig aus (es schickte nach dem Neuerstellen eines Containers Anfragen an die alte IP). Entfernen Sie ein gesetztes `ENABLE_DNS_CACHING=true` oder setzen Sie `false`. Im Test lief das Update auf einem Debian-Host: Log `Running DB migrations` und `Migration complete`, healthy nach rund 25 Sekunden. Das Update auf v2.5.2 lief ebenso, Benutzer und Anmeldung blieben erhalten. Beim Wechsel von v2.5.2 auf v2.6.0 mit derselben compose.yaml war der Container nach wenigen Sekunden `healthy`, das Log meldete `Migration complete`, und die Datenbank enthielt vor und nach dem Update dieselben 50 Migrationseinträge.

**Update von 2.6.0 auf 2.7.0:** Neue Pflichtvariablen gibt es nicht. Wichtig ist eine geänderte Voreinstellung: 2.7.0 schaltet `ENABLE_DNS_CACHING` wieder standardmäßig ein (Verhalten wie in 2.0.0), weil der native Resolver laut Pull Request #7207 bei Ping- und Verbindungstests Fehler verursachte. Wer nach dem Neuerstellen von Containern Anfragen an veraltete IP-Adressen sieht, setzt `ENABLE_DNS_CACHING=false`. Außerdem härtet 2.7.0 die Rechteprüfung für Sitzungsdaten, Integrationen, Release-Widget und RSS-Feeds, unterstützt anonyme LDAP-Service-Binds und protokolliert bei fehlgeschlagenen Anmeldungen die Client-IP. Im Test liefen Migration, Anmeldung und Ablehnung eines falschen Passworts ohne Fehler.

**Update von 2.7.0 auf 2.8.0:** 2.8.0 (22.10.2026) bringt laut Release Notes keine neuen Pflichtvariablen. Das Image nutzt Node.js 24.22.1 (Sicherheitsupdate) und Bun 1.4.3; dazu kommen ein Modus nur mit Zusammenfassung und Statusseiten je Widget für Uptime Kuma, Serientitel auf Jellyfin-Kacheln, korrigierte Links im Coolify-Widget und eine Kalenderansicht, die nur noch als Widget-Option gewählt wird. Im Test liefen Migration, Anmeldung und Ablehnung eines falschen Passworts ebenfalls ohne Fehler.

**Update von 2.8.0 auf 2.9.1:** Neue Pflichtvariablen gibt es nicht. 2.8.1 schließt Sicherheitslücken in Next.js, 2.9.0 erlaubt das Anlegen von Apps per Drag-and-Drop einer URL aufs Board im Bearbeitungsmodus, baut das Release-Widget neu auf und korrigiert Speicherwerte für TrueNAS; 2.9.1 stellt gespeicherte Container-Größen wieder her. Im Test meldete das Log nach dem Tag-Wechsel `Migration complete`, der Container war nach wenigen Sekunden `healthy`, die Datenbank hatte danach 51 statt 50 Migrationseinträge, der Benutzer blieb erhalten, die Anmeldung mit dem bestehenden Passwort funktionierte, und ein falsches Passwort führte zurück zur Anmeldeseite mit `error=CredentialsSignin`.

**Update von 2.9.1 auf 2.10.1:** 2.10.0 bringt laut Release Notes keine neuen Pflichtvariablen. Neu sind unter anderem eine Option, den Laufschrift-Hintergrund der Anmeldeseite auszublenden, API-Schlüssel für die Homebox-Integration, persönliche API-Tokens für die WUD-Integration, eine Fahrenheit-Option für Beszel sowie Korrekturen für TrueNAS und das Download-Widget; dazu kommt eine Härtung von Abhängigkeiten und Images. 2.10.1 aktualisiert nur Abhängigkeiten. Im Test meldete das Log nach dem Tag-Wechsel `Migration complete`, der Container war nach wenigen Sekunden `healthy`, die Datenbank blieb bei 51 Migrationseinträgen, der Benutzer blieb erhalten, die Anmeldung mit dem bestehenden Passwort funktionierte, und ein falsches Passwort führte zurück zur Anmeldeseite.

**Update von 2.10.1 auf 2.12.0:** Neue Pflichtvariablen gibt es laut Release Notes nicht. 2.11.0 aktualisiert Node.js auf 24.22.2, senkt laut Release Notes den RAM-Bedarf, ergänzt ein Feld für externe Adressen in Widget-Links und teilt Lesezugriffe zwischen API-Schlüsseln und MCP; 2.11.1 legt bei Installationen ohne Docker das fehlende nginx-Laufzeitverzeichnis an. Wichtig für den Healthcheck dieser Anleitung: Das Image v2.11.1 enthält kein `wget`. Im Test stand der Container mit der compose.yaml oben deshalb nach gut einer Minute auf unhealthy, der Healthcheck meldete `exec: "wget": executable file not found in $PATH`. 2.12.0 bringt `wget` laut Release Notes für bestehende Healthchecks zurück. Wechseln Sie deshalb direkt auf v2.12.0, nicht auf v2.11.1. Außerdem laufen die nginx-Worker im Image jetzt als www-data, und eine App-Kachel kann einen verknüpften Container starten und stoppen. Im Test meldete das Log nach dem Tag-Wechsel von v2.10.1 auf v2.12.0 `Migration complete`, der Container war nach rund 15 Sekunden healthy, der Benutzer blieb erhalten, die Anmeldung mit dem bestehenden Passwort funktionierte, und ein falsches Passwort führte zurück zur Anmeldeseite mit `error=CredentialsSignin`. Die bei gestopptem Container gesicherten Ordner homarr/appdata und .env brachten nach einem Totalverlust den Benutzer samt Anmeldung zurück.

**Update von 2.12.0 auf 2.13.0:** Neue Pflichtvariablen gibt es laut Release Notes nicht. 2.13.0 bringt Board-Tabs (bis zu fünf je Board, mit Verschieben von Elementen), einen neuen Widget-Editor mit Vorschau, 28 Theme-Vorlagen mit Live-Editor und ein Widget zur Steuerung von Home Assistant. Im Test meldete das Log nach dem Tag-Wechsel von `v2.12.0` auf `v2.13.0` `Running DB migrations` und `Migration complete`, der Container war nach rund 17 Sekunden healthy, die Datenbank hatte danach 55 statt 53 Migrationseinträge, und ein vor dem Update gesetzter Testeintrag in der Datenbank blieb erhalten. Die bei gestopptem Container gesicherten Ordner `homarr/appdata` und `.env` brachten nach einem Totalverlust die Datenbank mit diesem Eintrag zurück.

### Umstieg von Homarr 1.x auf 2.0

Laut Doku genügt bei SQLite und PostgreSQL der Image-Wechsel, die Migration läuft beim Start. So gehen Sie vor:

1. **Sichern:** `docker compose stop`, dann `.env` und den Ordner `homarr/appdata` kopieren. Zurück auf 1.x geht nur mit dieser Sicherung, weil die Migration die Datenbank umbaut.
2. **Tag ändern:** in der compose.yaml von `v1.77.2` (oder `latest`) auf `v2.0.0`, Volume-Pfad und Schlüssel bleiben.
3. **Starten:** `docker compose pull` und `docker compose up -d`. Im Log erscheinen `Running DB migrations` und `Migration complete`.

MySQL: 2.0 unterstützt MySQL nicht mehr. Überführen Sie die Daten vor dem Update mit dem Konvertierungsskript des Projekts nach SQLite („Move from MySQL to SQLite“). Eigene JSX-Widgets aus 1.x gehen in einen Migrationszustand, Homarr archiviert eine Kopie. Gruppen und dynamische Abschnitte heißen jetzt Container.

Im Test migrierte eine frische 1.77.2-Instanz nach dem Wechsel auf v2.0.0 ohne Fehler, healthy nach rund 15 Sekunden, rund 300 MB RAM.

Watchtower setzt `latest` voraus und spielt auch große Versionssprünge ein.

Zum Backup gehören:

1. `/opt/homarr/.env` mit dem `SECRET_ENCRYPTION_KEY`. Ohne sie sind gesicherte Zugangsdaten unlesbar.
2. `/opt/homarr/homarr/appdata/` mit SQLite-Datenbank, Konfiguration, Logs und Icon-Cache.

Zur Wiederherstellung legen Sie beides in denselben Pfaden ab und starten mit `docker compose up -d`.

> **Prüfen:** Nach dem Update zeigt `docker compose ps` den Container als `(healthy)`, unter **Einstellungen → Über Homarr** steht die neue Version, und Dashboards sowie Integrationen sind unverändert vorhanden.

Grundlagen zum Betrieb finden Sie in [Docker-Container automatisch aktualisieren: Diun, WUD und Renovate im Vergleich](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud).

Grundlagen zum Betrieb finden Sie in [Linux-Server absichern mit UFW und Fail2ban](https://s-edv.com/anleitungen/linux-server-absichern-ufw-fail2ban).

## Troubleshooting / Typische Fehler

1. Logs zeigen „SECRET_ENCRYPTION_KEY is required“: Die Variable fehlt oder ist leer. Im Test lief der Container weiter, Homarr war unbenutzbar. Prüfen Sie mit `ls -la /opt/homarr/.env` Ort und Länge (64 Hex-Zeichen).
2. **Zugangsdaten nach Neuaufbau verloren:** Neuer `SECRET_ENCRYPTION_KEY`. Stellen Sie die gesicherte `.env` wieder her.
3. Konfiguration nach Neustart verschwunden: Das Volume `./homarr/appdata:/appdata` ist falsch eingebunden. Prüfen: `docker compose exec homarr ls /appdata`, erwartet werden `db`, `redis` und `trusted-certificates`.
4. Docker-Socket meldet „permission denied“: Der Prozess (PUID/PGID) darf nicht auf `/var/run/docker.sock` zugreifen. Entfernen Sie PUID/PGID (Standard: root), passen Sie die Socket-Rechte laut Homarr-Doku an oder schalten Sie einen Socket Proxy vor.
5. **Rechtefehler beim Start mit PUID={{pgid}}:** Das Host-Verzeichnis gehört root. Führen Sie vor dem Start `chown -R {{pgid}}:{{pgid}} /opt/homarr/homarr/appdata` aus.
6. Integrationen liefern keine Daten: Container in anderen Docker-Netzwerken erreicht Homarr nicht per Name. Nutzen Sie ein gemeinsames Netzwerk oder die Host-IP (`docker network inspect`).
7. „Internal Server Error“ bei einzelnen Integrationen oder Anfragen an eine alte Container-IP: Das DNS-Caching verursachte in manchen Netzen Probleme (GitHub-Issue #4006). Von 2.1 bis 2.6 war es standardmäßig aus, ab 2.7.0 ist es wieder an. Tritt der Fehler nach dem Neuerstellen eines Containers auf, setzen Sie `ENABLE_DNS_CACHING=false` und starten neu.
8. Update von 1.x auf 2.0 scheitert bei MySQL: Bleiben Sie auf 1.77.2, bis die Daten nach SQLite konvertiert sind (siehe Umstieg).
9. Umstieg von ajnart/homarr oder linuxserver/homarr: Version 1.0 war ein Neuaufbau, alte Konfigurationen sind nicht kompatibel. Betreiben Sie beide parallel auf verschiedenen Ports.

## Häufige Fragen

### Brauche ich eine externe Datenbank (PostgreSQL) oder Redis?

Für eine einzelne Instanz nicht: SQLite (`/appdata/db/db.sqlite`) und Redis laufen im Container. PostgreSQL und externer Redis sind für Hochverfügbarkeit oder Kubernetes, MySQL wird seit 2.0 nicht mehr unterstützt.

### Wie setze ich den SECRET_ENCRYPTION_KEY sicher?

Erzeugen Sie ihn einmalig mit `openssl rand -hex 32`, tragen Sie ihn in die `.env` ein und referenzieren Sie ihn in der compose.yaml mit `${SECRET_ENCRYPTION_KEY}`. Alternativ liest Homarr mit Suffix `_FILE` den Wert aus einer Datei (Docker Secret).

### Ist HTTPS möglich, und wie richte ich es ein?

Ja, über einen Reverse Proxy (Schritt 7).

### Kann Homarr meine laufenden Docker-Container anzeigen und steuern?

Ja, wenn der Docker-Socket eingebunden ist (Schritt 6). Das Container-Widget ist nur für Administratoren. Sicherer ist ein Socket Proxy.

### Wie aktualisiere ich Homarr auf die neueste Version?

Tag in der compose.yaml anpassen, dann `docker compose pull` und `docker compose up -d` (Schritt 8). Das appdata-Verzeichnis bleibt, Migrationen laufen automatisch.

### Wie unterscheidet sich Homarr von Homepage oder Glance?

Homepage und Glance laufen per YAML; Homarr konfigurieren Sie im Browser, es hat mehr Integrationen und Benutzerverwaltung, braucht aber mehr Ressourcen.

### Was passiert bei einer vollständigen Deinstallation?

Führen Sie `docker compose down` aus, löschen Sie den Ordner mit `rm -rf /opt/homarr` und entfernen Sie das Image mit `docker image rm ghcr.io/homarr-labs/homarr:v2.13.0`.

## Fazit

Homarr läuft als einzelner Container ohne externe Datenbank. Sichern Sie die `.env` mit dem Schlüssel wie das appdata-Verzeichnis, binden Sie den Docker-Socket nur bei Bedarf ein und scannen Sie Images, etwa mit Trivy.

## Weiterführende Anleitungen und Quellen

1. [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian)](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
2. [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)
3. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
4. [Watchtower mit Docker: Container automatisch aktualisieren](https://s-edv.com/anleitungen/watchtower-docker-automatische-updates)
5. [Docker-Images auf Schwachstellen scannen mit Trivy](https://s-edv.com/anleitungen/docker-images-scannen-trivy-schwachstellen-sbom)
6. [Beszel Server Monitoring mit Docker einrichten](https://s-edv.com/anleitungen/beszel-server-monitoring-docker-installieren)

Offizielle Quellen: [Homarr Dokumentation: Docker-Installation](https://homarr.dev/docs/getting-started/installation/docker/) | [Homarr Dokumentation: Umgebungsvariablen](https://homarr.dev/docs/advanced/environment-variables/) | [GitHub: homarr-labs/homarr](https://github.com/homarr-labs/homarr) | [Release-Notes v2.13.0](https://github.com/homarr-labs/homarr/releases/tag/v2.13.0)

## Passende Anleitungen auf S-EDV

1. [Homepage auf dem Synology NAS installieren: Dashboard für alle Self-Hosting-Dienste](https://s-edv.com/anleitungen/homepage-synology-dashboard-selfhosting)
2. [Automatische Sicherheitsupdates unter Debian/Ubuntu mit unattended-upgrades rich](https://s-edv.com/anleitungen/unattended-upgrades-automatische-sicherheitsupdates-debian-ubuntu)
3. [netcup Local Block Storage bestellen, einrichten und unter Linux einbinden](https://s-edv.com/anleitungen/netcup-local-block-storage-bestellen-linux-einbinden)
