Karakeep auf dem Server installieren: Dein eigener Lesezeichen-Manager 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. Da sich Karakeep noch in der Entwicklung befindet (Beta-Status), ist es ratsam, immer die offizielle Karakeep-Dokumentation im Auge zu behalten, da sich Details ändern können.

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. Achte darauf, die Image-Version anzupassen!

services:
  web:
    image: ghcr.io/karakeep-app/karakeep:0.24.1 # Überprüfe die aktuelle Version auf GitHub!
    container_name: karakeep_web # Wird später für den Reverse Proxy benötigt
    restart: unless-stopped
    ports:
      - "3005:3000" # Host-Port:Container-Port (kann angepasst werden)
    env_file:
      - .env
    volumes:
      - ./data:/data # Bind Mount für Karakeep-Daten
    depends_on:
      - chrome
      - meilisearch
    networks: # Wird später für den Reverse Proxy benötigt
      - internal 
      # - proxy # Vorerst auskommentiert, später hinzufügen

  chrome:
    image: gcr.io/zenika-hub/alpine-chrome:123
    restart: unless-stopped
    command:
      - --no-sandbox
      - --disable-gpu
      - --disable-dev-shm-usage
      - --remote-debugging-address=0.0.0.0
      - --remote-debugging-port=9222
      - --hide-scrollbars
    networks:
      - internal

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

networks:
  internal:
    external: false
  # proxy: # Vorerst auskommentiert
  #   external: true # Vorerst auskommentiert

Wichtige Hinweise zur compose.yaml:

• Image-Version: Ich habe 0.24.1 verwendet. Gehe zu Karakeep GitHub Packages und suche die neueste stabile Version (vermeide latest, da dies zu unerwarteten Updates führen kann). Passe auch ggf. die Version für web und chrome an.
• 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:

  mkdir data
  mkdir meilisearch_data

• Ports: 3005:3000 bedeutet, dass Karakeep auf Port 3005 deines Servers erreichbar sein wird und Anfragen an Port 3000 im Container weiterleitet. Wenn Port 3005 belegt ist, wähle einen anderen (z.B. 3006:3000).
• Netzwerke: Die proxy Netzwerkdefinitionen sind vorerst auskommentiert. Wir aktivieren sie später für den Reverse Proxy.

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:

MEILI_MASTER_KEY=DEIN_SUPER_GEHEIMER_SCHLUESSEL_1
NEXTAUTH_SECRET=DEIN_SUPER_GEHEIMER_SCHLUESSEL_2
NEXTAUTH_URL=http://localhost:3000

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

Führe den Befehl zweimal aus und kopiere die Ergebnisse in die .env

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. 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.

Du solltest den Anmeldebildschirm von Karakeep sehen.

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

Melde dich an und erkunde die Oberfläche! Du kannst die Sprache in den Benutzereinstellungen (Zahnrad-Symbol oben rechts -> User Settings -> Interface) auf Deutsch umstellen.

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:

   nano .env

2. Füge folgende Zeile hinzu:

   DISABLE_SIGNUPS=true

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

   sudo docker compose down
   sudo docker compose up -d

Wenn du dich nun abmeldest und versuchst, dich neu zu registrieren (“Sign up”), solltest du eine Meldung sehen, dass Registrierungen deaktiviert sind.

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):

   OCR_LANGS=eng,deu

3. Speichern und Karakeep neu starten:

   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:

   nano .env

   Füge folgende Variablen hinzu/ändere sie:

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

   Eine Liste der verfügbaren Modelle findest du auf der OpenRouter-Webseite.
3. Karakeep neu starten:

   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” 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://karakeep.deinedomain.de), 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 aktiviere das proxy-Netzwerk für den web-Service:

services:
  web:
    image: ghcr.io/karabot/karakeep/web:0.24.1
    container_name: karakeep_web # Wichtig für Caddy
    restart: unless-stopped
    # ports: # Diese Zeile auskommentieren oder löschen
    #   - "3005:3000" # Diese Zeile auskommentieren oder löschen
    env_file:
      - .env
    volumes:
      - ./data:/data
    depends_on:
      - chrome
      - meilisearch
    networks: # Netzwerke anpassen
      - internal
      - proxy # Dieses Netzwerk hinzufügen

  chrome:
    image: ghcr.io/karabot/karakeep/chrome:0.24.1
    restart: unless-stopped
    shm_size: '1gb'
    cap_add:
      - SYS_ADMIN
    networks: # Nur internal
      - internal

  meilisearch:
    image: getmeili/meilisearch:v1.7
    restart: unless-stopped
    environment:
      - MEILI_ENV=production
      - MEILI_MASTER_KEY=${MEILISEARCH_MASTER_KEY}
    volumes:
      - ./meilisearch_data:/meili_data
    networks: # Nur internal
      - internal

networks:
  internal:
    driver: bridge
  proxy: # Diese Sektion aktivieren
    external: true # Bedeutet, das Netzwerk wird außerhalb dieser Compose-Datei verwaltet

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://karakeep.deinedomain.de

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:latest
    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 (ersetze karakeep.deinedomain.de mit deiner Domain und gib deine E-Mail-Adresse an):

karakeep.deinedomain.de {
    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 (z.B. karakeep.deinedomain.de) 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://karakeep.deinedomain.de erreichen können.

Karakeep aktualisieren

Um Karakeep zu aktualisieren:

1. Überprüfe die Karakeep GitHub Packages auf eine neue Version.
2. Stoppe die laufenden Karakeep-Container:

   cd ~/karakeep
   sudo docker compose down

3. Bearbeite deine compose.yaml und ändere die Image-Tags für web und chrome auf die neue Version.
4. Ziehe die neuen Images:

   sudo docker compose pull

5. Starte Karakeep neu:

   sudo docker compose up -d

Lies immer die Release Notes, falls es Breaking Changes gibt!

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.

Ich hoffe, diese Anleitung hat dir geholfen! Benutzt du bereits einen selbstgehosteten Lesezeichen-Manager? Welche Funktionen sind dir dabei besonders wichtig? Schreib es gerne in die Kommentare!

FAQ