Self-hosting Outline on a VPS: Docker Compose, Postgres, Redis, and the login screen it doesn't haveOutline selbst hosten auf einem VPS: Docker Compose, Postgres, Redis und der Login-Bildschirm, den es nicht gibt

Outline builds from its own repository, not a trusted public tagOutline baut aus dem eigenen Repository, nicht aus einem vertrauenswürdigen öffentlichen Tag

Outline doesn't ship a single, official pre-built image you pull and run the way BookStack or Mattermost do. The supported self-hosting path is cloning the project's own repository and building the image from that source with Compose, so the artifact you're running is exactly the code the maintainers tagged, not a third party's repackaging of it.Outline liefert kein einziges, offizielles vorgebautes Image, das du einfach ziehst und startest, so wie es BookStack oder Mattermost tun. Der unterstützte Weg zum Selbst-Hosten ist, das eigene Repository des Projekts zu klonen und das Image mit Compose aus diesem Quellcode zu bauen, sodass das Artefakt, das du betreibst, exakt der Code ist, den die Maintainer getaggt haben — nicht die Neuverpackung eines Dritten.

git clone https://github.com/outline/outline.git
cd outline
git checkout <tag>  # check github.com/outline/outline/releases for the current stable tag
cp .env.sample .env

Pin a real release tag before you build — building straight off the default branch means you're running whatever landed there today, not a version anyone tested as a release. .env.sample is Outline's own reference for every variable it reads; keep it open in a second terminal while you edit .env, because a few of the names below are easy to mistype.Pinne einen echten Release-Tag, bevor du baust — baust du direkt vom Default-Branch, betreibst du, was auch immer heute dort gelandet ist, nicht eine Version, die jemand als Release getestet hat. .env.sample ist Outlines eigene Referenz für jede Variable, die es liest; halte sie in einem zweiten Terminal offen, während du .env bearbeitest, denn ein paar der Namen unten lassen sich leicht vertippen.

Authentication is mandatory, and it isn't a local accountAuthentifizierung ist Pflicht, und es ist kein lokaler Account

This is the part that changes whether Outline is even the right tool: it has no built-in password login at all. Every install needs at least one external identity provider configured before the first user can sign in — Google or Slack with a couple of client ID and secret variables, or a generic OIDC connection to any provider that speaks it. There's no "just create an admin account and move on" step; the OAuth or OIDC round-trip is how the first account gets created too.Das ist der Teil, der darüber entscheidet, ob Outline überhaupt das richtige Werkzeug ist: Es hat überhaupt kein eingebautes Passwort-Login. Jede Installation braucht mindestens einen externen Identity-Provider, der konfiguriert ist, bevor sich der erste Nutzer anmelden kann — Google oder Slack mit ein paar Client-ID- und Secret-Variablen, oder eine generische OIDC-Verbindung zu jedem Provider, der das spricht. Es gibt keinen Schritt „einfach einen Admin-Account anlegen und weitermachen“; der OAuth- oder OIDC-Roundtrip ist auch, wie der erste Account überhaupt entsteht.

If you don't want your team's login riding on a Google or Slack app registration, a self-hosted OIDC provider like Authentik or Keycloak on a second small VPS does the job — Outline doesn't care who issues the token as long as the endpoints are reachable and the claims match what it expects. Either way, set it up and test a login before you spend time on themes and permissions; the wiki is unreachable to everyone until one identity provider is wired in.Willst du nicht, dass das Login deines Teams an einer Google- oder Slack-App-Registrierung hängt, erledigt ein selbst gehosteter OIDC-Provider wie Authentik oder Keycloak auf einem zweiten kleinen VPS die Aufgabe — Outline ist es egal, wer das Token ausstellt, solange die Endpoints erreichbar sind und die Claims dem entsprechen, was es erwartet. So oder so: Richte es ein und teste einen Login, bevor du Zeit in Themes und Berechtigungen steckst; das Wiki ist für alle unerreichbar, bis ein Identity-Provider eingebunden ist.

# .env — pick one provider before first boot
OIDC_CLIENT_ID=<from your identity provider>
OIDC_CLIENT_SECRET=<from your identity provider>
OIDC_AUTH_URI=<authorization endpoint>
OIDC_TOKEN_URI=<token endpoint>
OIDC_USERINFO_URI=<userinfo endpoint>
OIDC_USERNAME_CLAIM=preferred_username
OIDC_DISPLAY_NAME=Company SSO

GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET and SLACK_CLIENT_ID / SLACK_CLIENT_SECRET are the equivalent pair for those two providers if you'd rather not stand up OIDC yourself. All of them need the app or OAuth client registered first — Outline only consumes the credentials, it doesn't help you create them.GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET und SLACK_CLIENT_ID / SLACK_CLIENT_SECRET sind das entsprechende Paar für diese beiden Provider, falls du OIDC lieber nicht selbst aufsetzen willst. Bei allen muss zuerst die App bzw. der OAuth-Client registriert werden — Outline konsumiert nur die Credentials, es hilft dir nicht, sie zu erstellen.

The compose file: Outline, Postgres, and RedisDie Compose-Datei: Outline, Postgres und Redis

Three services. Postgres holds every document; Redis handles the job queue and the websocket layer behind collaborative editing, and doesn't need to survive a restart to keep the wiki correct.Drei Services. Postgres speichert jedes Dokument; Redis übernimmt die Job-Queue und die Websocket-Schicht hinter dem kollaborativen Editieren und muss einen Neustart nicht überleben, damit das Wiki korrekt bleibt.

services:
  outline:
    build:
      context: .
    restart: unless-stopped
    env_file: ./.env
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - storage-data:/var/lib/outline/data
    ports:
      - "127.0.0.1:3000:3000"

  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_USER=outline
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=outline
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U outline"]
      interval: 5s
      timeout: 5s
      retries: 10
    volumes:
      - db-data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    restart: unless-stopped

volumes:
  storage-data:
  db-data:

Redis gets no volume on purpose — losing a queue of in-flight jobs on a restart is a non-event, and not persisting it is one less thing to back up or corrupt. The web port is bound to 127.0.0.1 so only the reverse proxy on the same host can reach it. The Postgres healthcheck and long-form depends_on above are load-bearing: a plain list only waits for the container to start, not for Postgres to finish initdb, and on a first docker compose up -d that gap alone can make outline exit once before restart: unless-stopped brings it back — check docker compose ps again rather than assume the stack is broken.Redis bekommt absichtlich kein Volume — eine Queue mit laufenden Jobs bei einem Neustart zu verlieren ist ein Nicht-Ereignis, und sie nicht zu persistieren ist eine Sache weniger, die man sichern oder die kaputtgehen kann. Der Web-Port ist an 127.0.0.1 gebunden, sodass ihn nur der Reverse-Proxy auf demselben Host erreicht. Der Postgres-healthcheck und das ausführliche depends_on oben sind tragend: Eine einfache Liste wartet nur darauf, dass der Container startet, nicht darauf, dass Postgres initdb abschließt, und beim ersten docker compose up -d kann allein diese Lücke dazu führen, dass sich outline einmal beendet, bevor restart: unless-stopped es zurückbringt — prüfe lieber noch einmal docker compose ps, statt anzunehmen, der Stack sei kaputt.

SECRET_KEY, UTILS_SECRET, and a Postgres connection string that needs one extra flagSECRET_KEY, UTILS_SECRET und ein Postgres-Connection-String, der ein zusätzliches Flag braucht

Outline refuses to start without two long random secrets, and its own docs give you the command to generate both:Outline weigert sich, ohne zwei lange, zufällige Secrets zu starten, und die eigene Doku liefert dir den Befehl, um beide zu erzeugen:

printf 'SECRET_KEY=%s\n' "$(openssl rand -hex 32)" >> .env
printf 'UTILS_SECRET=%s\n' "$(openssl rand -hex 32)" >> .env
printf 'DB_PASSWORD=%s\n' "$(openssl rand -hex 24)" >> .env

Then point Outline at Postgres and Redis using the service names Compose gives them on the internal network:Richte Outline dann mit den Servicenamen, die Compose ihnen im internen Netzwerk gibt, auf Postgres und Redis aus:

DATABASE_URL=postgres://outline:<same value as DB_PASSWORD>@postgres:5432/outline?sslmode=disable
REDIS_URL=redis://redis:6379
URL=https://wiki.example.com

The ?sslmode=disable on the end of DATABASE_URL is the thing that bites later. Postgres inside this compose file has no TLS certificate configured, and Outline's default connection behavior expects one; leave the flag off and the container fails to connect to a database that is running fine right next to it. URL has to be the exact public HTTPS address, for the same reason APP_URL and SITEURL matter in other self-hosted apps — Outline uses it to build the links it sends and to validate the OAuth callback it just walked the user through.Das ?sslmode=disable am Ende von DATABASE_URL ist das, was später zuschlägt. Postgres in dieser Compose-Datei hat kein TLS-Zertifikat konfiguriert, und Outlines Standard-Verbindungsverhalten erwartet eines; lässt du das Flag weg, kann der Container keine Verbindung zu einer Datenbank aufbauen, die direkt daneben einwandfrei läuft. URL muss die exakte öffentliche HTTPS-Adresse sein, aus demselben Grund, aus dem APP_URL und SITEURL in anderen selbst gehosteten Apps wichtig sind — Outline nutzt sie, um die Links zu bauen, die es verschickt, und um den OAuth-Callback zu validieren, den der Nutzer gerade durchlaufen hat.

File storage: local volume, or hand it to S3-compatible storageDateispeicher: lokales Volume, oder an S3-kompatiblen Speicher abgeben

FILE_STORAGE=local is the default and needs nothing extra — uploaded images and file attachments land under /var/lib/outline/data inside the container, which the storage-data volume above already persists. For a small wiki this is genuinely fine; it's one more thing to back up, not a reason to add a service.FILE_STORAGE=local ist die Vorgabe und braucht nichts Zusätzliches — hochgeladene Bilder und Dateianhänge landen unter /var/lib/outline/data im Container, was das storage-data-Volume oben bereits persistiert. Für ein kleines Wiki ist das wirklich in Ordnung; es ist eine Sache mehr, die man sichern muss, kein Grund, einen weiteren Service hinzuzufügen.

Past a certain point — years of screenshots and attached PDFs — moving uploads to S3-compatible object storage keeps the VPS's own disk from being the thing you're watching. Outline supports this natively with FILE_STORAGE=s3 plus AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION, AWS_S3_UPLOAD_BUCKET_URL, and AWS_S3_UPLOAD_BUCKET_NAME — any S3-compatible endpoint works, including one you run yourself. self-hosting MinIO object storage on a VPS walks through standing up that side of it if you'd rather keep the bucket on infrastructure you control instead of a third party's.Ab einem bestimmten Punkt — Jahre an Screenshots und angehängten PDFs — sorgt das Verschieben der Uploads auf S3-kompatiblen Objektspeicher dafür, dass nicht die eigene Festplatte des VPS die Sache ist, die du im Auge behalten musst. Outline unterstützt das nativ mit FILE_STORAGE=s3 plus AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION, AWS_S3_UPLOAD_BUCKET_URL und AWS_S3_UPLOAD_BUCKET_NAME — jeder S3-kompatible Endpoint funktioniert, auch einer, den du selbst betreibst. MinIO-Objektspeicher selbst hosten auf einem VPS führt durch das Aufsetzen dieser Seite, falls du den Bucket lieber auf Infrastruktur behalten willst, die du selbst kontrollierst, statt bei einem Dritten.

HTTPS with Caddy, and the NAT catch worth checking firstHTTPS mit Caddy, und die NAT-Falle, die du vorher prüfen solltest

wiki.example.com {
    reverse_proxy 127.0.0.1:3000
}

That's the whole file — Caddy requests and renews the certificate on its own once DNS resolves to the box, and forwards the websocket upgrade Outline's live editing needs through the same reverse proxy line with nothing extra. Point DNS first and let it settle before starting Caddy.Das ist die ganze Datei — Caddy fordert das Zertifikat von selbst an und erneuert es, sobald DNS auf die Maschine zeigt, und leitet das Websocket-Upgrade, das Outlines Live-Editing braucht, über dieselbe Reverse-Proxy-Zeile weiter, ganz ohne Zusatz. Richte zuerst DNS ein und lass es sich setzen, bevor du Caddy startest.

A NAT IPv4 VPS forwards a small number of ports to the machine, and whether 443 is among them depends on the plan — check before you point a domain here. Running only Outline on this box makes it a non-issue: Caddy is the one thing binding 443, and everything else stays internal. It only turns into a decision once a second HTTPS service wants the same port, since nothing can bind 443 twice — the fix is Caddy staying the sole owner of that port with a separate block per hostname. A standalone address with a port to itself exists too, but it's arranged by e-mail rather than something you self-service from the panel. NAT IPv4 vs a dedicated IP and NAT IPv4, ports and forwarding cover the mechanics.Ein NAT-IPv4-VPS leitet eine kleine Anzahl an Ports an die Maschine weiter, und ob 443 dazugehört, hängt vom Plan ab — prüfe das, bevor du hier eine Domain draufzeigen lässt. Betreibst du auf dieser Maschine nur Outline, ist das kein Thema: Caddy ist das Einzige, das 443 bindet, und alles andere bleibt intern. Zur Entscheidung wird es erst, sobald ein zweiter HTTPS-Dienst denselben Port will, denn 443 lässt sich nicht doppelt binden — die Lösung ist, dass Caddy alleiniger Besitzer dieses Ports bleibt, mit einem separaten Block pro Hostname. Eine eigenständige Adresse mit einem Port für sich allein gibt es auch, aber die wird per E-Mail geregelt statt selbst im Panel buchbar zu sein. NAT IPv4 vs. dedizierte IP und NAT IPv4, Ports und Weiterleitung behandeln die Mechanik.

Backups: the Postgres dump and the data volume, bothBackups: der Postgres-Dump und das Daten-Volume, beide

Two pieces, and skipping either one leaves a restore that's missing something:Zwei Teile, und lässt du eines davon aus, fehlt bei einer Wiederherstellung etwas:

docker compose exec -T postgres pg_dump -U outline -d outline > "outline-$(date +%F).sql"
docker run --rm -v outline_storage-data:/data -v "$(pwd)":/backup alpine:3.20 \
  tar czf "/backup/outline-storage-$(date +%F).tar.gz" -C /data .

Check the actual volume name first with docker compose config --volumes — Compose prefixes it with the project directory name, so it may differ from the example. If every upload lives on S3-compatible storage instead of the local volume, the dump is still required — it's the only copy of the wiki's actual document text — but the volume backup becomes small and mostly disposable. Copy both files off the VPS entirely; a dump sitting on the same disk as the database it came from is a file, not a backup. back up your VPS covers what off-machine actually means, and run a database on your VPS is worth a read on running Postgres alongside the app it serves in general.Prüfe zuerst mit docker compose config --volumes den tatsächlichen Volume-Namen — Compose stellt ihm den Namen des Projektverzeichnisses voran, sodass er vom Beispiel abweichen kann. Liegt jeder Upload auf S3-kompatiblem Speicher statt auf dem lokalen Volume, ist der Dump trotzdem nötig — er ist die einzige Kopie des tatsächlichen Dokumententexts des Wikis —, aber das Volume-Backup wird klein und weitgehend verzichtbar. Kopiere beide Dateien vollständig vom VPS herunter; ein Dump auf derselben Platte wie die Datenbank, von der er stammt, ist eine Datei, kein Backup. Backup deines VPS behandelt, was Backup abseits der Maschine tatsächlich bedeutet, und eine Datenbank auf deinem VPS betreiben lohnt sich als Lektüre dazu, Postgres generell neben der App zu betreiben, der es dient.

UpdatesUpdates

git pull
git checkout <new tag>
docker compose build
docker compose up -d

Take both backups immediately before this, not after. Outline runs its own database migrations automatically the moment the new version starts — there's no separate migration command to remember — and that's exactly why the dump needs to exist a few minutes earlier, not be something you improvise once a migration has already run against production data. Read the release notes for the tag you're jumping to, especially across several versions at once.Mach beide Backups unmittelbar davor, nicht danach. Outline führt seine eigenen Datenbank-Migrationen automatisch aus, sobald die neue Version startet — es gibt keinen separaten Migrationsbefehl, den man sich merken müsste — und genau deshalb muss der Dump ein paar Minuten vorher existieren, statt etwas zu sein, das du improvisierst, nachdem eine Migration bereits gegen Produktionsdaten gelaufen ist. Lies die Release Notes für den Tag, zu dem du springst, besonders wenn du mehrere Versionen auf einmal überspringst.

Sizing: Standard, because Postgres and Redis are what decide itDimensionierung: Standard, weil Postgres und Redis darüber entscheiden

The Outline process itself is a lean Node application; it is not what determines whether this stack feels comfortable. Standard (2 vCPU / 4 GiB / 80 GB) is a solid floor for a real team wiki — Postgres gets enough memory to keep its working set cached instead of hitting disk on every search, Redis stays trivial, and Caddy's TLS handling doesn't compete meaningfully with either. A wiki with a couple of dozen active editors and a normal amount of history runs here without drama.Der Outline-Prozess selbst ist eine schlanke Node-Anwendung; er ist nicht das, was darüber entscheidet, ob sich dieser Stack komfortabel anfühlt. Standard (2 vCPU / 4 GiB / 80 GB) ist eine solide Untergrenze für ein echtes Team-Wiki — Postgres bekommt genug Speicher, um seinen Working Set im Cache zu halten, statt bei jeder Suche auf die Platte zu greifen, Redis bleibt trivial, und Caddys TLS-Handling konkurriert mit keinem von beiden nennenswert. Ein Wiki mit ein paar Dutzend aktiven Bearbeitern und einer normalen Menge an Historie läuft hier ohne Drama.

Below that, on Basic (2 vCPU / 2 GiB / 50 GB), Outline runs, but Postgres has noticeably less room to cache anything and a burst of concurrent editing can start swapping. Above Standard, the honest reason to move to Pro (4 vCPU / 8 GiB / 120 GB) is years of accumulated document history and a much larger concurrent user count pushing Postgres's working set past what 4 GiB can hold comfortably — not Outline itself needing more CPU.Darunter, auf Basic (2 vCPU / 2 GiB / 50 GB), läuft Outline zwar, aber Postgres hat merklich weniger Spielraum, um irgendetwas zu cachen, und ein Schub gleichzeitiger Bearbeitung kann anfangen zu swappen. Oberhalb von Standard ist der ehrliche Grund für einen Umstieg auf Pro (4 vCPU / 8 GiB / 120 GB) Jahre an angesammelter Dokumenten-Historie und eine deutlich größere Zahl gleichzeitiger Nutzer, die Postgres' Working Set über das hinausdrängen, was 4 GiB noch komfortabel fassen können — nicht, dass Outline selbst mehr CPU bräuchte.

On overnight.hostBei overnight.host

Full disclosure: this is what we sell. Standard (2 vCPU / 4 GiB / 80 GB) is the honest floor for a team wiki, because Postgres and Redis are what set the number, not the Outline process itself; a wiki with years of history and many concurrent editors is a reason to move up to Pro (4 vCPU / 8 GiB / 120 GB) for Postgres headroom, not for Outline.Volle Transparenz: Das ist, was wir verkaufen. Standard (2 vCPU / 4 GiB / 80 GB) ist die ehrliche Untergrenze für ein Team-Wiki, weil Postgres und Redis die Zahl bestimmen, nicht der Outline-Prozess selbst; ein Wiki mit Jahren an Historie und vielen gleichzeitigen Bearbeitern ist ein Grund, auf Pro (4 vCPU / 8 GiB / 120 GB) hochzugehen — für Postgres-Spielraum, nicht für Outline.

Linux KVM VPS — EUR 4.99 to EUR 59.99 a month, on our own single-tenant bare metal in Dallas, TX and Charlotte, NC. Full hardware virtualisation (KVM), your own kernel, full root. Six tiers, vps-starter to vps-ultra. Starter is 1 vCPU, 1 GiB RAM, 25 GB disk.Linux-KVM-VPS — 4,99 bis 59,99 EUR im Monat, auf unserer eigenen Single-Tenant-Bare-Metal-Hardware in Dallas, TX und Charlotte, NC. Vollständige Hardware-Virtualisierung (KVM), eigener Kernel, volles Root. Sechs Tarife, vps-starter bis vps-ultra. Starter hat 1 vCPU, 1 GiB RAM, 25 GB Speicher.

You order in the shop, pay by card (Stripe) or SEPA bank transfer, and your login details are e-mailed to you once the service is set up. Support is e-mail, run by one person, with no guaranteed response time. All prices are final totals under the German small-business rule (§19 UStG); no VAT is added or shown.Du bestellst im Shop, zahlst per Karte (Stripe) oder SEPA-Überweisung, und deine Zugangsdaten werden dir per E-Mail zugeschickt, sobald der Dienst eingerichtet ist. Support läuft per E-Mail, von einer einzelnen Person betrieben, ohne garantierte Reaktionszeit. Alle Preise sind Endpreise. Gemäß § 19 UStG wird keine Umsatzsteuer ausgewiesen.

Order vps-standard → · Linux KVM VPS overviewvps-standard bestellen → · Übersicht Linux-KVM-VPS

Written by the person who runs overnight.host: a small, honest hosting company on dedicated bare metal — Linux VPS, game servers, web hosting. Live status at up.overnight.host.Geschrieben von der Person, die overnight.host betreibt: ein kleines, ehrliches Hosting-Unternehmen auf dedizierter Bare-Metal-Hardware — Linux-VPS, Gameserver, Webhosting. Live-Status unter up.overnight.host.