Kavita mit Docker installieren: Schneller Reading-Server für Comics, Manga und eBooks

Kavita ist ein schneller, selbst gehosteter Reading-Server für Comics (CBR, CBZ), Manga, Webtoons und eBooks (EPUB, PDF). Über den browserbasierten Reader kannst du deine digitale Bibliothek auf jedem Gerät im Heimnetz lesen – ohne Abo, ohne Cloud-Abhängigkeit. Externe E-Reader-Apps wie KOReader oder Moon+ Reader lassen sich per OPDS ankoppeln. Mit über 10.900 GitHub-Stars und 1,6 Millionen Container-Pulls ist Kavita das führende Open-Source-Projekt dieser Kategorie. Diese Anleitung zeigt dir den Weg von null bis zum laufenden Reading-Server per Docker Compose auf einem beliebigen Linux-Host – mit Verifikation nach jedem Schritt.

Voraussetzungen

1. Linux-Host (x86_64, arm64 oder arm/v7), VM oder NAS mit Docker-Unterstützung – oder Windows/macOS mit Docker Desktop
2. Docker Engine >= 20.10 mit Compose-Plugin v2 (Befehl: docker compose ohne Bindestrich). Falls noch nicht installiert, lies zuerst die Grundlagenanleitung: Docker und Docker Compose auf Linux installieren
3. Mediendateien (CBR, CBZ, EPUB, PDF) auf dem Host-Dateisystem erreichbar
4. Netzwerkzugang auf Port 5000 (oder einen frei gewählten externen Port)
5. Für den Produktivbetrieb hinter einem Reverse Proxy mit HTTPS empfiehlt sich Caddy als Reverse Proxy oder Traefik (kein Pflichtschritt für diese Anleitung)
6. RAM: ca. 256–512 MB im Betrieb; CPU: gering (kein Transcoding notwendig)

Eckdaten im Überblick

Schritt 1: Projektordner und Verzeichnisstruktur anlegen

Lege einen dedizierten Ordner für Kavita an. In diesem Beispiel wird /opt/kavita verwendet – du kannst auch ~/kavita nehmen.

mkdir -p /opt/kavita
cd /opt/kavita

# Unterordner für Medien anlegen (passe die Pfade an deine Medienstruktur an)
mkdir -p manga comics books kavita-config

Wenn deine Mediendateien bereits an einem anderen Ort liegen (z. B. /mnt/media/manga), brauchst du diese Ordner nicht neu anlegen – du trägst die vorhandenen Pfade später in die .env ein.

Verifizieren: Mit ls /opt/kavita solltest du die Unterordner manga, comics, books und kavita-config sehen.

Schritt 2: .env-Datei mit Konfiguration anlegen

Alle anpassbaren Parameter landen in einer .env-Datei. Kavita benötigt keine Passwörter oder Datenbankverbindungen als Umgebungsvariablen – das ist ein bewusster Unterschied zu vielen anderen Self-Hosted-Apps. Lediglich die Zeitzone und die Host-Pfade sind sinnvoll zu setzen.

# /opt/kavita/.env

# Externer Port (Host-Seite); Kavita lauscht intern immer auf 5000
KAVITA_PORT=5000

# Medienpfade auf dem Host (passe diese an deine reale Struktur an)
MANGA_PATH=/opt/kavita/manga
COMICS_PATH=/opt/kavita/comics
BOOKS_PATH=/opt/kavita/books

# Konfigurationsverzeichnis (SQLite-Datenbank, Logs)
CONFIG_PATH=/opt/kavita/kavita-config

# Zeitzone
TZ=Europe/Berlin

Wenn deine Medienbibliotheken bereits unter /mnt/media/... liegen, ersetze die Pfade entsprechend. Der Container-seitige Pfad (/manga, /comics, /books) bleibt immer gleich – nur der Host-Pfad links vom Doppelpunkt ändert sich.

Verifizieren:

cat /opt/kavita/.env

Alle Zeilen müssen lesbar sein und die Pfade müssen auf dem Host existieren.

Schritt 3: compose.yaml erstellen

Lege die Compose-Datei im Projektordner ab. Das offizielle Image von der GitHub Container Registry (ghcr.io/kareadita/kavita) ist die kanonische Quelle und unterliegt keinen Docker-Hub-Ratenlimits.

# /opt/kavita/compose.yaml

services:
  kavita:
    image: ghcr.io/kareadita/kavita:latest
    container_name: kavita
    restart: unless-stopped
    ports:
      - "${KAVITA_PORT:-5000}:5000"
    volumes:
      - ${MANGA_PATH:-./manga}:/manga
      - ${COMICS_PATH:-./comics}:/comics
      - ${BOOKS_PATH:-./books}:/books
      - ${CONFIG_PATH:-./kavita-config}:/kavita/config
    environment:
      - TZ=${TZ:-Europe/Berlin}

Wichtige Hinweise zur compose.yaml:

1. Der Container-interne Pfad /kavita/config ist hardcoded. Ändere niemals den rechten Teil des Volume-Mounts – nur den linken (Host-)Teil.
2. Es gibt keinen separaten Datenbankcontainer. Kavita ist vollständig in sich geschlossen.
3. Der Image-Tag latest folgt dem stabilen Release-Kanal. Wer nightly nutzt, kann danach nicht ohne Weiteres auf latest zurückwechseln (inkompatible DB-Migrationen).
4. Möchtest du weitere Medienbibliotheken einbinden (z. B. /novels), ergänze einfach weitere Volume-Einträge.

Verifizieren:

docker compose -f /opt/kavita/compose.yaml config

Die Ausgabe sollte die aufgelöste Konfiguration ohne Fehlermeldungen zeigen – alle Variablen aus der .env werden eingesetzt.

Schritt 4: Container starten

cd /opt/kavita
docker compose up -d

Docker zieht das Image (ca. 100–200 MB), erstellt den Container und startet ihn im Hintergrund.

Verifizieren:

docker compose ps

Erwartete Ausgabe (Spalte STATUS zeigt Up):

NAME      IMAGE                             COMMAND   SERVICE   STATUS    PORTS
kavita    ghcr.io/kareadita/kavita:latest   ...       kavita    Up        0.0.0.0:5000->5000/tcp

Anschließend Logs prüfen – keine Fehler zu Port oder Volume sollten erscheinen:

docker compose logs -f kavita

Typische Startmeldung: Now listening on: http://0.0.0.0:5000. Mit Ctrl+C beendest du das Log-Follow.

HTTP-Erreichbarkeit testen:

curl -I http://localhost:5000

Erwartete Antwort: HTTP/1.1 200 OK oder HTTP/1.1 302 Found (Redirect auf die Login-Seite).

Schritt 5: Admin-Account und erste Bibliothek einrichten

Rufe im Browser http://<host-ip>:5000 auf. Beim allerersten Start startet Kavita einen Setup-Wizard, in dem du Name, E-Mail-Adresse und Passwort des Admin-Accounts festlegst. Dieser Schritt ist einmalig und kann nicht übersprungen werden.

Nach dem Login navigierst du zu Einstellungen > Admin-Dashboard > Bibliotheken und legst dort deine Bibliotheken an:

1. Klick auf „Bibliothek hinzufügen"
2. Typ wählen (Manga, Comics oder eBooks)
3. Pfad eintragen – das ist der Container-seitige Pfad, also z. B. /manga oder /books
4. Speichern – Kavita startet sofort einen Scan

Wichtig: Die Pfade in der Web-UI sind immer die Container-internen Pfade (z. B. /manga), nicht die Host-Pfade. Der Scan läuft im Hintergrund; bei großen Bibliotheken kann das einige Minuten dauern.

Verifizieren: Nach dem Scan siehst du deine Serien und Bücher in der Bibliotheksübersicht. Ist die Bibliothek leer, prüfe die Volume-Mounts:

docker compose exec kavita ls /manga

Die Ausgabe sollte deine Manga-Ordner oder Dateien zeigen. Ist der Befehl leer, stimmt der Host-Pfad in der .env nicht.

Schritt 6: OPDS für externe E-Reader einrichten

Kavita stellt für jeden Benutzer eine eigene, berechtigungsbasierte OPDS-URL bereit. Damit lassen sich Apps wie KOReader, Moon+ Reader, Panels oder Suwatte direkt ankoppeln.

Die OPDS-URL findest du im Web-UI unter Einstellungen > Benutzerprofil > OPDS-URL. Das Format lautet:

http://<host>:5000/api/opds/<dein-api-key>

Der API-Key übernimmt die Authentifizierung – kein zusätzliches Passwort nötig. Gib diese URL in deiner OPDS-App ein.

Verifizieren:

curl -s "http://localhost:5000/api/opds/<dein-api-key>" | head -5

Erwartete Ausgabe: Beginn eines XML-Dokuments (<?xml und <feed), was zeigt, dass der OPDS-Endpunkt antwortet.

Schritt 7: Updates und Backup

Kavita wird regelmäßig aktualisiert. Das Update-Verfahren ist einzeilig:

cd /opt/kavita
docker compose pull && docker compose up -d

Vorher empfiehlt sich ein Backup des Config-Verzeichnisses, das die SQLite-Datenbank, Einstellungen und Logs enthält:

# Container stoppen, Config sichern, neu starten
docker compose stop kavita
tar -czf /backup/kavita-config-$(date +%F).tar.gz /opt/kavita/kavita-config
docker compose start kavita

Eine systematische Backup-Strategie für deine gesamte Serverinfrastruktur beschreibt die Anleitung 3-2-1-Backup-Strategie umsetzen.

Verifizieren:

docker compose ps
docker image ls ghcr.io/kareadita/kavita

Die Spalte STATUS zeigt Up, die Image-Ausgabe das aktuelle Erstellungsdatum des neuen Layers.

Troubleshooting / Typische Fehler

1. Bibliothek bleibt nach dem Scan leer: Der gemountete Host-Pfad existiert nicht oder enthält keine erkannten Dateiformate. Prüfe mit docker compose exec kavita ls /manga. Tippfehler im Host-Pfad der .env beheben und Container mit docker compose up -d neu starten.
2. HTTP 502 oder kein Verbindungsaufbau: Container läuft nicht. docker compose ps prüfen; bei Status Exited die Logs mit docker compose logs kavita lesen.
3. Port 5000 bereits belegt: Fehlermeldung Bind: address already in use. Externen Port in der .env ändern: KAVITA_PORT=5001, dann docker compose up -d. Unter macOS belegt AirPlay-Receiver Port 5000.
4. Falscher Config-Pfad nach Image-Wechsel: Wechsel von ghcr.io/kareadita/kavita (Config: /kavita/config) auf das LinuxServer.io-Image (Config: /config) führt zu einer leeren Datenbank. Volume-Mount in der compose.yaml anpassen und Backup einspielen.
5. Wechsel von nightly auf latest nicht möglich: Fehlermeldung zu Datenbankmigrationen beim Start. Backup erstellen, auf den nächsten stabilen Release warten oder bei nightly bleiben.
6. ARM32-Fehler (version GLIBC_2.34 not found): Neuere Kavita-Builds benötigen GLIBC 2.34+, das offizielle Image basiert auf Ubuntu Focal mit GLIBC 2.31. Lösung: Kavita nativ installieren oder auf arm64 upgraden.
7. Dateirechte-Probleme (leere Bibliotheken trotz korrektem Pfad): Das offizielle Image läuft als root – Dateirechte sind in der Regel kein Problem. Beim LinuxServer.io-Image PUID und PGID in der .env auf den Besitzer der Mediendateien setzen.
8. OPDS-URL zeigt doppelten Slash (/kavita//api/opds/): Bekannter Anzeige-Bug bei konfigurierter BaseURL. Die tatsächliche OPDS-URL funktioniert trotzdem korrekt.

Häufige Fragen

Brauche ich eine externe Datenbank (PostgreSQL oder MySQL)?

Nein. Kavita verwendet eine eingebettete SQLite-Datenbank, die automatisch im Config-Verzeichnis (/kavita/config) angelegt wird. Ein separater Datenbankcontainer ist weder nötig noch vorgesehen.

Welches Image soll ich nehmen – ghcr.io oder Docker Hub?

Beide sind offiziell und inhaltlich identisch. ghcr.io/kareadita/kavita ist die kanonische Quelle (GitHub Container Registry, vom Kavita-Projekt selbst gepflegt). jvmilazz0/kavita ist der offizielle Docker-Hub-Mirror mit über 5 Millionen Pulls. Empfehlung: Die GHCR-Variante bevorzugen, weil Docker Hub Ratenlimits beim Image-Pull haben kann.

Wie verbinde ich meinen E-Reader per OPDS?

Nach dem ersten Login in der Web-UI unter Einstellungen > Benutzerprofil die persönliche OPDS-URL kopieren. Das Format lautet http://<host>:5000/api/opds/<api-key>. Diese URL direkt in die OPDS-App (z. B. KOReader, Moon+ Reader, Panels, Suwatte) eintragen – kein separates Passwort nötig, da der API-Key die Authentifizierung übernimmt.

Kann ich mehrere Medienbibliotheken einbinden?

Ja, beliebig viele. Ergänze in der compose.yaml weitere Volume-Einträge, z. B. ${NOVELS_PATH:-./novels}:/novels. Nach einem docker compose up -d kannst du den neuen Pfad in der Web-UI als Bibliotheksquelle hinzufügen.

Wie funktioniert das Update?

Mit docker compose pull && docker compose up -d zieht Docker das aktuelle Image, erstellt den Container neu und startet ihn. Die Datenbank und alle Einstellungen im Config-Verzeichnis bleiben erhalten. Vorher ein Backup des kavita-config-Ordners ist empfohlen.

Unterstützt Kavita Single Sign-On?

Ja. Kavita unterstützt OIDC-Authentifizierung (OpenID Connect) für Single Sign-On. Die Konfiguration erfolgt in den Admin-Einstellungen der Web-UI. Passende SSO-Lösungen findest du in der Anleitung Single Sign-On für den Self-Hosted-Stack.

Was passiert, wenn ich den Container lösche?

Solange das Config-Verzeichnis (kavita-config) auf dem Host erhalten bleibt, bleiben Datenbank, Einstellungen, Benutzer und Bibliothekskonfiguration intakt. Du kannst den Container jederzeit neu erstellen, ohne Daten zu verlieren.

Fazit

Kavita ist einer der unkompliziertesten Self-Hosted-Dienste überhaupt: kein externer Datenbankcontainer, keine erzwungenen Umgebungsvariablen, sauberes Setup über den Browser-Wizard. Die Kombination aus browserbasiertem Reader, OPDS-Support für echte E-Reader-Hardware und rollenbasierter Benutzerverwaltung macht es zur ersten Wahl für alle, die ihre Comic-, Manga- oder eBook-Sammlung im Heimnetz zugänglich machen wollen. Der Beta-Status bis Version 1.0.0 bedeutet in der Praxis vor allem: Backups machen, bevor man updatet – das gilt aber für jeden Self-Hosted-Dienst. Wer eine reine eBook-Bibliothek mit Kindle-Sync bevorzugt, schaut sich als Alternative Calibre-Web mit Docker an.

Weiterführende Anleitungen und Quellen

1. Docker und Docker Compose auf Linux installieren (Ubuntu/Debian)
2. Calibre-Web mit Docker installieren: Web-Oberfläche für die eBook-Bibliothek
3. Jellyfin mit Docker: eigener Media-Server ohne Abo
4. Caddy als Reverse Proxy einrichten: Anfänger-Anleitung mit automatischem HTTPS
5. Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only

Offizielle Quellen: Kavita Wiki – Docker Installation · GitHub – Kareadita/Kavita