---
title: "LinkWarden mit Docker installieren: Self-hosted kollaborativer Bookmark-Manager mit Webarchivierung"
date: 2026-07-05T07:33:53+02:00
modified: 2026-11-11T09:33:05+01:00
category: docker
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/linkwarden-docker-bookmark-archiv
reading_time: 10
personalize_url: "https://s-edv.com/anleitungen/linkwarden-docker-bookmark-archiv#path={path}&user={user}&domain={domain}&email={email}&smtp_user={smtp_user}&smtp_host={smtp_host}"
variables:
  - name: path
    label: "Pfad"
    default: "/opt/linkwarden"
  - name: user
    label: "Benutzername"
    default: "ihrbenutzer"
  - name: nextauth_secret
    label: "NEXTAUTH SECRET (48 Zeichen)"
    generated_in_browser: true
  - name: domain
    label: "Ihre Domain"
    default: "links.meinedomain.tld"
  - name: postgres_password
    label: "PostgreSQL-Passwort (48 Hex-Zeichen)"
    generated_in_browser: true
  - name: meili_master_key
    label: "MeiliSearch Master-Key (48 Zeichen)"
    generated_in_browser: true
  - name: email
    label: "E-Mail-Adresse"
    default: "noreply@meinedomain.tld"
  - name: smtp_user
    label: "SMTP-Benutzer"
    default: "user"
  - name: smtp_pass
    label: "SMTP-Passwort"
    default: "pass"
  - name: smtp_host
    label: "SMTP-Server"
    default: "smtp.meinedomain.tld"
---

# LinkWarden mit Docker installieren: Self-hosted kollaborativer Bookmark-Manager mit Webarchivierung

## 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 |
| --- | --- | --- |
| `{{path}}` | Pfad | `/opt/linkwarden` |
| `{{user}}` | Benutzername | `ihrbenutzer` |
| `{{nextauth_secret}}` | NEXTAUTH SECRET (48 Zeichen) | wird im Browser des Lesers zufällig erzeugt |
| `{{domain}}` | Ihre Domain | `links.meinedomain.tld` |
| `{{postgres_password}}` | PostgreSQL-Passwort (48 Hex-Zeichen) | wird im Browser des Lesers zufällig erzeugt |
| `{{meili_master_key}}` | MeiliSearch Master-Key (48 Zeichen) | wird im Browser des Lesers zufällig erzeugt |
| `{{email}}` | E-Mail-Adresse | `noreply@meinedomain.tld` |
| `{{smtp_user}}` | SMTP-Benutzer | `user` |
| `{{smtp_pass}}` | SMTP-Passwort | `pass` |
| `{{smtp_host}}` | SMTP-Server | `smtp.meinedomain.tld` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/linkwarden-docker-bookmark-archiv#path=%2Fsrv%2Fdaten&user=admin&domain=cloud.example.com&email=admin%40example.com&smtp_user=user&smtp_host=smtp.meinedomain.tld

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.

Gespeicherte Links führen oft Monate später ins Leere. **LinkWarden** archiviert jeden Bookmark automatisch als Screenshot, PDF und Single-File-HTML, sodass der Inhalt auch nach dem Abschalten der Originalseite erhalten bleibt. Dazu kommen Mobile-Apps für iOS und Android, Browser-Erweiterungen, eine Leseansicht mit Anmerkungen, optionales KI-Tagging und Anmeldung über zahlreiche SSO-Anbieter. Diese Anleitung zeigt den Betrieb mit Docker Compose auf einem Linux-Host, ob VPS, Heimserver oder NAS.

**Kurzfassung:** Projektordner anlegen, `.env` mit drei Pflicht-Secrets befüllen (NEXTAUTH_SECRET, POSTGRES_PASSWORD, MEILI_MASTER_KEY), `compose.yaml` mit drei Services (linkwarden, postgres, meilisearch) erstellen und mit `docker compose up -d` starten. Die Web-UI ist danach unter Port 3000 erreichbar. Beim ersten Aufruf den Admin-Account registrieren, danach die offene Registrierung in der `.env` sperren. Für den Produktionsbetrieb NEXTAUTH_URL auf die externe HTTPS-Domain anpassen.

## Voraussetzungen

- [ ] **Docker Engine >= 24.x** und **Docker Compose v2** (Befehl: `docker compose`, ohne Bindestrich) auf dem Host installiert (siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)).
- [ ] Linux-Host (x86_64 oder arm64): Ubuntu 22.04/24.04 oder Debian 12 empfohlen; läuft identisch auf einem NAS mit Docker-Unterstützung.
- [ ] **2 CPU-Kerne** und **4 GB RAM** empfohlen, da drei Services parallel laufen (Next.js, PostgreSQL 16, MeiliSearch) und die Archivierung einen Chromium-Browser startet. Im Test belegte der Stack nach dem Start rund 600 MB RAM; mindestens **20 GB freier Speicherplatz** für Archivdaten.
- [ ] Ausgehender HTTP/HTTPS-Zugriff vom Container zum Internet (LinkWarden lädt externe Seiten zur Archivierung herunter).
- [ ] `openssl` oder `python3` zur Generierung sicherer Zufalls-Secrets.
- [ ] Optional: eigene Domain + Reverse Proxy (Nginx Proxy Manager, Traefik oder Caddy) für HTTPS-Betrieb. Wie das funktioniert, erklärt [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten).

## Schritt 1: Projektordner anlegen

Legen Sie einen eigenen Ordner an; Datenbank, Archive und Suchindex liegen als Unterverzeichnisse darin:

```bash
$ mkdir -p {{path}}
$ cd {{path}}
```

Ohne Root-Zugriff geht auch `~/linkwarden`, sofern der Benutzer Schreibrechte hat. `./pgdata`, `./data` und `./meili_data` entstehen beim ersten Start automatisch und gehören danach `root` bzw. dem Postgres-Benutzer (relevant für das Backup in Schritt 8).

> **Prüfen:** `ls -la {{path}}` zeigt das leere Verzeichnis. Der aktuell angemeldete Benutzer ist Eigentümer (`drwxr-xr-x ... {{user}}`).

## Schritt 2: Sichere Secrets generieren

LinkWarden benötigt drei kryptografisch starke Zufalls-Strings. Erzeugen Sie sie mit `openssl`:

```bash
# NEXTAUTH_SECRET (mindestens 32 Zeichen, signiert alle Auth-Sessions)
openssl rand -base64 36

# POSTGRES_PASSWORD (Datenbankpasswort, nur Hex-Zeichen)
openssl rand -hex 24

# MEILI_MASTER_KEY (mindestens 16 Zeichen für MeiliSearch-Produktion)
openssl rand -base64 36
```

Notieren Sie alle drei Ausgaben für die `.env`. Alternativ: `python3 -c 'import secrets; print(secrets.token_urlsafe(36))'`.

Für das Datenbankpasswort nehmen Sie `-hex` statt `-base64`: Das Passwort landet in der `DATABASE_URL`, und ein Schrägstrich aus der Base64-Ausgabe zerlegt diese Adresse. LinkWarden startet dann in einer Schleife neu (siehe Typische Fehler).

> **Prüfen:** Jeder generierte String ist 48 Zeichen lang. Das Datenbankpasswort besteht nur aus Hex-Zeichen (0 bis 9, a bis f), die beiden anderen Werte aus Groß- und Kleinbuchstaben, Ziffern und meist auch + oder /. Alle drei Werte sind voneinander verschieden.

## Schritt 3: .env-Datei anlegen und konfigurieren

Die `.env`-Datei enthält alle sensitiven Konfigurationswerte. Legen Sie sie im Projektordner an:

Datei: `.env`

```ini
# {{path}}/.env

# --- Pflichtfelder (alle drei MÜSSEN geändert werden!) ---

# Signiert Auth-Sessions; mindestens 32 Zeichen; generiert mit: openssl rand -base64 36
NEXTAUTH_SECRET={{nextauth_secret}}

# Muss exakt das Suffix /api/v1/auth enthalten, sonst schlägt der Login fehl!
# Lokal: http://localhost:3000/api/v1/auth
# Mit Reverse Proxy: https://{{domain}}/api/v1/auth
NEXTAUTH_URL=http://localhost:3000/api/v1/auth

# PostgreSQL-Datenbankpasswort; generiert mit: openssl rand -hex 24
POSTGRES_PASSWORD={{postgres_password}}

# MeiliSearch Master-Key; mindestens 16 Zeichen; generiert mit: openssl rand -base64 36
MEILI_MASTER_KEY={{meili_master_key}}

# --- Optionale Felder ---

# Nach der Erstregistrierung auf true setzen, um offene Registrierung zu sperren
NEXT_PUBLIC_DISABLE_REGISTRATION=false

# Sekunden Wartezeit vor Screenshot/PDF-Capture (Standard: 30)
# AUTOSCROLL_TIMEOUT=30

# Maximale Links pro Benutzer (Standard: 30000)
# MAX_LINKS_PER_USER=30000

# Browser-Archivierung deaktivieren (spart Ressourcen, aber kein Link-Rot-Schutz mehr)
# Früher DISABLE_PRESERVATION
# DISABLE_BROWSER=false
```

Schützen Sie die Datei vor unbefugtem Zugriff:

```bash
$ chmod 600 {{path}}/.env
```

> **Prüfen:** `cat {{path}}/.env` zeigt alle drei Pflichtfelder mit echten Werten (keine Platzhalter mehr). `ls -la {{path}}/.env` zeigt die Berechtigung `-rw-------`.

## Schritt 4: compose.yaml erstellen

Erstellen Sie die `compose.yaml` im Projektordner mit drei Services: LinkWarden-App (Next.js), PostgreSQL 16 und MeiliSearch für die Volltextsuche. Nur Port 3000 wird freigegeben:

Datei: `compose.yaml`

```yaml
# {{path}}/compose.yaml
services:
  postgres:
    image: postgres:16-alpine
    env_file: .env
    restart: always
    volumes:
      - ./pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}

  meilisearch:
    image: getmeili/meilisearch:v1.12.8
    restart: always
    env_file:
      - .env
    volumes:
      - ./meili_data:/meili_data

  linkwarden:
    image: ghcr.io/linkwarden/linkwarden:latest
    env_file: .env
    environment:
      - DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/postgres
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - ./data:/data/data
    depends_on:
      - postgres
      - meilisearch
```

Details: Das offizielle Image liegt auf der **GitHub Container Registry** (`ghcr.io`), nicht auf Docker Hub. MeiliSearch ist bewusst auf `v1.12.8` festgeschrieben, um Breaking Changes zu vermeiden; die offizielle Vorlage verwendet inzwischen `v1.13.3`. `DATABASE_URL` wird im `environment`-Block aus `${POSTGRES_PASSWORD}` zusammengebaut und gehört nicht in die `.env`.

Die folgende Tabelle fasst alle wichtigen Eckdaten des Stacks zusammen:

| Eigenschaft | Wert |
| --- | --- |
| Haupt-Image | ghcr.io/linkwarden/linkwarden:latest (v2.17.0) |
| Datenbank-Image | postgres:16-alpine |
| Suche-Image | getmeili/meilisearch:v1.12.8 |
| Exponierter Port | 3000 (Web-UI und API) |
| Volume: Archivdaten | ./data → /data/data |
| Volume: Datenbank | ./pgdata → /var/lib/postgresql/data |
| Volume: Suchindex | ./meili_data → /meili_data |
| RAM | 4 GB empfohlen |
| Mindest-Speicher | 20 GB für Archivdaten |

> **Prüfen:** `cat {{path}}/compose.yaml` zeigt alle drei Services ohne Syntaxfehler. `docker compose config` (im Projektordner) validiert die Datei und interpoliert die Umgebungsvariablen aus `.env`. Die Ausgabe darf keine Fehler und keine Platzhalter-Werte enthalten.

## Schritt 5: Stack starten

Starten Sie alle drei Services mit einem Befehl:

```bash
$ cd {{path}}
$ docker compose up -d
```

Docker lädt beim ersten Start die Images (im Test rund 3 GB, davon 2,5 GB für LinkWarden); PostgreSQL initialisiert die Datenbank in einigen Sekunden. Da `depends_on` ohne Healthcheck arbeitet, startet LinkWarden eventuell vor der Datenbank. Dann genügt ein Neustart:

```bash
$ docker compose restart linkwarden
```

Prüfen Sie den Status aller Services:

```bash
$ docker compose ps
```

Erwartete Ausgabe (alle Services `Up`):

Ausgabe:

```plaintext
NAME                      IMAGE                                  STATUS    PORTS
linkwarden-linkwarden-1   ghcr.io/linkwarden/linkwarden:latest   Up        0.0.0.0:3000->3000/tcp
linkwarden-postgres-1     postgres:16-alpine                     Up        5432/tcp
linkwarden-meilisearch-1  getmeili/meilisearch:v1.12.8          Up        7700/tcp
```

Bei Problemen helfen die Logs:

```bash
# Alle Services gleichzeitig
docker compose logs -f

# Nur LinkWarden
docker compose logs -f linkwarden
```

> **Prüfen:** `docker compose ps` zeigt alle drei Container im Status `Up`. Ein HTTP-Check bestätigt die Erreichbarkeit:
>
> ```bash
> curl -I http://localhost:3000
> # Erwartete Antwort: HTTP/1.1 200 OK oder HTTP/1.1 302 Found
> ```

## Schritt 6: Admin-Account anlegen und Ersteinrichtung

Öffnen Sie `http://localhost:3000` (bzw. IP/Domain des Servers) und klicken Sie auf „Registrieren“. **Der erste registrierte Benutzer wird automatisch zum Admin**; wählen Sie ein starkes Passwort.

Danach stehen alle Funktionen bereit: Links speichern (manuell oder per Browser-Extension), Collections, Tagging, Reader-View und Volltextsuche via MeiliSearch. Die Archivierung läuft im Hintergrund; je nach Seite und Einstellung (Standard: 30 Sekunden Wartezeit) dauert es einige Momente, bis Screenshot, PDF und HTML-Snapshot verfügbar sind.

Sperren Sie danach die offene Registrierung, damit sich keine unbefugten Benutzer anmelden können:

```bash
# In .env den Wert ändern:
# NEXT_PUBLIC_DISABLE_REGISTRATION=true
# Dann den Container neu starten:
docker compose up -d --force-recreate linkwarden
```

> **Prüfen:** Melden Sie sich mit dem neuen Admin-Account an und speichern Sie einen Test-Link. Nach etwa einer Minute stehen Screenshot, PDF und HTML-Kopie bereit. Versuchen Sie in einem privaten Browser-Fenster, einen zweiten Account zu registrieren: Nach dem Setzen von `NEXT_PUBLIC_DISABLE_REGISTRATION=true` lehnt LinkWarden das mit „Registration is disabled.“ ab.

## Schritt 7: Reverse Proxy und HTTPS (Produktion)

Für den Produktionsbetrieb mit einer eigenen Domain und HTTPS-Zertifikat passen Sie zwei Dinge an:

**1. NEXTAUTH_URL in der .env anpassen:** Der Wert muss die externe HTTPS-Domain samt dem Pflicht-Suffix `/api/v1/auth` enthalten:

Datei: `.env`

```ini
NEXTAUTH_URL=https://{{domain}}/api/v1/auth
```

**2. Reverse Proxy konfigurieren:** Leiten Sie Port 443 auf den Container-Port 3000 weiter. Binden Sie Port 3000 dann nur lokal (`"127.0.0.1:3000:3000"`), damit LinkWarden nicht am Proxy vorbei erreichbar ist. Nginx Proxy Manager, Traefik oder Caddy eignen sich gut dafür. Wie das mit Nginx Proxy Manager am Beispiel einer Synology klappt, erklärt die Anleitung [Nginx Proxy Manager auf der Synology mit Container Manager einrichten: Reverse Proxy und SSL Schritt für Schritt](https://s-edv.com/anleitungen/nginx-proxy-manager-synology-container-manager).

Nach der Änderung der `.env` den LinkWarden-Container neu starten:

```bash
$ docker compose up -d --force-recreate linkwarden
```

> **Prüfen:** Öffnen Sie `https://{{domain}}` im Browser. Das Schloss-Symbol zeigt ein gültiges TLS-Zertifikat. Login und OAuth-Callbacks funktionieren korrekt. Einen Test-Link speichern und nach einigen Sekunden prüfen, ob der Screenshot erscheint.

## Schritt 8: Updates und Backups

Aktuell ist v2.17.0. Mit dem `:latest`-Tag zieht ein Pull-Update die aktuelle Version:

```bash
$ cd {{path}}
$ docker compose pull
$ docker compose up -d
```

Seit 2.17 nimmt ein Konto nach 15 falschen Passwörtern in Folge nur noch alle 25 Sekunden einen Versuch an; die API meldet dann `Too many incorrect passwords. Please try again in 25 seconds.` Laut Release Notes meldet eine Passwortänderung ab 2.17 alle anderen Geräte ab und widerruft Zugriffstokens. Browser-Erweiterung und Integrationen wie Floccus, die ein Zugriffstoken nutzen, melden Sie danach neu an.

Legen Sie **vor jedem Update** ein Backup der drei Datenordner an. Da `./pgdata` und `./meili_data` nach dem ersten Start `root` bzw. dem Postgres-Benutzer gehören, braucht `tar` Root-Rechte:

```bash
# Kurz stoppen, Backup erstellen, wieder starten
docker compose down
sudo tar czf ~/backup-linkwarden-$(date +%Y%m%d).tar.gz \
  {{path}}/pgdata \
  {{path}}/data \
  {{path}}/meili_data
docker compose up -d
```

Für eine automatisierte Backup-Strategie (etwa mit Restic auf ein externes Ziel) empfiehlt sich [Restic Backup auf Linux und Windows einrichten und automatisieren](https://s-edv.com/anleitungen/restic-backup-linux-windows-automatisieren-cron).

> **Prüfen:** Nach dem Update zeigt `docker compose ps` alle Container im Status `Up`. `docker compose logs linkwarden | head -20` enthält keine Fehlermeldungen zu Datenbankmigrationen oder fehlenden Umgebungsvariablen. Das Backup-Archiv ist vorhanden und lesbar: `sudo tar tzf ~/backup-linkwarden-*.tar.gz | head`.

## Troubleshooting / Typische Fehler

**Login schlägt fehl: „Invalid URL“ oder Redirect-Fehler**

NEXTAUTH_URL fehlt das Suffix `/api/v1/auth`. Korrektes Format: `http://HOST:3000/api/v1/auth`. Nach Änderung: `docker compose up -d --force-recreate linkwarden`.

**„Can't reach database server at postgres:5432“**

LinkWarden startete vor PostgreSQL. Fix: `docker compose restart linkwarden`; dauerhaft per Healthcheck in `depends_on`. Wie das geht, zeigt [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root).

**POSTGRES_PASSWORD-Mismatch nach Passwortänderung**

`pgdata` wurde mit dem alten Passwort initialisiert. Passwort in PostgreSQL ändern: `docker compose exec postgres psql -U postgres -c "ALTER USER postgres PASSWORD 'neues_passwort';"`. Alternativ Volume löschen (Datenverlust!) und neu initialisieren.

**MeiliSearch startet im unsicheren Modus**

MEILI_MASTER_KEY fehlt oder ist kürzer als 16 Zeichen. Neuen Key generieren (`openssl rand -base64 36`), in `.env` eintragen und `docker compose up -d --force-recreate meilisearch` ausführen.

**Archivierung schlägt lautlos fehl (Screenshots leer)**

Playwright/Chromium braucht System-Libraries, die das offizielle `ghcr.io`-Image enthält. Bei ARM64 prüfen: `docker inspect ghcr.io/linkwarden/linkwarden:latest | grep -i architecture`.

**./data-Volume falsch gemountet**

Archive liegen im Container unter `/data/data`; der Mount muss `./data:/data/data` lauten (nicht `./data:/data`), sonst gehen Archive beim Neustart verloren.

**NEXTAUTH_URL nach Reverse-Proxy-Umstieg falsch**

Hinter Nginx/Traefik muss `NEXTAUTH_URL` die externe HTTPS-URL sein, sonst schlagen OAuth-Callbacks und Session-Cookies fehl.

**Backup mit tar meldet „Permission denied“**

Die Datenordner gehören `root` (`./data`, `./meili_data`) bzw. dem Postgres-Benutzer mit UID 70 (`./pgdata`). `tar` mit `sudo` ausführen; Eigentümer nicht per `chown` ändern.

**`Error: P1013: The provided database string is invalid. invalid port number in database URL.`**

Das Datenbankpasswort enthält einen Schrägstrich, meist aus `openssl rand -base64`. Er zerlegt die `DATABASE_URL`, LinkWarden startet in einer Schleife neu. Lösung: ein Passwort aus `openssl rand -hex 24`. Ist `./pgdata` schon mit dem alten Passwort angelegt, ändern Sie es zuerst in PostgreSQL (Eintrag POSTGRES_PASSWORD-Mismatch).

## Häufige Fragen

### Kann ich LinkWarden ohne MeiliSearch betreiben?

Ja. Ohne `meilisearch`-Service und `MEILI_MASTER_KEY` nutzt LinkWarden die einfache PostgreSQL-Suche, ohne unscharfe Suche und Relevanzbewertung; für den Einstieg oder schwache Hosts genügt das.

### Wie sperre ich die Registrierung nach der Ersteinrichtung?

`NEXT_PUBLIC_DISABLE_REGISTRATION=true` in der `.env` setzen und `docker compose up -d --force-recreate linkwarden` ausführen. Neue Benutzer lädt dann nur noch der Admin ein.

### Wie viel Speicherplatz brauche ich für Archive?

Pro archiviertem Link (Screenshot, PDF, HTML-Snapshot via Monolith) 1 bis 10 MB je nach Seite; 1.000 Links mit 3 MB ergeben 3 GB. Für Teams mit Tausenden Links eignet sich ein großes Volume oder S3-kompatibles Object Storage (AWS S3, MinIO, Hetzner Object Storage) über die `SPACES_*`-Variablen.

### Wie konfiguriere ich KI-Tagging?

LinkWarden unterstützt mehrere KI-Provider für automatisches Tagging: lokal via Ollama (`NEXT_PUBLIC_OLLAMA_ENDPOINT_URL`), OpenAI (`OPENAI_API_KEY`) oder Anthropic (`ANTHROPIC_API_KEY`). Für datenschutzbewusste Teams ist Ollama mit einem lokalen Modell naheliegend. Wie Sie Ollama als Docker-Container betreiben, erklärt [Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud](https://s-edv.com/anleitungen/ollama-open-webui-docker-lokales-llm).

### Wie aktiviere ich E-Mail und Passwort-Reset?

In der `.env` setzen und Container neu starten: `NEXT_PUBLIC_EMAIL_PROVIDER=true`, `EMAIL_FROM={{email}}`, `EMAIL_SERVER=smtp://{{smtp_user}}:{{smtp_pass}}@{{smtp_host}}:587` und `BASE_URL=https://{{domain}}`. Ohne diese Werte funktioniert der Passwort-Reset nicht.

### Wie stelle ich auf SSO (Google, GitHub, Authentik) um?

LinkWarden unterstützt über 60 SSO-Provider via NextAuth.js. Fügen Sie die entsprechenden Provider-Variablen in die `.env` ein, z. B. für Google: `GOOGLE_CLIENT_ID` und `GOOGLE_CLIENT_SECRET`. Die vollständige Liste der unterstützten Provider findet sich in der offiziellen [LinkWarden Environment Variables Referenz](https://docs.linkwarden.app/self-hosting/environment-variables).

## Fazit

Die Installation ist dank des offiziellen Images unkompliziert, verlangt aber sorgfältig gesetzte Pflicht-Secrets; häufigster Stolperstein ist das `NEXTAUTH_URL`-Suffix. MeiliSearch liefert vollwertige Volltextsuche, lässt sich aber weglassen.

## Weiterführende Anleitungen und Quellen

1. [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
2. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
3. [Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud](https://s-edv.com/anleitungen/ollama-open-webui-docker-lokales-llm)
4. [Restic Backup auf Linux und Windows einrichten und automatisieren](https://s-edv.com/anleitungen/restic-backup-linux-windows-automatisieren-cron)
5. [Paperless-ngx mit Docker: papierloses Büro mit OCR](https://s-edv.com/anleitungen/paperless-ngx-dokumentenverwaltung-ocr-docker)
6. [Firefly III mit Docker installieren: Self-hosted Finanzverwaltung](https://s-edv.com/anleitungen/firefly-iii-docker-finanzverwaltung)

Offizielle Quellen: [LinkWarden Installationsdokumentation](https://docs.linkwarden.app/self-hosting/installation) | [LinkWarden auf GitHub](https://github.com/linkwarden/linkwarden) | [Environment Variables Referenz](https://docs.linkwarden.app/self-hosting/environment-variables)

## Passende Anleitungen auf S-EDV

1. [PostgreSQL pg_dump und pg_restore: Anleitung für Backup und Migration per Kommandozeile](https://s-edv.com/anleitungen/postgresql-pg-dump-pg-restore-backup-migration)
2. [netcup Local Block Storage bestellen, einrichten und unter Linux einbinden](https://s-edv.com/anleitungen/netcup-local-block-storage-bestellen-linux-einbinden)
