Wer im Team strukturiertes Wissen aufbauen und pflegen möchte, ohne sich von Notion oder Confluence in die Cloud treiben zu lassen, kommt an Outline kaum vorbei. Das auf React und Node.js basierende Open-Source-Wiki überzeugt mit Echtzeit-Kollaboration an Dokumenten, verschachtelten Seiten, Markdown-Editor, Volltext-Suche und feingranularer Zugriffssteuerung — alles selbstgehostet auf dem eigenen Synology NAS. Was Outline von klassischen Wikis wie BookStack unterscheidet: statt einer starren Buch-Kapitel-Struktur gibt es frei verlinkbare, verschachtelte Dokumente im Notion-Stil — und statt eigenem Nutzerlogin wird bewusst auf einen externen Identity Provider wie Keycloak gesetzt. Genau diese Kombination macht Outline besonders interessant für KMU, die SSO bereits betreiben oder planen.

Voraussetzungen

Synology NAS mit Intel/AMD-CPU (x86_64) — z. B. DS923+, DS723+, DS1522+; ARM-Geräte werden vom offiziellen Image nicht unterstützt
DSM 7.2 oder neuer mit installiertem Container Manager
Mindestens 4 GB RAM im NAS (empfohlen), davon 2 GB für den Outline-Stack verfügbar
Mindestens 10 GB freier Speicher auf dem NAS-Volume
Eigene Domain mit gültigem SSL-Zertifikat (Let's Encrypt oder Wildcard) und erreichbarem Synology Reverse Proxy
Laufende Keycloak-Instanz mit einem konfigurierten Realm — falls noch nicht vorhanden: Keycloak auf dem Synology NAS installieren
SSH-Zugang zum NAS für die Secret-Generierung (Anleitung: SSH auf dem Synology NAS aktivieren und verbinden)
Optional: SMTP-Zugangsdaten für E-Mail-Benachrichtigungen

Eckdaten auf einen Blick

Parameter	Wert
Docker-Image (empfohlen)	docker.getoutline.com/outlinewiki/outline:latest
Aktueller Stable-Tag	1.8.2 (Stand Juni 2026) — für Produktion pinnen: outlinewiki/outline:1.8.2
Architektur	linux/amd64 (x86_64)
Image-Größe	ca. 261 MB
Interner Port	3000 (Web-UI)
Externer Port (Empfehlung)	4997 → 3000
Pflicht-Abhängigkeiten	PostgreSQL ≥ 12, Redis ≥ 4
RAM (Minimum/Empfehlung)	512 MB / 1 GB+
Lizenz	BSL 1.1 — Selbsthosting für interne Nutzung kostenlos

Volume (Host)	Container-Pfad	Zweck
/volume1/docker/outline/data	/var/lib/outline/data	Uploads und Dateianhänge (Pflicht!)
/volume1/docker/outline/db	/var/lib/postgresql/data	PostgreSQL-Datenbankdateien
/volume1/docker/outline/redis	/data	Redis-Persistenz

Schritt 1: Keycloak-Client für Outline anlegen

Outline hat keine eingebaute Passwortverwaltung — ein externer Auth-Provider ist zwingend. Am saubersten läuft das über Keycloak mit OIDC. Melde dich in der Keycloak-Admin-Konsole an und wechsle in deinen Realm (z. B. myrealm).

Lege unter Clients → Create client einen neuen Client an:

Client ID: outline
Client type: OpenID Connect
Client authentication: ON (damit wird der Client „confidential“ und bekommt ein Secret)
Root URL: https://wiki.deine-domain.tld
Valid Redirect URIs: https://wiki.deine-domain.tld/auth/oidc.callback
Web Origins: https://wiki.deine-domain.tld

Speichere den Client und kopiere anschließend das Client Secret aus dem Tab „Credentials“. Du benötigst es gleich in der Compose-Datei.

Merke dir außerdem die Basis-URL deines Keycloak-Realms — alle OIDC-Endpunkte folgen dem Muster:

https://keycloak.deine-domain.tld/realms/myrealm/protocol/openid-connect/auth
https://keycloak.deine-domain.tld/realms/myrealm/protocol/openid-connect/token
https://keycloak.deine-domain.tld/realms/myrealm/protocol/openid-connect/userinfo

Verifizieren: Rufe https://keycloak.deine-domain.tld/realms/myrealm/.well-known/openid-configuration im Browser auf. Du siehst ein JSON-Dokument mit authorization_endpoint, token_endpoint und userinfo_endpoint. Wenn die Seite antwortet, ist der OIDC-Endpunkt erreichbar und der Client korrekt angelegt.

Schritt 2: Ordnerstruktur anlegen und Secrets generieren

Lege die Verzeichnisse per File Station unter /volume1/docker/outline/ an — oder nutze SSH. Wie du die Ordner korrekt anlegst und die nötigen Berechtigungen (PUID/PGID) setzt, erklärt die Grundanleitung Docker-Ordner und Berechtigungen auf dem Synology NAS.

Verbinde dich per SSH mit dem NAS und lege die Ordner an:

mkdir -p /volume1/docker/outline/data
mkdir -p /volume1/docker/outline/db
mkdir -p /volume1/docker/outline/redis
chmod 777 /volume1/docker/outline/data

Der chmod 777 auf das data-Verzeichnis ist nötig, weil Outline im Container als nicht-root-Benutzer läuft und sonst beim Schreiben von Anhängen auf „Permission denied“ trifft. Für die Datenbank- und Redis-Verzeichnisse übernehmen die jeweiligen Container selbst die Berechtigungen.

Generiere jetzt die beiden Pflicht-Secrets direkt auf dem NAS:

openssl rand -hex 32   # SECRET_KEY — Ausgabe notieren
openssl rand -hex 32   # UTILS_SECRET — zweiten Wert notieren

Beide Ausgaben sind 64 Zeichen lange Hex-Strings. Notiere sie sicher — nach dem ersten Container-Start dürfen diese Werte niemals mehr geändert werden. Ein späteres Ändern macht alle bestehenden Sessions ungültig und kann gespeicherte verschlüsselte Tokens in der Datenbank unbrauchbar machen.

Unter Windows PowerShell (falls du keinen SSH-Zugang nutzen möchtest) generierst du die Werte so:

-join ((1..32) | ForEach-Object { '{0:x2}' -f (Get-Random -Max 256) })

Verifizieren: Beide Secret-Strings müssen exakt 64 Zeichen lang sein. Prüfe das auf dem NAS per SSH:

echo -n "DEIN_GENERIERTER_SECRET_KEY" | wc -c
# Erwartete Ausgabe: 64

Schritt 3: compose.yaml erstellen

Wie du ein neues Compose-Projekt im Container Manager anlegst, erklärt die Grundanleitung Container Manager auf dem Synology NAS: Docker-Compose-Projekt anlegen. Lege ein neues Projekt namens „outline“ an und füge folgenden Inhalt ein — ersetze dabei alle Platzhalter durch deine echten Werte:

services:
  outline:
    image: docker.getoutline.com/outlinewiki/outline:latest
    container_name: outline
    restart: unless-stopped
    ports:
      - "4997:3000"
    volumes:
      - /volume1/docker/outline/data:/var/lib/outline/data
    environment:
      NODE_ENV: "production"
      URL: "https://wiki.deine-domain.tld"
      SECRET_KEY: "dein-64-zeichen-secret-key-hier-einfuegen"
      UTILS_SECRET: "dein-64-zeichen-utils-secret-hier-einfuegen"
      DATABASE_URL: "postgresql://outlineuser:sicheresPasswort@outline-db:5432/outline"
      REDIS_URL: "redis://outline-redis:6379"
      FILE_STORAGE: "local"
      FILE_STORAGE_LOCAL_ROOT_DIR: "/var/lib/outline/data"
      FILE_STORAGE_UPLOAD_MAX_SIZE: "262144000"
      OIDC_CLIENT_ID: "outline"
      OIDC_CLIENT_SECRET: "dein-keycloak-client-secret"
      OIDC_AUTH_URI: "https://keycloak.deine-domain.tld/realms/myrealm/protocol/openid-connect/auth"
      OIDC_TOKEN_URI: "https://keycloak.deine-domain.tld/realms/myrealm/protocol/openid-connect/token"
      OIDC_USERINFO_URI: "https://keycloak.deine-domain.tld/realms/myrealm/protocol/openid-connect/userinfo"
      OIDC_USERNAME_CLAIM: "preferred_username"
      OIDC_SCOPES: "openid profile email"
      OIDC_DISPLAY_NAME: "Keycloak SSO"
      SMTP_HOST: "smtp.example.com"
      SMTP_PORT: "465"
      SMTP_USERNAME: "user@example.com"
      SMTP_PASSWORD: "smtp-passwort"
      SMTP_FROM_EMAIL: "outline@example.com"
      SMTP_SECURE: "true"
    depends_on:
      - outline-db
      - outline-redis
    networks:
      - outline-net

  outline-db:
    image: postgres:16-alpine
    container_name: outline-db
    restart: unless-stopped
    volumes:
      - /volume1/docker/outline/db:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: "outlineuser"
      POSTGRES_PASSWORD: "sicheresPasswort"
      POSTGRES_DB: "outline"
    networks:
      - outline-net

  outline-redis:
    image: redis:7-alpine
    container_name: outline-redis
    restart: unless-stopped
    volumes:
      - /volume1/docker/outline/redis:/data
    networks:
      - outline-net

networks:
  outline-net:
    driver: bridge

Einige Hinweise zu den Werten: Die URL-Variable darf keinen abschließenden Schrägstrich haben — https://wiki.deine-domain.tld ist korrekt, https://wiki.deine-domain.tld/ würde beim OIDC-Roundtrip zu fehlerhaften Redirect-URLs führen. Das PostgreSQL-Image postgres:16-alpine wird hier bewusst gegenüber postgres:18 bevorzugt: Version 16 ist LTS, gut getestet mit Outline und produktionsreif. Der FILE_STORAGE_UPLOAD_MAX_SIZE-Wert ist auf 250 MB (262144000 Bytes) gesetzt — der offizielle Standard gemäß Outline-Dokumentation. Die SMTP-Zeilen sind optional; du kannst sie weglassen, wenn du keine E-Mail-Benachrichtigungen benötigst.

Verifizieren: Prüfe im Container Manager, dass die compose.yaml fehlerfrei validiert wird (kein roter Fehlerhinweis beim Speichern). Stelle sicher, dass alle drei Platzhalter (SECRET_KEY, UTILS_SECRET, OIDC_CLIENT_SECRET) durch echte Werte ersetzt sind — niemals mit den Beispielwerten deployen.

Schritt 4: Stack starten und Datenbank initialisieren

Starte das Compose-Projekt im Container Manager über den „Ausführen“-Button. Die Container starten in der Reihenfolge: zuerst outline-db und outline-redis, dann outline. Beim allerersten Start initialisiert PostgreSQL seine Datenbankdateien, was einige Sekunden dauert. Outline kann dabei mit „Connection refused“ scheitern und neu starten — das ist normal, weil depends_on nur die Startreihenfolge, nicht die Bereitschaft der Datenbank sicherstellt. Mit restart: unless-stopped startet der Container automatisch neu und verbindet sich erfolgreich, sobald PostgreSQL bereit ist.

Alle Datenbankmigrationen laufen automatisch beim Container-Start — kein manueller SQL-Befehl ist nötig.

Verfolge die Logs im Container Manager unter Protokoll → outline. Nach erfolgreicher Initialisierung erscheint eine Zeile wie:

{"level":"info","message":"Server listening on port 3000","label":"server"}

Verifizieren: Rufe http://NAS-IP:4997 im Browser auf. Du siehst den Outline-Login-Bildschirm mit einem Button „Mit Keycloak SSO anmelden“ (entsprechend deinem OIDC_DISPLAY_NAME). Erscheint nur eine leere Seite, fehlt vermutlich ein Auth-Provider in der Konfiguration. Siehst du einen Datenbankfehler in den Logs, warte 30 Sekunden und prüfe erneut.

Schritt 5: Reverse Proxy mit WebSocket-Unterstützung einrichten

Outline erwartet HTTPS — die URL-Variable muss https:// beginnen, und viele OIDC-Provider lehnen HTTP-Callback-URLs ab. Richte im Synology Reverse Proxy einen neuen Eintrag ein:

Quelle: HTTPS, wiki.deine-domain.tld, Port 443
Ziel: HTTP, localhost, Port 4997

Wichtig und leicht übersehen: Wechsle in den erweiterten Einstellungen des Reverse-Proxy-Eintrags und aktiviere „WebSocket-Proxy aktivieren“. Ohne WebSocket-Unterstützung funktioniert die Echtzeit-Kollaboration nicht — Nutzer sehen keine Live-Updates anderer Bearbeiter.

Wähle außerdem ein gültiges SSL-Zertifikat für wiki.deine-domain.tld aus oder erstelle eines über DSM → Systemsteuerung → Sicherheit → Zertifikat per Let's Encrypt.

Verifizieren: Rufe https://wiki.deine-domain.tld auf. Der Browser zeigt ein gültiges HTTPS-Schloss-Icon. Die Seite lädt den Outline-Login-Bildschirm ohne Zertifikatsfehler. Prüfe im Browser-Entwicklertool unter „Netzwerk“, dass nach dem Login WebSocket-Verbindungen (wss://) erfolgreich aufgebaut werden.

Schritt 6: OIDC-Roundtrip testen und erste Anmeldung

Klicke auf „Mit Keycloak SSO anmelden“. Du wirst zur Keycloak-Login-Seite weitergeleitet. Melde dich mit einem Benutzer an, der in deinem Keycloak-Realm existiert. Nach erfolgreicher Authentifizierung leitet Keycloak zurück an Outline, das den Benutzer anlegt und zur Startseite weiterleitet.

Der erste Benutzer, der sich anmeldet, wird automatisch zum Administrator des Workspaces. Lege dann unter Einstellungen → Workspace den Workspace-Namen fest und lade weitere Teammitglieder ein — sie müssen sich einfach über Keycloak anmelden und erscheinen automatisch in Outline.

Erstelle zur Probe ein erstes Dokument: Klicke auf „Neue Seite“, gib einen Titel ein und schreibe einen kurzen Text. Lade einen Kollegen ein, das Dokument gleichzeitig zu öffnen — ihr seht die Cursor-Positionen des jeweils anderen in Echtzeit, wenn WebSocket korrekt konfiguriert ist.

Verifizieren: Nach der Anmeldung erscheint das Outline-Dashboard mit deinem Benutzernamen. In Einstellungen → Mitglieder ist dein Account als Administrator gelistet. Das erste Testdokument lässt sich anlegen, speichern und per Volltext-Suche (Strg+K) wiederfinden.

Schritt 7: DSM-Firewall-Port freigeben

Wenn du die Synology-Firewall nutzt (empfohlen), musst du Port 4997 intern freigeben — zumindest für den Reverse Proxy. Wie du das korrekt einrichtest, erklärt die Grundanleitung DSM-Firewall auf dem Synology NAS: Ports für Docker-Container freigeben. Nach außen (Internet) ist nur Port 443 des Reverse Proxy nötig — Port 4997 sollte nicht direkt aus dem Internet erreichbar sein.

Verifizieren: https://wiki.deine-domain.tld ist erreichbar, während der direkte Zugriff auf http://NAS-IP:4997 aus dem externen Netz geblockt wird.

Updates einspielen und Backups

Ein Update auf eine neue Outline-Version ist unkompliziert. Verbinde dich per SSH und führe im Projektverzeichnis aus:

docker compose pull
docker compose up -d

Datenbankmigrationen laufen automatisch beim Start des neuen Containers. Lege dennoch vorher ein Backup der PostgreSQL-Datenbank an — am einfachsten per pg_dump:

docker exec outline-db pg_dump -U outlineuser outline > /volume1/docker/outline/backup_$(date +%Y%m%d).sql

Für eine vollständige Backup-Strategie — inklusive automatisierter Rotation — bietet sich PostgreSQL-Backup automatisieren mit cron an.

Troubleshooting / Typische Fehler

Login-Button fehlt / leerer Login-Screen: Kein Auth-Provider konfiguriert. Prüfe, ob alle OIDC_*-Variablen gesetzt und korrekt sind. Outline startet auch ohne Provider, zeigt aber keinen Anmelde-Button.
„redirect_uri mismatch“ nach Keycloak-Login: Die Valid Redirect URI im Keycloak-Client stimmt nicht exakt überein. Sie muss lauten: https://wiki.deine-domain.tld/auth/oidc.callback — kein abschließender Schrägstrich, exakt dieser Callback-Pfad.
URL-Variable mit abschließendem Schrägstrich: URL=https://wiki.deine-domain.tld/ führt zu fehlerhaften Redirect-URLs. Immer ohne abschließenden Slash konfigurieren.
„Connection refused“ beim Start: PostgreSQL ist noch nicht bereit. Outline startet automatisch neu. Warte 60 Sekunden und prüfe die Logs erneut.
„Permission denied“ beim Upload: Das Volume /volume1/docker/outline/data hat falsche Berechtigungen. Führe chmod 777 /volume1/docker/outline/data aus und starte den Outline-Container neu.
Echtzeit-Kollaboration funktioniert nicht: WebSocket-Proxy am Synology Reverse Proxy nicht aktiviert. DSM → Anmeldeportal → Erweiterter Modus → Eintrag bearbeiten → Erweiterte Einstellungen → „WebSocket-Proxy aktivieren“ anhaken.
Anhänge nach Neustart verschwunden: Das Volume /var/lib/outline/data wurde nicht gemountet. Prüfe, ob der Volume-Eintrag in der compose.yaml vorhanden ist und der Host-Pfad existiert.
Sessions nach Konfigurationsänderung ungültig: SECRET_KEY oder UTILS_SECRET wurden nach dem ersten Start geändert. Diese Werte dürfen niemals geändert werden — alle Nutzer müssen sich neu anmelden, verschlüsselte Datenbankeinträge können unbrauchbar werden.

Häufige Fragen

Kann ich mich ohne Keycloak oder OIDC einloggen?

Nein. Outline hat bewusst keine eingebaute Passwortverwaltung. Du benötigst zwingend einen externen Auth-Provider: OIDC (z. B. Keycloak), Slack, Google OAuth oder Azure AD. Wer Keycloak nicht nutzen möchte, kann alternativ Google OAuth oder einen Slack-Workspace als Provider konfigurieren — die entsprechenden Variablen heißen dann GOOGLE_CLIENT_ID/GOOGLE_CLIENT_SECRET bzw. SLACK_KEY/SLACK_SECRET.

Wie unterscheidet sich Outline von BookStack und Docmost?

BookStack verwendet eine starre Buch/Kapitel/Seite-Hierarchie mit eingebautem Benutzer-Login per Passwort — ideal für sehr strukturierte, redaktionell gepflegte Wissensbases. Docmost orientiert sich an Confluence, bringt Spaces und ein eigenes Authentifizierungssystem mit. Outline hingegen setzt auf frei verlinkbare, verschachtelte Dokumente im Notion-Stil und ist von Anfang an auf OIDC/SSO-Integration ausgelegt — das macht es besonders attraktiv für Teams, die bereits einen Identity Provider betreiben.

Funktioniert Outline auf einem Synology ARM-NAS?

Nein. Das offizielle Docker-Image ist als linux/amd64 verifiziert. ARM-Synology-Geräte (J-Serie, ältere Plus-Modelle mit ARM-CPU) werden nicht unterstützt. Outline eignet sich für Intel/AMD-Synology-NAS wie DS923+, DS723+ oder DS1522+.

Was macht die BSL-1.1-Lizenz in der Praxis?

Die Business Source License 1.1 erlaubt Selbsthosting für die interne Nutzung in deinem Unternehmen kostenfrei. Eingeschränkt ist lediglich die kommerzielle Weiterverteilung — also wenn du Outline selbst als SaaS-Dienst an Kunden verkaufen wolltest. Für KMU, die Outline für das eigene Team betreiben, gibt es keine Kosten und keine Einschränkungen.

Wie häufig sollte ich Outline aktualisieren?

Outline wird aktiv gepflegt (9.700+ Commits, 38.900+ GitHub-Stars). Empfehlenswert ist ein Update-Rhythmus von 4–8 Wochen. Für Produktivumgebungen solltest du statt :latest einen gepinnten Tag wie outlinewiki/outline:1.8.2 verwenden und Updates bewusst mit vorherigem Datenbank-Backup einzuspielen.

Wie konfiguriere ich Keycloak für Outline im Detail?

Eine ausführliche Schritt-für-Schritt-Anleitung zur Keycloak-Installation und OIDC-Client-Konfiguration findest du unter Keycloak auf dem Synology NAS installieren. Für Outline sind die wichtigsten Einstellungen: Client-Typ „confidential“, Valid Redirect URI exakt auf /auth/oidc.callback und die drei OIDC-Endpunkt-URLs aus dem Well-Known-Dokument des Realms.

Fazit

Outline ist der überzeugendste moderne Team-Wiki-Kandidat für KMU, die Wert auf Echtzeit-Kollaboration, saubere OIDC-Integration und eine Notion-ähnliche Nutzeroberfläche legen — ohne Cloud-Abhängigkeit. Der Compose-Stack mit PostgreSQL 16 und Redis 7 läuft stabil auf jedem Intel/AMD-Synology-NAS mit DSM 7.2. Der einzige Pflicht-Aufwand vor der Installation ist ein laufender OIDC-Provider: Wer Keycloak bereits betreibt, hat Outline in unter 45 Minuten produktionsreif am Laufen. Vergiss dabei nicht die zwei Grundregeln: SECRET_KEY und UTILS_SECRET niemals nach dem ersten Start ändern, und WebSocket am Reverse Proxy aktivieren — dann steht einem gepflegten, langlebigen Team-Wissensspeicher nichts im Weg.

Weiterführende Anleitungen und Quellen

Keycloak auf dem Synology NAS installieren: SSO und zentrale Logins mit OIDC und SAML — Voraussetzung für die OIDC-Authentifizierung
BookStack auf dem Synology NAS installieren: das Firmen-Wiki für IT-Dokumentation — Alternative mit strenger Buch-Hierarchie und eingebautem Login
MySQL & PostgreSQL Backup automatisieren mit cron: mysqldump, pg_dump, Rotation und rclone-Cloud-Sync

Offizielle Quellen: Outline Docker-Hosting-Dokumentation · Outline GitHub Repository · Outline .env.sample (alle Umgebungsvariablen)