Karakeep installieren: Self-hosted Lesezeichen mit Docker

In diesem Blogpost wollen wir uns Karakeep genauer ansehen. Karakeep ist eine vielversprechende Bookmark-App, die es sich zum Ziel gesetzt hat, Lesezeichen für alles zu ermöglichen. Egal ob Webseiten, Notizen, Bilder oder sogar RSS-Feeds – Karakeep möchte deine zentrale Anlaufstelle werden.

Wir werden Karakeep gemeinsam auf einem Server installieren, es für den externen Zugriff absichern und sogar einige der optionalen KI-Funktionen erkunden.

Was ist Karakeep?

Karakeep ist ein Open-Source Lesezeichen-Manager, der darauf ausgelegt ist, mehr als nur URLs zu speichern. Du kannst:

• Webseiten speichern und archivieren (Full Page Archive).
• Notizen und Bilder hinzufügen.
• Automatisch Tags durch KI vergeben lassen.
• Inhalte per KI zusammenfassen lassen.
• RSS-Feeds abonnieren und lesen.
• Lesezeichen aus Browsern oder anderen Diensten importieren.
• Über Browser-Erweiterungen und mobile Apps schnell Inhalte hinzufügen.

Da es sich um eine selbst gehostete Anwendung handelt, behältst du die volle Kontrolle über deine Daten.

Glossar: Wichtige Begriffe und Technologien

Voraussetzungen

Bevor wir starten, stelle sicher, dass du Folgendes hast:

1. Einen Server: Das kann ein Homeserver oder ein öffentlicher VPS sein. Ich nutze für diese Anleitung einen VPS bei Hetzner (Affiliate-Link: Als Neukunde erhältst du mit diesem Link 20€ Startguthaben). Auf dem Server sollte ein Linux-Betriebssystem laufen (z.B. Ubuntu).
2. (Optional, aber empfohlen) Eine Domain: Wenn du Karakeep sicher und einfach über das Internet erreichen möchtest, ist eine Domain, die auf die IP-Adresse deines Servers zeigt, sehr sinnvoll.

Karakeep mit Docker Compose installieren

Die Installation von Karakeep ist dank Docker Compose relativ unkompliziert. Karakeep wird aktiv weiterentwickelt, deshalb lohnt sich ein Blick in die offizielle Karakeep-Dokumentation, falls sich Details ändern.

0. Docker und Docker Compose installieren

Zuerst verbinden wir uns per SSH mit unserem Server und stellen sicher, dass Docker installiert ist. Falls nicht, müssen Docker und Docker Compose installiert werden. Folgt am besten der offiziellen Dokumentation.

Für Ubuntu führt ihr aus:

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Und dann:

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

1. Verzeichnis erstellen und compose.yaml anlegen

Wir erstellen ein Verzeichnis für Karakeep.

mkdir karakeep
cd karakeep

Als Nächstes erstellen wir die compose.yaml-Datei. Diese Datei beschreibt, wie unsere Karakeep-Anwendung mit Docker gestartet werden soll.

nano compose.yaml

Kopiere folgenden Inhalt in die Datei:

services:
    web:
        image: ghcr.io/karakeep-app/karakeep:${KARAKEEP_VERSION}
        container_name: karakeep_web # Wird später für den Reverse Proxy benötigt
        restart: unless-stopped
        ports:
            - "{{port}}:3000" # Host-Port:Container-Port (kann angepasst werden)
        env_file:
            - .env
        environment:
            MEILI_ADDR: http://meilisearch:7700
            BROWSER_WEB_URL: http://chrome:9222
        volumes:
            - ./data:/data # Bind Mount für Karakeep-Daten
        depends_on:
            - chrome
            - meilisearch
        networks:
            - internal

    chrome:
        image: ghcr.io/karakeep-app/karakeep-chrome:release
        restart: unless-stopped
        init: true
        command:
            - --disable-gpu
            - --disable-dev-shm-usage
            - --hide-scrollbars
            - --disable-blink-features=AutomationControlled
            - --window-size=1440,900
        networks:
            - internal

    meilisearch:
        image: getmeili/meilisearch:v1.55.0
        restart: unless-stopped
        env_file:
            - .env
        environment:
            MEILI_NO_ANALYTICS: "true"
        volumes:
            - ./meilisearch_data:/meili_data
        networks:
            - internal

networks:
    internal:
        external: false

Wichtige Hinweise zur compose.yaml:

• Image-Version: Die Version von Karakeep steht nicht in der Datei, sondern in der .env (KARAKEEP_VERSION). Das Image karakeep-chrome gibt es nur mit dem Tag release, das Karakeep-Projekt pflegt es mit. Die Meilisearch-Version habe ich auf v1.55.0 festgelegt, wie im offiziellen Beispiel.
• Volumes: Ich verwende hier Bind-Mounts (./data und ./meilisearch_data). Das bedeutet, die Daten werden in Unterordnern relativ zu deiner compose.yaml gespeichert. Erstelle diese Ordner:
  Terminalbash

  mkdir data
  mkdir meilisearch_data

• Ports: {{port}}:3000 bedeutet, dass Karakeep auf Port 3005 deines Servers erreichbar sein wird und Anfragen an Port 3000 im Container weiterleitet. Wenn der Port belegt ist, wähle einen anderen (z.B. 3006:3000).
• Netzwerke: Beide Dienste hängen am Netzwerk internal. Für den Reverse Proxy erweitern wir das später.

Speichere die Datei (in nano mit Strg+X, dann Y und Enter).

2. .env-Datei erstellen

Die .env-Datei enthält Konfigurationsvariablen.

nano .env

Füge folgenden Inhalt ein und passe die Werte an:

KARAKEEP_VERSION=0.34.1
DATA_DIR=/data
MEILI_MASTER_KEY=DEIN_SUPER_GEHEIMER_SCHLUESSEL_1
NEXTAUTH_SECRET=DEIN_SUPER_GEHEIMER_SCHLUESSEL_2
NEXTAUTH_URL=http://{{server_ip}}:{{port}}

Wichtig: Ersetze DEIN_SUPER_GEHEIMER_SCHLUESSEL_1 und _2 durch lange, zufällige Zeichenketten. Du kannst diese z.B. so generieren:

openssl rand -base64 36 | tr -dc 'A-Za-z0-9'

Führe den Befehl zweimal aus und kopiere die Ergebnisse in die .env. Die aktuelle Version von Karakeep findest du auf GitHub. Vermeide latest oder release, weil sich die Version dann beim nächsten Neustart unbemerkt ändern kann.

NEXTAUTH_URL ist die Adresse, unter der du Karakeep im Browser aufrufst. Wenn du später einen Reverse Proxy mit Domain einrichtest, änderst du sie dort.

Speichere die Datei.

3. Karakeep-Container starten

Jetzt können wir Karakeep starten:

sudo docker compose up -d

Docker wird nun die Images herunterladen und die Container im Hintergrund (-d) starten. Das kann beim ersten Mal etwas dauern.

Du kannst den Status der Container überprüfen:

sudo docker compose ps
# Oder die Logs ansehen:
sudo docker compose logs -f
# Oder die Ressourcennutzung:
sudo docker compose stats

Im Normalfall sollten die Container nach kurzer Zeit laufen. Der Webserver meldet healthy, sobald die Datenbank-Migration durch ist:

sudo docker compose ps --format 'table {{.Service}}\t{{.Image}}\t{{.Status}}'

SERVICE       IMAGE                                          STATUS
chrome        ghcr.io/karakeep-app/karakeep-chrome:release   Up 16 seconds
meilisearch   getmeili/meilisearch:v1.55.0                   Up 16 seconds
web           ghcr.io/karakeep-app/karakeep:0.34.1           Up 16 seconds (healthy)

Die Logs können bei Problemen sehr hilfreich sein. Beim ersten Start kann Meilisearch etwas Zeit für die Indizierung benötigen.

4. Erster Zugriff und Admin-Konto erstellen

Öffne deinen Webbrowser und gib die IP-Adresse mit dem Port aus der compose.yaml ein, also http://{{server_ip}}:{{port}}.

Du solltest den Anmeldebildschirm von Karakeep sehen.

1. Klicke auf “Sign up”.
2. Erstelle dein Benutzerkonto. Der erste Benutzer wird automatisch zum Administrator.

Nach der Anmeldung siehst du das leere Dashboard. Oben links legst du Lesezeichen an: Füge einen Link ein und klicke auf “Save”. Karakeep holt die Seite im Hintergrund mit dem Chrome-Container, speichert Titel und Vorschaubild und legt eine Kopie an.

Die Sprache stellst du über dein Benutzer-Menü (Avatar oben rechts) um: “User Settings” -> “User Info” -> “Interface Language” -> “German”.

Grundkonfiguration und erste Schritte

Nach der erfolgreichen Installation und dem ersten Login empfehle ich, ein paar grundlegende Einstellungen vorzunehmen.

Registrierungen deaktivieren (DISABLE_SIGNUPS)

Sobald du dein Admin-Konto erstellt hast, ist es ratsam, die öffentliche Registrierung zu deaktivieren, es sei denn, du möchtest, dass sich jeder anmelden kann.

1. Öffne die .env-Datei:
   Terminalbash

   nano .env

2. Füge folgende Zeile hinzu:
   .env

   DISABLE_SIGNUPS=true

3. Speichere die Datei und starte Karakeep neu, damit die Änderungen wirksam werden:
   Terminalbash

   sudo docker compose down
   sudo docker compose up -d

   Wenn du dich nun abmeldest und die Seite /signup aufrufst, steht dort Signups are currently disabled. Weitere Benutzer legst du als Administrator unter “Admin Settings” -> “Users List” selbst an.

OCR-Sprachen festlegen (OCR_LANGS)

Wenn du möchtest, dass Karakeep Text in Bildern erkennt (OCR), kannst du die Sprachen dafür festlegen.

1. Öffne die .env-Datei.
2. Füge hinzu (z.B. für Englisch und Deutsch):
   .env

   OCR_LANGS=eng,deu

3. Speichern und Karakeep neu starten:
   Terminalbash

   sudo docker compose down
   sudo docker compose up -d

(Optional) Erweiterte Funktionen mit KI

Karakeep bietet optionale KI-Funktionen wie automatisches Tagging und Zusammenfassungen. Standardmäßig ist dies nicht aktiv. Wenn du einen eigenen API-Key (z.B. von OpenAI oder OpenRouter) verwenden möchtest:

Ich nutze gerne OpenRouter, da es mir Zugriff auf verschiedene Modelle gibt.

1. API-Key besorgen: Erstelle einen Account bei OpenRouter.ai und generiere einen API-Key. Lade ggf. Guthaben auf.
2. .env-Datei anpassen:
   Terminalbash

   nano .env

   Füge folgende Variablen hinzu/ändere sie:
   .env

   OPENAI_API_KEY=DEIN_OPENROUTER_API_KEY # Dein Key von OpenRouter
   OPENAI_BASE_URL=https://openrouter.ai/api/v1
   INFERENCE_TEXT_MODEL=google/gemini-3.5-flash-lite
   INFERENCE_IMAGE_MODEL=google/gemini-3.5-flash-lite

   Eine Liste der verfügbaren Modelle findest du auf der OpenRouter-Webseite. Die Modellnamen ändern sich schnell. Für den Bildmodus muss das Modell Bilder verstehen.
3. Karakeep neu starten:
   Terminalbash

   sudo docker compose down
   sudo docker compose up -d

Wenn du nun Lesezeichen hinzufügst, sollten Tags automatisch generiert werden. Du kannst auch versuchen, Artikel zusammenfassen zu lassen. Die Nutzung der API kostet Geld, aber bei moderater Nutzung und günstigen Modellen (wie Gemini Flash) halten sich die Kosten im Rahmen (oft unter einem Cent pro Anfrage). Kostenlose Modelle gibt es auch, sie sind jedoch unzuverlässiger (nicht vom Ergebnis, sondern vom rate limit usw.)

RSS-Feeds integrieren

Unter “User Settings” -> “RSS Subscriptions” kannst du RSS-Feeds hinzufügen (z.B. von deinem Lieblingsblog https://deployn.de/rss.xml). Karakeep wird dann die Artikel importieren, und du kannst sie direkt in der App lesen und verwalten – optional auch automatisch taggen lassen!

Reverse Proxy mit Caddy einrichten (HTTPS und Domain)

Um Karakeep sicher über eine Domain mit HTTPS zu erreichen (z.B. https://{{domain}}), richten wir einen Reverse Proxy mit Caddy ein. Caddy kümmert sich automatisch um SSL-Zertifikate von Let’s Encrypt.

1. Vorbereitung Karakeep

a) Container-Namen und Netzwerke in Karakeep compose.yaml anpassen:

Wir haben container_name: karakeep_web bereits in der compose.yaml von Karakeep definiert. Nun passen wir die Netzwerkeinstellungen an. Öffne die compose.yaml von Karakeep:

cd ~/karakeep # Stelle sicher, dass du im Karakeep-Verzeichnis bist
nano compose.yaml

Entferne die Port-Freigabe und hänge den web-Service an das externe Netzwerk proxy:

services:
    web:
        image: ghcr.io/karakeep-app/karakeep:${KARAKEEP_VERSION}
        container_name: karakeep_web # Wichtig für Caddy
        restart: unless-stopped
        ports:
            - "{{port}}:3000"
        # ... env_file, environment, volumes und depends_on bleiben gleich
        networks:
            - internal
            - proxy

networks:
    internal:
        external: false
    proxy:
        external: true

Die Dienste chrome und meilisearch bleiben unverändert.

Speichere die Änderungen.

b) NEXTAUTH_URL in .env anpassen:

Öffne die .env-Datei von Karakeep:

nano .env

Ändere NEXTAUTH_URL auf deine zukünftige HTTPS-Domain:

NEXTAUTH_URL=https://{{domain}}

Speichere die Datei.

2. Docker-Netzwerk für den Proxy erstellen

Dieses Netzwerk wird von Caddy und Karakeep gemeinsam genutzt.

sudo docker network create proxy

(Falls es schon existiert, ist das okay.)

3. Caddy einrichten

Wir erstellen ein separates Verzeichnis für Caddy.

cd ~ # Gehe ins Home-Verzeichnis
mkdir caddy
cd caddy
mkdir data config # Unterordner für Caddy-Daten und -Konfiguration

a) Caddy compose.yaml erstellen:

nano compose.yaml

Inhalt:

services:
    caddy:
        image: caddy:2
        container_name: caddy
        restart: unless-stopped
        ports:
            - "80:80"
            - "443:443"
            - "443:443/udp"
        volumes:
            - ./Caddyfile:/etc/caddy/Caddyfile # Konfigurationsdatei
            - ./data:/data # Für Zertifikate und andere Daten
            - ./config:/config # Für Caddy-Konfiguration
        networks:
            - proxy # Caddy dem Proxy-Netzwerk zuweisen

networks:
    proxy:
        external: true

Speichere die Datei.

b) Caddyfile erstellen:

Dies ist die Konfigurationsdatei für Caddy.

nano Caddyfile

Inhalt:

{{domain}} {
    encode gzip

    # Weiterleitung an den Karakeep Web-Container über das Docker-Netzwerk
    # karakeep_web ist der container_name aus der Karakeep compose.yaml
    # 3000 ist der interne Port von Karakeep im Container
    reverse_proxy karakeep_web:3000
}

Speichere die Datei. Stelle sicher, dass deine Domain per DNS A-Record auf die IP-Adresse deines Servers zeigt!

4. Caddy und Karakeep (neu) starten

Zuerst starten wir Caddy:

cd ~/caddy # Ins Caddy-Verzeichnis wechseln
sudo docker compose up -d

Dann starten wir Karakeep neu, damit es die Netzwerkänderungen übernimmt:

cd ~/karakeep # Ins Karakeep-Verzeichnis wechseln
sudo docker compose down # Stoppt und entfernt die alten Container
sudo docker compose up -d # Startet Karakeep mit der neuen Konfiguration

5. Zugriff über HTTPS-Domain

Warte einen Moment, bis Caddy das SSL-Zertifikat ausgestellt hat. Du solltest Karakeep nun unter https://{{domain}} erreichen können. Deine Lesezeichen und dein Login bleiben erhalten, weil die Daten im Ordner data liegen.

Karakeep aktualisieren

Um Karakeep zu aktualisieren:

1. Schau in den Karakeep-Releases nach einer neuen Version und lies die Release Notes.
2. Ändere in der .env die Zeile KARAKEEP_VERSION auf die neue Version.
3. Ziehe die neuen Images und starte neu:
   Terminalbash

   cd ~/karakeep
   sudo docker compose pull
   sudo docker compose up -d

   Docker ersetzt nur die Container, deren Image sich geändert hat. Die Datenbank-Migration läuft beim Start automatisch.

Fazit

Karakeep ist ein mächtiger und flexibler Lesezeichen-Manager, der dank Docker und Docker Compose relativ einfach selbst gehostet werden kann. Mit einem Reverse Proxy wie Caddy wird der Zugriff sicher und benutzerfreundlich. Die optionalen KI-Funktionen und die RSS-Integration runden das Paket ab und machen Karakeep zu einer zentralen Anlaufstelle.

Benutzt du bereits einen selbstgehosteten Lesezeichen-Manager? Welche Funktionen sind dir dabei besonders wichtig? Schreib es gerne in die Kommentare!

FAQ