Zum Inhalt springen
Serverküche
Suche

Die Suche wird geladen …

Anwendungen Schwierigkeit: Fortgeschritten

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.

· 11 Min. Lesezeit ·Dauer: ca. 60 Minuten
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

Outline hat keine eigene Benutzerverwaltung mit Passwort. Es kann sich ausschließlich gegen einen externen Anmeldedienst authentifizieren (OIDC, Google, Slack, Azure, Discord). Wer das Wiki aufsetzt, ohne vorher einen davon zu haben, steht vor einer Anwendung, die niemand betreten kann. Deshalb ist Authentik hier Voraussetzung, nicht Zubehör.

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_DOMAIN für Outline und auth.DEINE_DOMAIN für Authentik
  • Etwa 60 Minuten, davon die Hälfte in der Authentik-Oberfläche
🍳 Empfehlung Anzeige

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.

Zu netcup →

💶 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

Alle netcup-Gutscheine →

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:

Ausgabe
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 Token

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

Terminal
curl -s https://auth.DEINE_DOMAIN/application/o/outline/.well-known/openid-configuration \
  | python3 -m json.tool | head -6
Ausgabe
{
    "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:

Terminal
mkdir -p /opt/outline && cd /opt/outline
openssl rand -hex 32   # zweimal: für SECRET_KEY und UTILS_SECRET
INI
# /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 email
  • SECRET_KEY verschlü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=local spart dir einen S3-kompatiblen Speicher. Für ein Team-Wiki reicht das völlig; die Dateien landen in einem Docker-Volume.
  • PGSSLMODE=disable ist nötig, weil die Datenbank im internen Netz ohne TLS läuft. Ohne die Zeile versucht Outline eine verschlüsselte Verbindung, bekommt The server does not support SSL connections und startet in einer Schleife neu.
  • OIDC_DISPLAY_NAME ist nur die Beschriftung auf der Anmeldeseite.
Terminal
chmod 600 /opt/outline/.env

Schritt 3: Der Stack

YAML
# /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: true

Datenbank 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

Terminal
cd /opt/outline
docker compose up -d
docker compose logs -f outline

Beim ersten Start legt Outline die Datenbank an und spielt die Migrationen ein. Bis der Container (healthy) meldet, vergeht gut eine Minute:

Ausgabe
{"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.

Terminal
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/oidc
Ausgabe
200
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:

Die Anmeldemaske von Authentik mit dem Hinweis Log in to continue to Outline
Authentik übernimmt die Anmeldung – Outline selbst fragt nichts ab

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:

Outline nach der Anmeldung: links die Navigation mit der Sammlung „Welcome“ und dem Bereich „Personal“, rechts die vier Einstiegsdokumente
Nach der Anmeldung: links die Sammlungen und der persönliche Bereich, in der Mitte die Dokumente der Sammlung „Welcome“

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

Es gibt keine Einladung und keine Freigabe: Wer als Erster über Authentik hereinkommt, ist Administrator. Leg den OIDC-Zugang in Authentik deshalb von Anfang an eingeschränkt an (über eine Gruppenbindung an der Anwendung) und melde dich selbst als Erster an, bevor du den Namen weitergibst.

Schritt 6: Dokumente und Dateien

Ein Dokument legst du über New doc an. Outline versteht Markdown direkt beim Tippen, ## wird zur Überschrift, - zur Liste:

Ein Outline-Dokument mit Überschriften und Aufzählungen sowie der Dokumentliste in der Seitenspalte
Ein fertiges Dokument – Überschriften erscheinen links in der Sammlung als Unterpunkte

Hochgeladene Bilder und Anhänge landen bei FILE_STORAGE=local im Volume. Nach einem Upload findest du sie so:

Terminal
docker exec outline find /var/lib/outline/data -type f | head -3
Ausgabe
/var/lib/outline/data/uploads/fbc65b45-…/f633c516-…/punkt.png

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

Die Sicherheitseinstellungen von Outline mit Einladungen, Standardrolle und öffentlicher Dokumentfreigabe
Die Standardrolle für neue Konten und die öffentliche Freigabe sind die beiden wichtigen Schalter

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:

Terminal
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 20

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

Ausgabe
/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änge

Der SECRET_KEY ist der kritische Teil: Die Datenbank allein nützt nichts, wenn er fehlt. Das Volume sicherst du mit

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

Ausgabe
outline         341 MB
outline-db       77 MB
outline-redis    27 MB

Die 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