Outline: das moderne Team-Wiki mit Authentik-Login
Outline 1.12 mit Postgres 18 hinter Traefik – Anmeldung über Authentik, Dateien lokal statt S3, und die OIDC-Falle, die den Login abbricht.
Inhaltsverzeichnis
Outline ist das seltene Wiki, das sich anfühlt wie Notion und trotzdem komplett auf deinem Server läuft. Der Preis dafür fällt schon beim ersten Start auf: Es gibt keine Anmeldung mit Benutzername und Passwort. Ohne Anmeldedienst kommst du nicht hinein, auch nicht als Administrator.
Was bauen wir?
Wir betreiben Outline 1.12.0 mit PostgreSQL 18.6 und Redis 8.10.3 hinter Traefik. Die Anmeldung läuft über Authentik 2026.8.5 per OpenID Connect, hochgeladene Dateien liegen in einem Docker-Volume statt in einem S3-Speicher.
Am Ende hast du ein Wiki, in das nur hineinkommt, wer in Authentik ein Konto hat. Einen Cloud-Dienst braucht es dafür nicht.
Outline kennt keine Passwörter
Voraussetzungen
- Ein laufendes Authentik als Single Sign-on; dort hast du bereits einen Administrator und den Zugang zur Verwaltungsoberfläche
- Ein Reverse Proxy mit Traefik
- Zwei Namen, die beide auf den Server zeigen:
wiki.DEINE_DOMAINfür Outline undauth.DEINE_DOMAINfür Authentik - Etwa 60 Minuten, davon die Hälfte in der Authentik-Oberfläche
VPS 2000 G12.5
8 vCore · 16 GB RAM · 256 GB SSD
ab 26,92 €/Monat
Outline belegt rund 340 MB, Datenbank und Redis zusammen gut 100 MB – dazu kommt das Authentik daneben mit gut einem Gigabyte.
💶 1 Monat gratis:
Einmal einlösbar, gilt für VPS 2000 G12.5. Im Warenkorb einlösen →
💶 5,95 € Gutschein für netcup-Neukunden: immer gültig · nicht für Domains und VPS Lite
Schritt für Schritt
Schritt 1: In Authentik den Zugang anlegen
Melde dich in Authentik an und geh in der Verwaltung auf Applications → Providers → Create. Wähle OAuth2/OpenID Provider und trag ein:
Name Outline
Authorization flow default-provider-authorization-implicit-consent
Client type Confidential
Redirect URI https://wiki.DEINE_DOMAIN/auth/oidc.callback (Strict)
Signing Key authentik Self-signed Certificate
Subject mode Based on the User's Email
Grant types Authorization Code, Refresh TokenZwei Felder entscheiden darüber, ob der Login später funktioniert. Die Redirect-URI muss auf das
Zeichen genau stimmen: Outline ruft immer https://wiki.DEINE_DOMAIN/auth/oidc.callback auf, ohne
abschließenden Schrägstrich und ohne anderen Pfad. Steht dort etwas anderes, bricht Authentik die
Anmeldung mit invalid_request ab.
Außerdem muss Grant types den Eintrag Authorization Code enthalten. In Authentik 2026.x ist
das ein eigenes Feld. Lässt man es leer, sieht die Konfiguration vollständig aus, und die Anmeldung
schlägt trotzdem sofort fehl. Im Protokoll steht dann Invalid grant_type for provider.
Subject mode „Based on the User’s Email" sorgt dafür, dass Outline Konten an der Mailadresse festmacht. Das zählt, wenn du später den Anmeldedienst wechselst: Die Adresse bleibt, eine interne Benutzer-ID nicht.
Danach legst du unter Applications → Applications → Create die Anwendung an: Name Outline,
Slug outline, als Provider den eben erzeugten. Auf der Provider-Seite stehen jetzt
Client ID und Client Secret, die du gleich brauchst.
Die fertige Konfiguration kannst du dir von Authentik selbst bestätigen lassen:
curl -s https://auth.DEINE_DOMAIN/application/o/outline/.well-known/openid-configuration \
| python3 -m json.tool | head -6{
"issuer": "https://auth.DEINE_DOMAIN/application/o/outline/",
"authorization_endpoint": "https://auth.DEINE_DOMAIN/application/o/authorize/",
"token_endpoint": "https://auth.DEINE_DOMAIN/application/o/token/",
"userinfo_endpoint": "https://auth.DEINE_DOMAIN/application/o/userinfo/",
"end_session_endpoint": "https://auth.DEINE_DOMAIN/application/o/outline/end-session/",Diese vier Adressen trägst du gleich unverändert bei Outline ein.
Schritt 2: Die Konfiguration von Outline
Outline wird über eine .env eingestellt. Erzeuge zuerst die beiden Schlüssel:
mkdir -p /opt/outline && cd /opt/outline
openssl rand -hex 32 # zweimal: für SECRET_KEY und UTILS_SECRET# /opt/outline/.env
NODE_ENV=production
URL=https://wiki.DEINE_DOMAIN
PORT=3000
SECRET_KEY=DEIN_ERSTER_SCHLUESSEL
UTILS_SECRET=DEIN_ZWEITER_SCHLUESSEL
POSTGRES_PASSWORD=DEIN_DB_PASSWORT
DATABASE_URL=postgres://outline:DEIN_DB_PASSWORT@db:5432/outline
PGSSLMODE=disable
REDIS_URL=redis://redis:6379
FILE_STORAGE=local
FILE_STORAGE_LOCAL_ROOT_DIR=/var/lib/outline/data
FILE_STORAGE_UPLOAD_MAX_SIZE=26214400
OIDC_CLIENT_ID=AUS_AUTHENTIK
OIDC_CLIENT_SECRET=AUS_AUTHENTIK
OIDC_AUTH_URI=https://auth.DEINE_DOMAIN/application/o/authorize/
OIDC_TOKEN_URI=https://auth.DEINE_DOMAIN/application/o/token/
OIDC_USERINFO_URI=https://auth.DEINE_DOMAIN/application/o/userinfo/
OIDC_LOGOUT_URI=https://auth.DEINE_DOMAIN/application/o/outline/end-session/
OIDC_USERNAME_CLAIM=preferred_username
OIDC_DISPLAY_NAME=Authentik
OIDC_SCOPES=openid profile emailSECRET_KEYverschlüsselt Feldinhalte in der Datenbank und signiert Sitzungen. Ändert man ihn später, sind alle Anmeldungen ungültig und verschlüsselte Felder unlesbar. Er gehört ins Backup und wird nie angefasst.FILE_STORAGE=localspart dir einen S3-kompatiblen Speicher. Für ein Team-Wiki reicht das völlig; die Dateien landen in einem Docker-Volume.PGSSLMODE=disableist nötig, weil die Datenbank im internen Netz ohne TLS läuft. Ohne die Zeile versucht Outline eine verschlüsselte Verbindung, bekommtThe server does not support SSL connectionsund startet in einer Schleife neu.OIDC_DISPLAY_NAMEist nur die Beschriftung auf der Anmeldeseite.
chmod 600 /opt/outline/.envSchritt 3: Der Stack
# /opt/outline/compose.yaml
services:
db:
image: postgres:18.6-alpine
container_name: outline-db
restart: unless-stopped
environment:
POSTGRES_USER: outline
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: outline
volumes:
- pgdata:/var/lib/postgresql
networks: [outline-intern]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U outline"]
interval: 10s
timeout: 5s
retries: 6
redis:
image: redis:8.10.3-alpine
container_name: outline-redis
restart: unless-stopped
networks: [outline-intern]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 6
outline:
image: outlinewiki/outline:1.12.0
container_name: outline
restart: unless-stopped
depends_on:
db:
condition: service_healthy
redis:
condition: service_healthy
env_file: .env
volumes:
- storage:/var/lib/outline/data
networks: [outline-intern, proxy]
labels:
- traefik.enable=true
- traefik.docker.network=proxy
- traefik.http.routers.outline.rule=Host(`wiki.DEINE_DOMAIN`)
- traefik.http.routers.outline.entrypoints=websecure
- traefik.http.routers.outline.tls.certresolver=le
- traefik.http.services.outline.loadbalancer.server.port=3000
volumes:
pgdata:
storage:
networks:
outline-intern:
internal: true
proxy:
external: trueDatenbank und Redis hängen in einem Netz mit internal: true und sind weder von außen noch aus
dem proxy-Netz erreichbar. Der Mount der Datenbank liegt auf /var/lib/postgresql, nicht auf
/var/lib/postgresql/data: Ab PostgreSQL 18 verweigert der Container mit dem alten Pfad den Start.
Für den Dateispeicher nutzen wir bewusst ein benanntes Volume und keinen Ordner vom Host.
Outline läuft im Container als Benutzer nodejs mit UID 1001; bei einem Bind-Mount müsstest du die
Rechte selbst setzen, beim Volume übernimmt Docker das.
Schritt 4: Starten und prüfen
cd /opt/outline
docker compose up -d
docker compose logs -f outlineBeim ersten Start legt Outline die Datenbank an und spielt die Migrationen ein. Bis der Container
(healthy) meldet, vergeht gut eine Minute:
{"label":"database","level":"info","message":"Migrated 20261012120000-add-owner-id-to-collections.js in 0.011s"}
{"label":"plugins","level":"info","message":"OIDC endpoints mounted with manual configuration"}
{"label":"plugins","level":"info","message":"OIDC plugin registered"}
{"label":"lifecycle","level":"info","message":"Listening on http://localhost:3000 / https://wiki.DEINE_DOMAIN"}Die beiden plugins-Zeilen sind die Abnahme für die Anmeldung: Nur wenn die OIDC-Variablen
vollständig sind, registriert Outline das Modul überhaupt. Fehlt eine davon, startet Outline
trotzdem, hat dann aber gar keinen Anmeldeweg mehr.
Von außen prüfst du erst, wenn docker compose ps bei outline (healthy) zeigt.
Das dauert nach dem Start gut eine Minute, und solange der Healthcheck noch läuft, übergeht Traefik
den Container: curl scheitert dann am Zertifikat, weil Traefik nur sein eigenes
TRAEFIK DEFAULT CERT ausliefert.
curl -s -o /dev/null -w "%{http_code}\n" https://wiki.DEINE_DOMAIN/
curl -s -o /dev/null -w "%{http_code} -> %{redirect_url}\n" https://wiki.DEINE_DOMAIN/auth/oidc200
302 -> https://auth.DEINE_DOMAIN/application/o/authorize/?response_type=code&redirect_uri=…Die zweite Zeile ist die wichtige: Outline baut die Weiterleitung aus deinen Einstellungen
zusammen. Steht dort eine falsche Adresse, liegt es an der .env, nicht an Authentik.
Schritt 5: Die erste Anmeldung
Ruf https://wiki.DEINE_DOMAIN/ auf. Weil Authentik der einzige eingerichtete Anmeldedienst ist,
zeigt Outline gar keine eigene Anmeldeseite mehr, sondern leitet direkt weiter:

Nach der Anmeldung landest du in Outline. Der erste Nutzer wird automatisch Administrator, und der Arbeitsbereich wird angelegt, samt einer Beispielsammlung, die du später löschen kannst:

Unter den Sammlungen steht der Bereich Personal. Hier legt jedes Konto Dokumente an, die nur es selbst sieht und gezielt mit anderen teilen kann, ein privater Notizblock neben dem gemeinsamen Wiki.
Wer sich zuerst anmeldet, besitzt das Wiki
Schritt 6: Dokumente und Dateien
Ein Dokument legst du über New doc an. Outline versteht Markdown direkt beim Tippen, ## wird
zur Überschrift, - zur Liste:

Hochgeladene Bilder und Anhänge landen bei FILE_STORAGE=local im Volume. Nach einem Upload findest
du sie so:
docker exec outline find /var/lib/outline/data -type f | head -3/var/lib/outline/data/uploads/fbc65b45-…/f633c516-…/punkt.pngDie Dateien liegen unter zufälligen Kennungen; wer die URL nicht kennt, findet sie nicht. Ausgegeben
werden sie nur über /api/attachments.redirect, und das prüft die Berechtigung.
Schritt 7: Sicherheitseinstellungen, bevor andere dazukommen
Unter Settings → Security stehen vier Schalter, die du vor der ersten Einladung anfassen solltest:

Default role steht auf Editor. Jeder, der sich über Authentik anmeldet, darf damit sofort
schreiben. Für ein gemischtes Team ist Viewer die bessere Voreinstellung, Schreibrechte vergibst
du dann gezielt.
Public document sharing erlaubt es jedem Mitglied, ein Dokument über einen Link ins offene Internet zu stellen. Das ist praktisch und zugleich ein Datenabfluss in einem Schalter; schalt es ab, wenn du es nicht ausdrücklich brauchst.
Allow users to send invites gibt Mitgliedern das Recht, weitere Leute zu holen. Bei SSO-Anmeldung behältst du diese Entscheidung besser in Authentik als im Wiki.
Personal documents steht weiter unten und erlaubt die privaten Dokumente aus Schritt 5. Für ein Team-Wiki ist das Abwägungssache, denn privat heißt hier wirklich privat: Auch als Administrator öffnest du ein fremdes persönliches Dokument nicht. Du siehst nur „No access to this doc“ und kannst Zugriff anfragen. Die Suche findet es nicht, und der Export des gesamten Arbeitsbereichs lässt es aus. Im Klartext steht es nur in der Datenbank und damit in deinem Backup. Soll Wissen grundsätzlich im gemeinsamen Teil landen, schalt den Schalter vor der ersten Einladung ab: Er verhindert nur neue persönliche Dokumente, bereits angelegte bleiben ihren Verfassern erhalten.
Unten links steht die laufende Version (v1.12.0) samt Hinweis, ob sie aktuell ist. Schneller
lässt sich der Update-Stand nicht prüfen.
Wenn es nicht funktioniert
Die Anmeldung springt sofort zurück und Outline zeigt „Authentication failed". Schau in die Protokolle von Authentik: docker compose logs server | grep -i grant. Steht dort Invalid grant_type for provider, ist beim Provider das Feld Grant types leer. In Authentik 2026.x muss Authorization Code dort ausdrücklich eingetragen sein; die Anmeldung bricht sonst schon vor der Anmeldemaske mit invalid_request ab. Outline protokolliert dazu nur OAuth error during authentication: The request is otherwise malformed – die eigentliche Ursache steht immer auf der Authentik-Seite.
Nach der Anmeldung kommt redirect_uri als Fehler zurück. Die bei Authentik hinterlegte Adresse muss exakt https://wiki.DEINE_DOMAIN/auth/oidc.callback lauten, mit demselben Namen, den auch URL= in der .env von Outline nennt. Ein abweichender Hostname, ein zusätzlicher Schrägstrich oder http statt https reichen für die Ablehnung. Bei Matching Mode Strict gibt es keinen Spielraum – das ist Absicht.
Outline zeigt keine Anmeldeseite mehr, sondern springt direkt zu Authentik. Das ist kein Fehler: Bei genau einem eingerichteten Anmeldedienst überspringt Outline die eigene Auswahlseite. Sobald du einen zweiten Weg einrichtest, erscheint sie wieder. Wenn du die Seite sehen willst, ruf sie mit einem Hinweisparameter auf, etwa nach einem fehlgeschlagenen Versuch.
Uploads schlagen fehl, wenn du statt des Volumes einen Ordner vom Host einbindest. Outline läuft im Container als nodejs mit UID 1001 und kann in einen root-Ordner nicht schreiben – auf gehärteten Servern mit umask 027 erst recht nicht. Entweder du bleibst beim benannten Volume, oder du setzt chown -R 1001:1001 auf das Verzeichnis. Prüfen kannst du es mit docker exec outline ls -la /var/lib/outline/data.
Outline startet, aber niemand kann sich anmelden, und in den Protokollen fehlt die Zeile OIDC plugin registered. Dann ist mindestens eine der sechs OIDC_-Variablen leer. Outline meldet das nicht als Fehler – es startet einfach ohne Anmeldeweg. Prüf mit docker exec outline env | grep OIDC, ob alle Werte ankommen; ein häufiger Grund ist ein $ im Client Secret, das Compose bei environment: auflöst. Mit env_file: wie hier passiert das nicht.
Dein Problem ist nicht dabei? Alle Fehlermeldungen durchsuchen →
Wartung & Backups
Updates sind unauffällig, weil die Migrationen beim Start automatisch laufen:
cd /opt/outline
docker compose exec -T db pg_dump -U outline outline > vor-update-$(date +%F).sql
sed -i 's/outline:1.12.0/outline:NEUE_VERSION/' compose.yaml
docker compose pull && docker compose up -d
docker compose logs outline --tail 20Das pg_dump vorher ist kein Ritual: Migrationen laufen in eine Richtung, und ein Rückschritt auf
eine ältere Version ist danach nicht mehr möglich. Outline veröffentlicht etwa monatlich eine neue
Nebenversion.
Sichern musst du drei Dinge:
/opt/outline/.env # SECRET_KEY und UTILS_SECRET, ohne sie ist die DB unbrauchbar
pg_dump-Ausgabe # Dokumente, Sammlungen, Konten
Volume outline_storage # hochgeladene Bilder und AnhängeDer SECRET_KEY ist der kritische Teil: Die Datenbank allein nützt nichts, wenn er fehlt. Das
Volume sicherst du mit
docker run --rm -v outline_storage:/data -v /tmp:/backup alpine \
tar czf /backup/outline-dateien.tar.gz -C /data .Alles zusammen gehört verschlüsselt ins Restic-Backup.
Der Ressourcenbedarf ist bescheiden und stabil:
outline 341 MB
outline-db 77 MB
outline-redis 27 MBDie Datenbank wuchs mit ein paar Dokumenten auf 12 MB. Was wirklich Speicher kostet, ist das Authentik daneben. Rechne mit gut einem Gigabyte für den Anmeldedienst allein und plan den VPS danach.
Der Aufwand im Betrieb: einmal im Monat ein Update mit Dump davor, etwa eine Viertelstunde. Dazwischen passiert nichts. Outline hat keine Hintergrundaufgaben, die aus dem Ruder laufen, und der Dateispeicher wächst nur so schnell, wie dein Team Bilder einfügt. Der einzige Punkt, den du im Blick behalten solltest, ist die Nutzerliste: Wer in Authentik gelöscht wird, bleibt in Outline als Konto bestehen und muss dort getrennt deaktiviert werden.
Feedback per E-Mail: feedback@serverkueche.de
Das könnte dir auch schmecken

Authentik Teil 2: Apps anbinden – Forward-Auth & OIDC

