---
title: "Casdoor mit Docker installieren: Zentraler Auth-Server für OAuth 2.0, OIDC und SSO"
date: 2026-07-05T07:02:20+02:00
modified: 2026-11-10T17:50:24+01:00
category: sicherheit
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/casdoor-docker-auth-server
reading_time: 12
personalize_url: "https://s-edv.com/anleitungen/casdoor-docker-auth-server#domain={domain}"
variables:
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
  - name: postgres_password
    label: "Schlüssel (postgres password)"
    generated_in_browser: true
---

# Casdoor mit Docker installieren: Zentraler Auth-Server für OAuth 2.0, OIDC und SSO

## 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 |
| --- | --- | --- |
| `{{domain}}` | Ihre Domain | `example.com` |
| `{{postgres_password}}` | Schlüssel (postgres password) | wird im Browser des Lesers zufällig erzeugt |

Link mit eigenen Werten: https://s-edv.com/anleitungen/casdoor-docker-auth-server#domain=cloud.example.com

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. 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 und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Wer mehrere selbst betriebene Dienste wie Gitea, Nextcloud, eine eigene API oder ein internes Wiki nutzt, pflegt ohne zentrale Anmeldung für jeden Dienst eigene Zugangsdaten. Casdoor schafft hier Abhilfe: Die in Go geschriebene Plattform arbeitet als zentraler Identity Provider (IdP) und unterstützt OAuth 2.0, OIDC, SAML, CAS, LDAP, WebAuthn, TOTP, SCIM 2.0 und RADIUS. Die laufende Verwaltung erfolgt vollständig in der Weboberfläche. Diese Anleitung zeigt, wie Sie Casdoor 4.25 mit Docker Compose und PostgreSQL auf einem Linux-Host einrichten, absichern und prüfen.

**Kurzfassung:** Projektordner anlegen, `app.conf` aus dem offiziellen Repository laden und auf PostgreSQL umstellen, Datenbankpasswort in `.env` hinterlegen, `compose.yaml` anlegen und mit `docker compose up -d` starten. Casdoor lauscht danach auf `127.0.0.1:8000`. Beim ersten Aufruf vergeben Sie das Passwort für `admin` auf der Willkommensseite (seit 4.19 gibt es kein Standardpasswort mehr). Für HTTPS schalten Sie einen Reverse Proxy (Caddy, Traefik, Nginx) vor. Das Image `casbin/casdoor` gibt es für amd64 und arm64; legen Sie den Tag fest, statt `latest` zu nutzen.

## Voraussetzungen

- [ ] **Docker Engine 20.10+** und **Docker Compose v2** (Befehl `docker compose`). Falls noch nicht installiert: [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Linux-Host oder VM, x86_64 oder ARM64.
- [ ] Mindestens 1 CPU-Kern und 1 GB RAM, 2 GB freier Speicher für Images, Datenbank und Logs; 2 Kerne und 4 GB RAM geben Reserve für weitere Dienste.
- [ ] Für HTTPS im Produktivbetrieb ein Reverse Proxy (Caddy, Traefik oder Nginx), siehe Schritt 6, und ein DNS-Eintrag wie `auth.{{domain}}`.
- [ ] Ein zufälliges PostgreSQL-Passwort mit mindestens 16 Zeichen, z. B. aus `openssl rand -hex 24`.

## Eckdaten auf einen Blick

| Eigenschaft | Wert |
| --- | --- |
| Docker-Image | `casbin/casdoor:4.25.0` |
| Plattformen | linux/amd64, linux/arm64 |
| Webport | 8000 (konfigurierbar über `httpport` in app.conf) |
| Datenbank | PostgreSQL, MySQL 8+, SQLite (nur Test), CockroachDB, MSSQL, Oracle, TiDB |
| Protokolle | OAuth 2.0, OIDC, SAML, CAS, LDAP, SCIM 2.0, WebAuthn, TOTP, RADIUS |
| MFA-Methoden | TOTP (Authenticator-Apps), SMS, E-Mail, WebAuthn/FIDO2 |
| Lizenz | Apache 2.0 |

| Volume / Env | Bedeutung |
| --- | --- |
| `./conf:/conf` | Pflicht: Verzeichnis mit `app.conf` (Datenbank-Verbindung, HTTP-Port u. a.) |
| `./logs:/logs` | Empfohlen: Casdoor-Logdateien |
| `postgres_data:/var/lib/postgresql/data` | Pflicht für PostgreSQL: Persistenz der Datenbankdaten |
| `RUNNING_IN_DOCKER=true` | Pflicht in Docker: ersetzt `localhost` im DSN automatisch durch den richtigen Container-Hostnamen |
| `POSTGRES_PASSWORD` | Pflicht: sicheres Passwort für den PostgreSQL-Superuser |

## Schritt 1: Projektordner und Verzeichnisstruktur anlegen

Legen Sie den Projektordner an, z. B. `/opt/casdoor/`:

```bash
$ mkdir -p /opt/casdoor/conf /opt/casdoor/logs
$ cd /opt/casdoor
```

Casdoor läuft im Container als Benutzer mit UID/GID 1000. Damit er in `logs/` schreiben und `app.conf` lesen kann, übergeben Sie ihm die Verzeichnisse:

```bash
$ chown -R 1000:1000 /opt/casdoor/conf /opt/casdoor/logs
```

> **Prüfen:** Die Verzeichnisstruktur sieht so aus:
>
> ```bash
> $ ls -la /opt/casdoor/
> ```
>
> ```bash
> # Erwartete Ausgabe:
> # drwxr-xr-x  conf/   (Eigentümer: 1000)
> # drwxr-xr-x  logs/   (Eigentümer: 1000)
> ```

## Schritt 2: app.conf herunterladen und anpassen

Ohne `conf/app.conf` startet Casdoor nicht. Laden Sie die offizielle Vorlage:

Datei: `conf/app.conf`

```bash
curl -o /opt/casdoor/conf/app.conf \
  https://raw.githubusercontent.com/casdoor/casdoor/master/conf/app.conf
```

Die Vorlage ist auf MySQL eingestellt (`driverName = mysql`). Passen Sie mindestens diese Werte an:

```ini
; Datenbankverbindung für PostgreSQL
driverName = postgres
dataSourceName = user=casdoor password={{postgres_password}} host=db port=5432 sslmode=disable dbname=casdoor

; HTTP-Port (muss mit dem internen Port in compose.yaml übereinstimmen)
httpport = 8000

; Öffentliche URL, wichtig für OIDC-Redirect-URIs
; Lokal: http://localhost:8000
; Produktion: https://auth.{{domain}}
origin = http://localhost:8000

; Optional: Redis für Session-Caching
; redisEndpoint = redis:6379

; LDAP-Server-Port (Vorlage: 389)
; ldapServerPort = 389
```

Ersetzen Sie `IHR_SICHERES_PASSWORT` durch dasselbe Passwort, das Sie gleich in `.env` festlegen. PostgreSQL erwartet Schlüssel-Wert-Paare mit Leerzeichen, nicht das MySQL-Format `root:pass@tcp(...)`.

> **Prüfen:** Die Datei ist für UID 1000 lesbar:
>
> ```bash
> $ ls -la /opt/casdoor/conf/app.conf
> ```
>
> ```bash
> # Erwartete Ausgabe: -rw-r--r-- 1 1000 1000 ...
> ```

## Schritt 3: .env mit Datenbankpasswort anlegen

Legen Sie `.env` mit dem PostgreSQL-Passwort an, **exakt identisch** mit dem Wert in `app.conf`:

Datei: `app.conf`

```ini
# /opt/casdoor/.env
POSTGRES_PASSWORD={{postgres_password}}
```

Schränken Sie die Rechte ein, damit andere Systembenutzer das Passwort nicht lesen:

```bash
$ chmod 600 /opt/casdoor/.env
```

> **Prüfen:** ```bash
> $ ls -la /opt/casdoor/.env
> ```
>
> ```bash
> # Erwartete Ausgabe: -rw------- 1 root root ...
> # Das Passwort darf nicht leer sein:
> ```
>
> ```bash
> $ grep POSTGRES_PASSWORD /opt/casdoor/.env
> ```

## Schritt 4: compose.yaml erstellen und Stack starten

Erstellen Sie `/opt/casdoor/compose.yaml`. Der Stack besteht aus Casdoor und PostgreSQL 16. `condition: service_healthy` sorgt dafür, dass Casdoor erst startet, wenn die Datenbank bereit ist. Der Port ist nur an `127.0.0.1` gebunden: Solange das Standardpasswort gilt, darf Casdoor nicht aus dem Netz erreichbar sein. Der Healthcheck nutzt `wget`, das im Alpine-basierten Image enthalten ist.

Datei: `/opt/casdoor/compose.yaml`

```yaml
services:

  casdoor:
    image: casbin/casdoor:4.25.0
    container_name: casdoor
    restart: unless-stopped
    ports:
      - "127.0.0.1:8000:8000"
    volumes:
      - ./conf:/conf
      - ./logs:/logs
    environment:
      RUNNING_IN_DOCKER: "true"
    depends_on:
      db:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8000/api/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 30s

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

volumes:
  postgres_data:
```

Starten Sie den Stack:

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

Casdoor braucht beim ersten Start etwas Zeit für die Datenbankinitialisierung. Öffnen Sie den Browser erst, wenn im Log der Start des HTTP-Servers erscheint:

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

```bash
# Warten, bis der HTTP-Server auf Port 8000 gestartet ist
```

> **Prüfen:** ```bash
> $ docker compose ps
> ```
>
> ```bash
> # Erwartete Ausgabe (beide Container im Status "running" / "healthy"):
> # NAME           IMAGE                    STATUS
> # casdoor        casbin/casdoor:4.25.0    Up X minutes (healthy)
> # casdoor-db     postgres:16-alpine       Up X minutes (healthy)
>
> # API-Healthcheck per curl:
> ```
>
> ```bash
> $ curl -s http://localhost:8000/api/health
> ```
>
> ```bash
> # Erwartete Ausgabe: JSON mit "status":"ok"
> ```

## Schritt 5: Erst-Einrichtung in der WebUI

Öffnen Sie `http://localhost:8000` auf dem Server. Von einem anderen Rechner aus erreichen Sie die Oberfläche vor der Proxy-Einrichtung per SSH-Tunnel: `ssh -L 8000:127.0.0.1:8000 benutzer@server`. Das erste Konto ist:

1. **Organisation:** `built-in`
2. **Benutzername:** `admin`
3. **Passwort:** legen Sie beim ersten Aufruf selbst fest

**Seit Version 4.19 gibt es kein Standardpasswort `123` mehr.** Eine neue Installation legt `admin` ohne Passwort an und meldet im Log: `The password of built-in/admin is not set, open Casdoor in the browser to set it, or set initAdminPassword before the first start`. Beim ersten Aufruf zeigt Casdoor eine Willkommensseite, auf der Sie das Admin-Passwort vergeben. Nur die erste Anfrage zählt: Der erste Aufruf setzt das Passwort, ein zweiter Versuch endet mit `Unauthorized operation`, und die Anmeldung mit `123` scheitert. Erledigen Sie diesen Schritt deshalb sofort nach dem Start, solange der Port nur an `127.0.0.1` gebunden ist. Alternativ setzen Sie das Passwort vor dem allerersten Start über den Schlüssel `initAdminPassword` in `conf/app.conf` oder eine gleichnamige Umgebungsvariable. Seit Version 4.0 nutzt Casdoor eine neue Oberfläche; Menübezeichnungen können von älteren Screenshots abweichen.

In der Weboberfläche können Sie:

1. **Organisationen** anlegen und Benutzer verwalten (einzeln oder per Import)
2. **Anwendungen** registrieren und Client-ID und Client-Secret erzeugen
3. **Identity Provider** einbinden (Google, GitHub, Microsoft Entra ID, LDAP, SAML-IdP)
4. **MFA erzwingen**, pro Organisation, Anwendung oder Benutzer
5. **RBAC/ABAC-Richtlinien** über die integrierte Casbin-Engine definieren

Um eine Anwendung wie Gitea oder Nextcloud anzubinden, legen Sie unter *Applications* eine neue Anwendung an und tragen Name, Redirect-URI und Protokoll (OIDC/OAuth 2.0) ein. Casdoor zeigt danach Client-ID und Client-Secret, die Sie in der Ziel-App als OIDC-Provider hinterlegen. Die Endpunkte liegen unter der öffentlichen Adresse aus `origin`, weil der Browser sie direkt aufruft:

1. Authorization: `https://auth.{{domain}}/login/oauth/authorize`
2. Token: `https://auth.{{domain}}/api/login/oauth/access_token`
3. UserInfo: `https://auth.{{domain}}/api/userinfo`
4. Discovery (für Apps mit automatischer Erkennung): `https://auth.{{domain}}/.well-known/openid-configuration`

> **Prüfen:** Melden Sie sich ab und mit dem neuen Admin-Passwort wieder an. Die Anmeldung mit `123` muss scheitern, und das Dashboard zeigt Organisationen, Benutzer und Anwendungen. `curl -s http://localhost:8000/api/get-init-admin-status` liefert danach `"data":false`; `true` bedeutet, dass das Admin-Passwort noch offen ist.

## Schritt 6: HTTPS mit Reverse Proxy (Produktion)

Für den Produktivbetrieb terminiert ein Reverse Proxy TLS vor Casdoor und leitet an `127.0.0.1:8000` weiter. Caddy holt Zertifikate von Let's Encrypt automatisch; die Einrichtung beschreibt [Caddy als Reverse Proxy einrichten](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung).

Setzen Sie danach `origin` in `conf/app.conf` auf die öffentliche HTTPS-Adresse:

Datei: `conf/app.conf`

```ini
origin = https://auth.{{domain}}
```

Starten Sie Casdoor neu:

```bash
$ cd /opt/casdoor
$ docker compose restart casdoor
```

> **Prüfen:** ```bash
> # HTTPS-Antwort des Reverse Proxys prüfen:
> ```
>
> ```bash
> $ curl -I https://auth.{{domain}}
> ```
>
> ```bash
> # Erwartete Ausgabe: HTTP/2 200 (oder 302 zum Login)
> ```

## Schritt 7: Updates und Backup

Casdoor veröffentlicht häufig neue Versionen; Version 4.0 (September 2026) brachte eine neue Weboberfläche mit geänderten Pfaden für statische Dateien. Legen Sie deshalb den Tag fest (hier `casbin/casdoor:4.25.0`), lesen Sie vor jedem Update die Release Notes und sichern Sie vorher die Datenbank. Neuer Tag, `docker compose pull` und `docker compose up -d` genügen, Casdoor passt das Datenbankschema beim Start selbst an. Von 4.15 auf 4.20 genügt derselbe Ablauf. Ein Bestand mit 4.15.0 und geändertem Admin-Passwort lief nach dem Tausch auf 4.20.0 sofort wieder (healthy), das geänderte Passwort galt weiter, `123` wurde abgelehnt. Seit 4.18 bringt das Image eigene Container-Healthchecks mit, seit 4.19 widerruft Casdoor Tokens bei Passwortänderung und kann die Selbstregistrierung abschalten, die Registrierung über externe Provider aber erlauben. 4.20 ergänzt einen Forward-Auth-Endpunkt für Traefik, Caddy und Nginx sowie einen Marketplace für Integrationen. Bestandsinstallationen behalten ihr Admin-Passwort; die neue Willkommensseite betrifft nur leere Datenbanken. Von 4.20 auf 4.21 genügt derselbe Ablauf. Eine frisch eingerichtete 4.20.0-Instanz lief nach dem Tausch auf 4.21.0 sofort wieder `healthy`, das gesetzte Admin-Passwort galt weiter, ein falsches Passwort wurde abgelehnt, und `/api/get-init-admin-status` meldete `false`. Von 4.21 auf 4.22 genügt ebenfalls derselbe Ablauf. Beim Update von 4.21.0 auf 4.22.0 lief Casdoor nach dem Tausch sofort wieder `healthy`, das gesetzte Admin-Passwort galt weiter, ein falsches Passwort wurde abgelehnt, und die OIDC-Discovery unter `/.well-known/openid-configuration` antwortete. Version 4.23.0 bringt laut Release Notes unter anderem einen Endpunkt zum Widerruf von Tokens nach RFC 7009, SAML-NameID-Vorlagen je Anwendung, die Konfiguration `webAuthnRpId` und `webAuthnRpOrigins` für Passkeys auf benachbarten Subdomains, eine Einstellungsseite für den Datenbank-Verbindungspool, Zähler für erfolgreiche und fehlgeschlagene Anmeldungen in den Prometheus-Metriken sowie die Möglichkeit, auf der Zustimmungsseite nur einen Teil der angefragten Scopes zu gewähren. Die Docker-Images tragen jetzt zusätzlich die Tags `vX.Y.Z`, `X.Y` und `X`. Auch das Update von 4.22.0 auf 4.23.0 verlief so: Casdoor war nach dem Tausch sofort wieder `healthy`, das gesetzte Admin-Passwort galt weiter, ein falsches Passwort wurde abgelehnt, die Ersteinrichtung blieb abgeschlossen, und die OIDC-Discovery antwortete. Version 4.24.0 ergänzt laut Release Notes eine globale Standard-Aufbewahrungsdauer für Datensätze, eigene Beschreibungen und Vorschau-Tags für Anmeldeseiten sowie `private_key_jwt` für dynamisch registrierte Clients. `/api/userinfo` antwortet ohne oder mit ungültigem Token jetzt mit `401` und einem `WWW-Authenticate`-Header. Neue Pflichtoptionen gibt es nicht. Beim Update von 4.23.0 auf 4.24.0 war Casdoor nach dem Tausch sofort wieder `healthy`, das gesetzte Admin-Passwort galt weiter, `123` wurde abgelehnt, die Ersteinrichtung blieb abgeschlossen, die OIDC-Discovery antwortete mit `200`, und `/api/userinfo` ohne Token lieferte `401` mit `WWW-Authenticate: Bearer`. Version 4.25.0 ergänzt laut Release Notes unter anderem Twilio Verify als SMS-Anbieter, einen Link auf die Datenschutzerklärung neben den Nutzungsbedingungen auf Anmelde- und Registrierungsseite, Eingabefelder mit einem Kästchen je Ziffer für Bestätigungscodes, eine Organisationsoption, die die MFA-Abfrage für RADIUS überspringt, und Token Exchange mit ID-JAGs für MCP-Clients; der Endpunkt für die Geräteanmeldung antwortet jetzt mit den Fehlercodes nach RFC 8628. Neue Pflichtoptionen nennen die Release Notes nicht. Beim Update von 4.24.0 auf 4.25.0 war Casdoor nach dem Tausch sofort wieder `healthy`, das gesetzte Admin-Passwort galt weiter, `123` wurde abgelehnt, die Ersteinrichtung blieb abgeschlossen, die OIDC-Discovery antwortete mit `200`, und `/api/userinfo` ohne Token lieferte weiter `401` mit `WWW-Authenticate: Bearer`. Zum Aktualisieren passen Sie den Tag in `compose.yaml` an und führen aus:

```bash
$ cd /opt/casdoor
$ docker compose pull
$ docker compose up -d
```

Für das Backup zählen zwei Dinge:

1. **PostgreSQL-Datenbank:** enthält Benutzer, Anwendungen, Richtlinien und Zertifikate. Sichern Sie sie regelmäßig mit `pg_dump`, siehe [PostgreSQL-Backup automatisieren mit cron](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud).
2. **conf/app.conf:** enthält die Datenbankverbindung und `origin`.

Sicherung direkt aus dem laufenden Container:

```bash
docker exec casdoor-db pg_dump -U casdoor casdoor \
  | gzip > /opt/backups/casdoor_$(date +%Y%m%d).sql.gz
```

> **Prüfen:** ```bash
> $ docker compose ps
> ```
>
> ```bash
> # Beide Container müssen nach dem Update "healthy" sein:
> # casdoor     casbin/casdoor:4.25.0    Up X minutes (healthy)
> # casdoor-db  postgres:16-alpine       Up X minutes (healthy)
>
> # Backup-Datei vorhanden und nicht leer:
> ```
>
> ```bash
> $ ls -lh /opt/backups/casdoor_*.sql.gz
> ```

## Troubleshooting / Typische Fehler

**„config file not found“ beim Start**

`./conf` ist gemountet, aber `conf/app.conf` fehlt. Laden Sie die Datei wie in Schritt 2.

**„dial tcp 127.0.0.1:5432: connect: connection refused“**

In `app.conf` steht `localhost` als Datenbank-Host. Tragen Sie den Service-Namen `db` ein oder setzen Sie `RUNNING_IN_DOCKER: "true"`.

**„invalid DSN“ bei PostgreSQL**

Das MySQL-Format funktioniert nicht. Richtig: `user=casdoor password=SECRET host=db port=5432 sslmode=disable dbname=casdoor`.

**„502 Bad Gateway“**

Casdoor initialisiert noch. Beobachten Sie `docker compose logs -f casdoor` und warten Sie auf den Start des HTTP-Servers.

**„Permission denied“ in `./logs`**

Der Ordner gehört root. Führen Sie `chown -R 1000:1000 conf/ logs/` auf dem Host aus.

**Casdoor startet vor der Datenbank**

`depends_on` ohne `condition: service_healthy`. Definieren Sie den Healthcheck beim `db`-Service wie gezeigt.

**LDAP-Port 389 lässt sich nicht binden**

Setzen Sie in `app.conf` einen höheren Port, z. B. `ldapServerPort = 1389`, und veröffentlichen Sie ihn in `compose.yaml`.

**Interner Port stimmt nicht**

Steht `httpport = 9000` in `app.conf`, aber `8000` in `compose.yaml`, ist der Dienst nicht erreichbar. Beide Werte müssen übereinstimmen.

**Anmeldung bei der Ziel-App scheitert mit Redirect-Fehler**

`origin` oder die Redirect-URI der Anwendung stimmt nicht exakt mit der aufgerufenen Adresse überein (Protokoll, Hostname, Pfad).

## Häufige Fragen

### Welche Datenbank soll ich verwenden?

PostgreSQL ist für den Produktivbetrieb die naheliegende Wahl, MySQL 8.0+ funktioniert ebenfalls. SQLite eignet sich nur für Tests, etwa mit dem Image `casbin/casdoor-all-in-one`; ohne Volume gehen die Daten beim Neuerstellen des Containers verloren.

### Wie integriere ich Nextcloud oder Gitea als SSO-Client?

Legen Sie in Casdoor unter *Applications* eine Anwendung mit der Redirect-URI der Ziel-App an und wählen Sie OIDC. In Nextcloud oder Gitea tragen Sie Client-ID, Client-Secret und die Discovery-URL `https://auth.{{domain}}/.well-known/openid-configuration` ein.

### Wie aktiviere ich MFA für alle Benutzer?

In den Einstellungen der Organisation erzwingen Sie MFA für alle Mitglieder. Unterstützt werden TOTP (Authenticator-Apps), SMS, E-Mail und Sicherheitsschlüssel per WebAuthn/FIDO2. MFA lässt sich auch pro Anwendung oder Benutzer aktivieren.

### Wie aktiviere ich HTTPS?

Über einen Reverse Proxy, der HTTPS auf Port 443 terminiert und an `127.0.0.1:8000` weiterleitet. Danach setzen Sie `origin = https://auth.{{domain}}` und starten Casdoor neu (Schritt 6).

### Sollte ich :latest oder eine feste Version verwenden?

Eine feste Version. Mit `:latest` zieht `docker compose pull` jederzeit eine neue Version, auch über Major-Grenzen wie 3.x auf 4.x hinweg. Update-Hinweise ohne automatisches Aktualisieren liefern Diun oder WUD, siehe [Docker-Container automatisch aktualisieren](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud).

### Kann Casdoor selbst als LDAP-Server agieren?

Ja, für ältere Anwendungen, die nur LDAP sprechen. Die Vorlage aktiviert den LDAP-Server auf Port 389 (`ldapServerPort`); veröffentlichen Sie den Port in `compose.yaml` nur, wenn Sie ihn brauchen, und nur im internen Netz. Casdoor stellt dann Benutzer und Gruppen aus demselben Benutzerstamm per LDAP bereit.

### Was ist SCIM 2.0 und wofür brauche ich es?

SCIM 2.0 (System for Cross-domain Identity Management) synchronisiert Benutzer und Gruppen automatisch zwischen Casdoor und Verzeichnisdiensten wie Microsoft Entra ID oder Okta. Neue Konten werden angelegt, gelöschte deaktiviert, ohne manuellen Import.

## Fazit

Casdoor bündelt OAuth 2.0, OIDC, SAML, LDAP-Server, RADIUS und WebAuthn mit einer Casbin-Autorisierung in einem Container, der wenig Ressourcen braucht. Gegenüber Keycloak ist der Betrieb einfacher, dafür fehlen Funktionen wie die Realm-Isolation. Für KMU, die eine zentrale Anmeldung für Docker-basierte Dienste suchen, ist Casdoor eine Option, sofern das Standardpasswort sofort geändert, der Tag festgelegt und die Oberfläche nur über HTTPS erreichbar ist. Als nächste Schritte empfehlen sich [Docker Compose absichern](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root) und der Vergleich in [Single Sign-On: Authentik vs. Authelia](https://s-edv.com/anleitungen/sso-authentik-authelia-traefik-forward-auth).

## Weiterführende Anleitungen und Quellen

1. [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
2. [Caddy als Reverse Proxy einrichten: Anfänger-Anleitung mit automatischem HTTPS](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung)
3. [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)
4. [Single Sign-On für den Self-Hosted-Stack: Authentik vs. Authelia mit Traefik Forward-Auth absichern](https://s-edv.com/anleitungen/sso-authentik-authelia-traefik-forward-auth)
5. [MySQL & PostgreSQL Backup automatisieren mit cron](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud)
6. [Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate im Vergleich](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud)
7. [Zitadel mit Docker installieren: Cloud-nativer Identity Server als Keycloak-Alternative](https://s-edv.com/anleitungen/zitadel-docker-identity-server)

Offizielle Quellen: [Casdoor-Dokumentation: Try with Docker](https://casdoor.ai/docs/basic/try-with-docker/) | [Casdoor GitHub-Repository](https://github.com/casdoor/casdoor) | [Casdoor Release Notes](https://github.com/casdoor/casdoor/releases) | [casbin/casdoor auf Docker Hub](https://hub.docker.com/r/casbin/casdoor).

## Passende Anleitungen auf S-EDV

1. [Pocket ID mit Docker Compose installieren: Passkey-SSO](https://s-edv.com/anleitungen/pocket-id-docker-compose-passkey-oidc)
2. [Logto mit Docker installieren: Auth-Infrastruktur mit OIDC](https://s-edv.com/anleitungen/logto-docker-auth-infrastruktur)
3. [Keycloak auf dem Synology NAS installieren: SSO mit OIDC und SAML](https://s-edv.com/anleitungen/keycloak-synology-sso-identity-provider)
