---
title: "Logto mit Docker installieren: Moderne Auth-Infrastruktur mit OIDC, OAuth 2.1 und Multi-Tenancy"
date: 2026-07-05T07:44:50+02:00
modified: 2026-11-08T21:16:58+01:00
category: sicherheit
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/logto-docker-auth-infrastruktur
reading_time: 10
variables:
  - name: postgres_password
    label: "Passwort (postgres password)"
    generated_in_browser: true
---

# Logto mit Docker installieren: Moderne Auth-Infrastruktur mit OIDC, OAuth 2.1 und Multi-Tenancy

## 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 |
| --- | --- | --- |
| `{{postgres_password}}` | Passwort (postgres password) | wird im Browser des Lesers zufällig erzeugt |

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, statt die Befehle selbst umzuschreiben.

**Logto** (MPL-2.0, aktuell 1.45.0) ist eine quelloffene Authentifizierungsplattform für eigene SaaS-Anwendungen und selbst gehostete Dienste mit zentralem Login. Sie implementiert OIDC und OAuth 2.1 und bringt Multi-Tenancy, Enterprise-SSO über SAML, RBAC und passwortlose Logins mit. Anders als bei Auth0 oder Okta fallen keine nutzungsabhängigen Kosten an, Code und Daten bleiben bei Ihnen. Betrieb per `docker compose`, einzige Abhängigkeit ist PostgreSQL.

**Kurzfassung:** Logto läuft als ein Container mit zwei Ports (Core-Service 3001, Admin Console 3002) plus PostgreSQL-Container, Redis ist optional. Sie legen einen Projektordner an, befüllen eine `.env` mit sicheren Zugangsdaten, starten den Stack mit `docker compose up -d` und richten den Admin-Account im Browser ein. Für den Produktivbetrieb kommen ein HTTPS-Reverse-Proxy und die Variable `ENDPOINT` hinzu, die den OIDC-Issuer bestimmt. Die offizielle Compose-Datei ist laut Projekt nur zur Demonstration gedacht; diese Anleitung ergänzt Volume, Zugangsdaten und festgelegte Versionen.

## Voraussetzungen

- [ ] **Docker Engine** (≥ 24) oder Docker Desktop sowie **Docker Compose v2** (Befehl: `docker compose`) auf einem Linux-Host (amd64 oder arm64), einer VM oder einem NAS; ist das noch nicht eingerichtet, lesen Sie zuerst die [Docker- und Compose-Grundlageninstallation für Ubuntu/Debian](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Mindestens **1 CPU-Kern und 1 GB RAM** frei für Logto und PostgreSQL zusammen; für den Produktivbetrieb 2 Kerne und 2 GB.
- [ ] Freie Ports **3001** und **3002** auf dem Host.
- [ ] Ein Texteditor für `.env` und `compose.yaml` sowie `curl` zur Verifikation.
- [ ] Für den Produktivbetrieb: Eine eigene Domain mit HTTPS-Zertifikat und ein Reverse Proxy (Nginx, Traefik oder Caddy). Eine Anleitung dazu bietet [Caddy als Reverse Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung).
- [ ] Optional: `openssl` zur Erzeugung eines sicheren KEK-Schlüssels für den Secret Vault.

## Schritt 1: Projektordner anlegen

Legen Sie einen eigenen Ordner für den Stack an; das vereinfacht Updates und Backups.

```bash
$ mkdir -p /opt/logto
$ cd /opt/logto
```

Alternativ `~/logto`; der Rest bleibt gleich.

> **Prüfen:** `ls -la /opt/logto` zeigt den noch leeren Ordner ohne Fehlermeldung.

## Schritt 2: .env-Datei mit sicheren Secrets anlegen

Legen Sie die Umgebungsvariablen in einer `.env` ab, die nie in ein Repository gehört:

Datei: `.env`

```ini
# /opt/logto/.env
# Pflicht: PostgreSQL-Passwort (mind. 20 Zeichen, keine Sonderzeichen die die URL brechen)
POSTGRES_PASSWORD={{postgres_password}}

# Produktion: Eigene Domain des Core-Service (bestimmt den OIDC Issuer, VOR dem ersten Start setzen!)
LOGTO_ENDPOINT=https://auth.beispiel.de

# Produktion: Eigene Domain der Admin Console
LOGTO_ADMIN_ENDPOINT=https://admin.auth.beispiel.de

# Produktion: Localhost-Zugang zur Admin Console sperren (auf 1 setzen sobald Reverse Proxy aktiv)
ADMIN_DISABLE_LOCALHOST=

# Optional: AES-256-KEK für Secret Vault (erzeugen mit: openssl rand -base64 32)
SECRET_VAULT_KEK=

# Optional: Statement-Timeout in ms; bei PgBouncer auf DISABLE_TIMEOUT setzen
DATABASE_STATEMENT_TIMEOUT=
```

Lokal reicht `POSTGRES_PASSWORD`; `LOGTO_ENDPOINT` und `LOGTO_ADMIN_ENDPOINT` bleiben leer. Produktiv setzen Sie beide vor dem ersten Einsatz: Eine spätere Änderung ändert den OIDC-Issuer, Tokens werden ungültig, alle angebundenen Anwendungen müssen nachziehen.

Den KEK-Schlüssel (Key Encryption Key) erzeugen Sie einmalig mit:

```bash
$ openssl rand -base64 32
```

> **Prüfen:** Nach `chmod 600 /opt/logto/.env` zeigt `ls -l /opt/logto/.env` die Rechte `-rw-------`, und `grep POSTGRES_PASSWORD /opt/logto/.env` zeigt Ihr eigenes Passwort statt des Platzhalters.

## Schritt 3: compose.yaml erstellen

Der offiziellen `docker-compose.yml` fehlen persistentes Volume und eigene Zugangsdaten; diese Variante ergänzt beides:

Datei: `docker-compose.yml`

```yaml
# /opt/logto/compose.yaml
# Persistentes Volume, Zugangsdaten aus .env, festgelegte Versionen

services:

  logto:
    image: svhd/logto:1.45.0   # Tags ohne "v"; fuer Updates Tag anpassen
    container_name: logto
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    ports:
      # Nur lokal erreichbar; von aussen ausschliesslich ueber den Reverse Proxy (Schritt 6)
      - "127.0.0.1:3001:3001"   # Core Service: OIDC-Endpunkte, Management API, Anmeldung
      - "127.0.0.1:3002:3002"   # Admin Console
    entrypoint: ["sh", "-c", "npm run cli db seed -- --swe && npm start"]
    environment:
      # Pflicht
      - DB_URL=postgres://logto:${POSTGRES_PASSWORD}@postgres:5432/logto
      - TRUST_PROXY_HEADER=1
      # Produktion: eigene Domains (beeinflusst OIDC Issuer!)
      - ENDPOINT=${LOGTO_ENDPOINT:-}
      - ADMIN_ENDPOINT=${LOGTO_ADMIN_ENDPOINT:-}
      # Optional
      - ADMIN_DISABLE_LOCALHOST=${ADMIN_DISABLE_LOCALHOST:-}
      - SECRET_VAULT_KEK=${SECRET_VAULT_KEK:-}
      - DATABASE_STATEMENT_TIMEOUT=${DATABASE_STATEMENT_TIMEOUT:-}

  postgres:
    image: postgres:17-alpine
    container_name: logto-db
    restart: unless-stopped
    user: postgres
    environment:
      POSTGRES_USER: logto
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: logto
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U logto -d logto"]
      interval: 5s
      timeout: 5s
      retries: 10
      start_period: 30s

volumes:
  postgres_data:
    driver: local
```

Wichtige Details:

1. **Healthcheck mit**`-U logto -d logto`: Logto startet das Seeding erst, wenn PostgreSQL Verbindungen annimmt.
2. **Persistentes Volume**`postgres_data`: Ohne legt PostgreSQL nach Neuerstellen des Containers eine leere Datenbank an.
3. **Entrypoint mit**`--swe` (skip when exists): unverändert aus der offiziellen Datei; bei initialisierter Datenbank entfällt das Seeding.
4. `TRUST_PROXY_HEADER=1`: Nötig, sobald ein Reverse Proxy vorgelagert ist, sonst schlägt die Anmeldung über HTTPS fehl.

> **Prüfen:** `docker compose config --quiet` im Ordner `/opt/logto` endet ohne Ausgabe, und `docker compose config --images` zeigt `svhd/logto:1.45.0` und `postgres:17-alpine`.

## Schritt 4: Stack starten

Starten Sie alle Container im Hintergrund:

```bash
$ cd /opt/logto
$ docker compose up -d
```

Logto wartet auf den PostgreSQL-Healthcheck und startet dann das Seeding (meist 30 bis 60 Sekunden).

Laufende Logs beobachten:

```bash
$ docker compose logs -f logto
```

Danach meldet das Log etwa `Admin app is running at http://localhost:3002`.

> **Prüfen:** ```bash
> $ docker compose ps
> ```

Erwartete Ausgabe (Auszug, beide Container `Up`, postgres mit `healthy`):

Ausgabe:

```plaintext
NAME       IMAGE                STATUS
logto      svhd/logto:1.45.0    Up 5 seconds
logto-db   postgres:17-alpine   Up 21 seconds (healthy)
```

Anschließend den Core-Service per curl prüfen:

```bash
$ curl -I http://localhost:3001/oidc/.well-known/openid-configuration
```

Erwartet: `HTTP/1.1 200 OK`; dann antwortet der OIDC-Discovery-Endpunkt.

## Schritt 5: Admin-Account einrichten

Öffnen Sie `http://localhost:3002`. Die Ports sind nur an 127.0.0.1 gebunden; von einem anderen Rechner per SSH-Tunnel: `ssh -L 3002:localhost:3002 -L 3001:localhost:3001 benutzer@server`. Ein Assistent legt den Admin-Account an.

> **Wichtig:** Ohne Lizenz unterstützt Logto OSS nur einen Administrator; weitere Console-Mitglieder per Einladung gibt es seit 1.45 nur mit einer Self-Hosted-Lizenz. Wählen Sie eine dauerhaft erreichbare E-Mail-Adresse und ein starkes Passwort. Danach öffnet sich die Admin Console (Applications, Connectors, Users, Enterprise SSO, RBAC).

| Bereich | URL (lokal) | Funktion |
| --- | --- | --- |
| OIDC Discovery | http://localhost:3001/oidc/.well-known/openid-configuration | OIDC-Metadaten, Issuer, Endpunkte |
| Management API | http://localhost:3001/api | REST-API für Usermanagement, Apps, Connectors |
| Admin Console | http://localhost:3002 | Web-UI für die gesamte Konfiguration |

> **Prüfen:** Nach dem Login erscheint das Logto-Dashboard; unter „Applications“ lässt sich eine Test-Application anlegen. Rufen Sie die Admin Console nur über `localhost` oder HTTPS auf, über eine IP-Adresse mit HTTP blockiert der Browser die Web Crypto API (*Crypto.subtle unavailable*).

## Schritt 6: Reverse Proxy und HTTPS einrichten (Produktion)

Für den Produktivbetrieb müssen beide Ports (3001 und 3002) hinter einem HTTPS-Reverse-Proxy liegen. Eine vollständige Anleitung für Nginx mit TLS bietet [Nginx als Reverse Proxy mit TLS manuell einrichten](https://s-edv.com/anleitungen/nginx-reverse-proxy-tls-einrichten). Für automatisches HTTPS ohne Zertifikatsverwaltung empfiehlt sich [Traefik als Docker-Reverse-Proxy](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten).

Ein minimales Nginx-Server-Block-Beispiel für den Core-Service:

```bash
server {
    listen 443 ssl;
    server_name auth.beispiel.de;

    ssl_certificate     /etc/letsencrypt/live/auth.beispiel.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/auth.beispiel.de/privkey.pem;

    location / {
        proxy_pass         http://127.0.0.1:3001;
        proxy_set_header   Host              $http_host;
        proxy_set_header   X-Real-IP         $remote_addr;
        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
        # Pflicht: Logto erkennt HTTPS-Kontext über diesen Header
        proxy_set_header   X-Forwarded-Proto https;
        proxy_set_header   X-Forwarded-Host  $http_host;
    }
}
```

Für `admin.auth.beispiel.de` gilt derselbe Block mit `proxy_pass http://127.0.0.1:3002`. Danach Domain-Variablen in der `.env` setzen und neu starten:

Datei: `.env`

```bash
# .env anpassen:
# LOGTO_ENDPOINT=https://auth.beispiel.de
# LOGTO_ADMIN_ENDPOINT=https://admin.auth.beispiel.de
# ADMIN_DISABLE_LOCALHOST=1
```

```bash
$ docker compose down
$ docker compose up -d
```

> **Achtung:** War `LOGTO_ENDPOINT` vorher nicht gesetzt (lokaler Test), sind alle bisherigen Tokens ungültig.

> **Prüfen:** ```bash
> $ curl -I https://auth.beispiel.de/oidc/.well-known/openid-configuration
> ```

Erwartet: `HTTP/2 200`, `"issuer"` zeigt auf `https://auth.beispiel.de/oidc`. Ein falscher Issuer ist die häufigste Ursache für Token-Validierungsfehler.

## Schritt 7: Updates und Backup

Vor jedem Update Datenbank sichern und Release Notes lesen. Dann den neuen Tag in der `compose.yaml` eintragen:

```bash
$ cd /opt/logto
```

```bash
# Vorher Datenbank sichern
```

```bash
$ docker exec logto-db pg_dump -U logto logto > /opt/logto/backup_$(date +%Y%m%d).sql
```

```bash
# Update durchfuehren und Datenbank-Migrationen anwenden
```

```bash
$ docker compose pull
$ docker compose run --rm -e CI=true --entrypoint "sh -c 'npm run alteration deploy latest'" logto
$ docker compose up -d
```

Schemaänderungen spielt `alteration deploy` ein (wie im offiziellen Kubernetes-Beispiel), nicht das Seeding beim Start.

**Update von 1.43 auf 1.44:** Laut Release Notes zwei Schemaänderungen: eine neue Spalte für SAML-Anwendungen und `users.id` samt Fremdschlüsseln auf 128 Zeichen. `alteration deploy` muss vor dem Start von 1.44 laufen. Er meldet dann `Found 2 alterations to deploy` und beide als erfolgreich. Ein Zurückrollen scheitert, sobald Benutzer-IDs länger als die bisherigen 12 bzw. 21 Zeichen gespeichert sind; das vorherige `pg_dump` ist Pflicht. Neu sind unter anderem vertrauenswürdige Geräte für MFA und eigene Benutzer-IDs per Management API (nur OSS), was Migrationen etwa von Auth0 erleichtert.

**Update von 1.44 auf 1.45:** Laut Release Notes eine Schemaänderung: Im Admin-Tenant kommt die Organisationsrolle `viewer` hinzu (Alteration `1.45.0-1791531333-add-tenant-viewer-role`). Dabei meldet `alteration deploy`:

```plaintext
info Deploy target 1.45.0
info Found 1 alteration to deploy
info Run alteration 1.45.0-1791531333-add-tenant-viewer-role.js `up()` function succeeded
```

Danach liefen beide Container mit 1.45.0, der vor dem Update angelegte Benutzer war vorhanden, die Anmeldung funktionierte, und die vor dem Update ausgestellte Sitzung bekam weiter Zugriff auf die Management API. Ohne Lizenz verhält sich 1.45 laut Projektdokumentation wie zuvor; neu ist die Lizenzverwaltung für Self-Hosted-Funktionen unter Tenant settings > License.

Für automatisierte PostgreSQL-Backups bietet sich ein Cronjob mit `pg_dump` an. Eine vollständige Anleitung dazu liefert die [Anleitung zum Automatisieren von PostgreSQL-Backups](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud).

Für die Eckdaten des Stacks auf einen Blick:

| Eigenschaft | Wert |
| --- | --- |
| Image | svhd/logto:1.45.0 (Docker Hub, amd64 und arm64) |
| Image (alternativ) | ghcr.io/logto-io/logto |
| Image-Größe | ca. 330 MB komprimiert (Docker Hub, amd64), entpackt rund 1,9 GB |
| Port Core Service | 3001 (OIDC, Management API, Sign-in-Flow) |
| Port Admin Console | 3002 (Web-UI) |
| Datenbank (Pflicht) | PostgreSQL 14+ |
| Redis | Optional (nur Multi-Instanz) |
| Volume (Pflicht) | postgres_data:/var/lib/postgresql/data |
| Lizenz | Mozilla Public License 2.0 |
| Aktuelle Version | 1.45.0 (13. Oktober 2026) |

> **Prüfen:** ```bash
> $ docker compose ps
> ```
>
> ```bash
> # Beide Container müssen Status "Up" zeigen.
> ```
>
> ```bash
> $ docker compose logs --tail=20 logto
> ```
>
> ```bash
> # Keine Fehler zu Image/Port/Volume/Env.
> ```

## Troubleshooting / Typische Fehler

**„Crypto.subtle unavailable“ in der Admin Console**

Web Crypto braucht einen sicheren Kontext; Aufruf per HTTP mit IP-Adresse. Lösung: `http://localhost:3002` oder HTTPS per Reverse Proxy.

**Sign-in schlägt hinter Nginx/Traefik fehl**

`TRUST_PROXY_HEADER=1` und Header `X-Forwarded-Proto: https` sind beide nötig.

**Logto startet nicht, Postgres bleibt „unhealthy“**

Prüfen Sie mit `docker compose logs postgres`, ob `POSTGRES_PASSWORD` gesetzt ist und der Healthcheck-Benutzer zu `POSTGRES_USER` passt.

**Datenverlust nach**

`docker compose down`**:** Kein persistentes Volume, siehe Schritt 3.

**Token-Validierungsfehler nach Domain-Wechsel**

Mit `LOGTO_ENDPOINT` änderte sich der Issuer. Issuer in allen Anwendungen anpassen, Benutzer neu anmelden lassen.

**CORS-Fehler bei API-Zugriffen**

`LOGTO_ADMIN_ENDPOINT` weicht von der Origin ab (Slash am Ende, http statt https). Exakt setzen: `https://admin.auth.beispiel.de`.

**PgBouncer / Connection-Pooler-Fehler**

`DATABASE_STATEMENT_TIMEOUT=DISABLE_TIMEOUT` in der `.env` setzen, wenn PgBouncer vorgelagert ist.

**Management API liefert 404**

Tutorials nutzen oft Cloud-URLs (`[tenant-id].logto.app/api`); bei OSS gilt `https://[eigene-domain]/api` bzw. `http://localhost:3001/api`.

**Umgebung ohne Internetzugang, Admin-Registrierung hängt**

`--disable-admin-pwned-password-check` an `npm run cli db seed` im Entrypoint anhängen (Prüfung gegen Have I Been Pwned entfällt).

**Invalid ID Token ohne erkennbaren Grund**

Uhrzeitabweichung zwischen Server und Client. NTP aktivieren: `sudo timedatectl set-ntp true`.

**Logto startet nach dem Tag-Wechsel nicht und startet ständig neu**

Das Log meldet `Found undeployed database alterations, you must deploy them first by npm run alteration deploy command.` und `Error: Undeployed database alterations found.` Der neue Tag wurde ohne `alteration deploy` gestartet. Lösung: den `alteration deploy`-Befehl aus Schritt 7 ausführen, danach `docker compose up -d`.

## Häufige Fragen

### Brauche ich Redis für Logto?

Nein. Redis dient nur als zentraler Cache mehrerer Instanzen hinter einem Load Balancer.

### Wie richte ich den ersten Admin-Account ein?

Siehe Schritt 5.

### Was ist der Unterschied zwischen Logto OSS und Logto Cloud?

Logto Cloud ist der gehostete Dienst mit mehreren Administratoren (in OSS seit 1.45 nur mit Self-Hosted-Lizenz), Logto OSS die selbst gehostete Version (MPL-2.0). Management-API: OSS `https://[domain]/api`, Cloud `[tenant-id].logto.app/api`.

### Unterstützt Logto Enterprise SSO wie SAML?

Ja, SAML 2.0 und OIDC als Enterprise Connector, eingerichtet unter „Enterprise SSO“, unter anderem für Okta, Azure AD/Entra ID und Google Workspace.

### Wie aktualisiere ich Logto auf eine neue Version?

Siehe Schritt 7. Tag-Format `svhd/logto:1.45.0`, ohne „v“.

### Kann ich Logto hinter einem Nginx-Reverse-Proxy betreiben?

Ja, siehe Schritt 6: je Port ein Server-Block, Header `X-Forwarded-Proto` und `X-Forwarded-Host` plus `TRUST_PROXY_HEADER=1`.

### Welche Architekturen unterstützt das Logto-Image?

Release-Tags von `svhd/logto` gibt es für `linux/amd64` und `linux/arm64` (auch Raspberry Pi 4/5); nur `edge` ist auf amd64 beschränkt.

## Fazit

Logto bietet OIDC, OAuth 2.1 und Enterprise-SSO als selbst gehostete Plattform auf Docker-Basis. Die Einrichtung dauert rund 20 Minuten, wenn `LOGTO_ENDPOINT` vor dem produktiven Einsatz korrekt gesetzt ist; eine spätere Änderung betrifft alle angebundenen Anwendungen. Für Teams, die Auth0 oder Okta ablösen wollen, ist Logto eine sachliche Alternative. Wer nur Single Sign-On für interne Dienste sucht, findet mit [Authentik oder Authelia](https://s-edv.com/anleitungen/sso-authentik-authelia-traefik-forward-auth) möglicherweise einen schlankeren Einstieg.

## Weiterführende Anleitungen und Quellen

1. [Docker Compose: Multi-Container-Stacks aufbauen](https://s-edv.com/anleitungen/docker-compose-grundlagen-stacks): Grundlagenwissen zu Compose-Syntax, Netzwerken und Volumes
2. [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root): Produktionshärtung für Compose-Stacks
3. [Single Sign-On für den Self-Hosted-Stack: Authentik vs. Authelia](https://s-edv.com/anleitungen/sso-authentik-authelia-traefik-forward-auth): Vergleich der SSO-Alternativen mit Traefik Forward-Auth
4. [MySQL & PostgreSQL Backup automatisieren mit cron](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud): pg_dump, Rotation und Cloud-Sync für PostgreSQL
5. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
6. [Passbolt mit Docker installieren: Team-Passwortmanager](https://s-edv.com/anleitungen/passbolt-docker-teampasswortmanager)

Offizielle Quellen: [Logto OSS: Get Started](https://docs.logto.io/logto-oss/get-started-with-oss) · [Logto Deployment and Configuration](https://docs.logto.io/logto-oss/deployment-and-configuration) · [logto-io/logto auf GitHub](https://github.com/logto-io/logto) · [svhd/logto auf Docker Hub](https://hub.docker.com/r/svhd/logto) · [Release Notes Logto v1.45.0](https://github.com/logto-io/logto/releases/tag/v1.45.0) · [Logto: Self-hosted license](https://docs.logto.io/logto-oss/self-hosted-license)
