Single Sign-On für den Self-Hosted-Stack: Authentik vs. Authelia mit Traefik Forward-Auth absichern

Viele interne Apps hinter Traefik, etwa Traefik-Dashboard, Portainer oder Grafana, haben kein oder nur ein schwaches Login. Single Sign-On per ForwardAuth schließt die Lücke: Traefik fragt vor jeder Anfrage einen Authentifizierungsdienst, ob der Nutzer durchdarf. Die führenden Open-Source-Kandidaten sind Authelia und Authentik. Hier: Auswahl, Konfiguration, Fallstricke.

Voraussetzungen

1. Traefik (v2.11+ oder v3.x) mit Docker-Provider und API/Dashboard
2. Eigene Root-Domain mit DNS-Kontrolle (auth.example.com, *.example.com); reiner IP-Betrieb wird nicht unterstützt
3. Gültige TLS-Zertifikate für alle Subdomains (Traefik ACME oder Wildcard)
4. Gemeinsames Docker-Netzwerk für Traefik, Authelia/Authentik und die zu schützenden Apps
5. Server mit 2 CPU-Kernen (x86_64 oder ARM64); mindestens 512 MB freies RAM für Authelia, 2 GB für Authentik (Server + Worker + PostgreSQL), etwa 5 GB Speicher für Images und Datenbank
6. SMTP-Server oder -Relay (z. B. Mailjet, Brevo) für E-Mail-Verifizierung und Passwort-Reset
7. PostgreSQL (für Authentik zwingend; für Authelia optional, SQLite reicht für kleine Setups)

Schritt 1: Die richtige Lösung wählen

Die wichtigsten Unterschiede:

KMU-Faustregel: Nur Web-Apps, keine SAML-Dienste, unter 15 Nutzer: Authelia. Mit SAML, LDAP-Verzeichnis für Legacy-Systeme oder Self-Service-Passwort-Reset-Portal mit eigenen Flows: Authentik. Beides parallel geht auch: Authelia als ForwardAuth-Proxy für Apps ohne Login, Authentik als OIDC-Provider für Grafana, Nextcloud oder Gitea.

Verifizieren: Sie können für jede zu schützende App sagen, ob ForwardAuth reicht oder ob sie SAML, LDAP oder OIDC braucht, und haben daraus Authelia (Schritte 2 bis 4) oder Authentik (Schritte 5 bis 7) abgeleitet.

Schritt 2: Authelia installieren und grundlegend konfigurieren

Legen Sie ein Verzeichnis für Authelia und darin die configuration.yml an. Das Minimalbeispiel unten deckt Session-Management, Access Control und Storage ab. Achten Sie darauf, dass Authelia im selben Docker-Netzwerk wie Traefik erreichbar ist – zur Grundkonfiguration von Traefik mit Docker finden Sie Details in unserer Anleitung zu Traefik mit Docker als Reverse Proxy und HTTPS einrichten.

# docker-compose.yml für Authelia
services:
  authelia:
    image: authelia/authelia:4.39   # Minor-Version festschreiben, Updates bewusst einspielen
    container_name: authelia
    volumes:
      - ./authelia/config:/config
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`auth.example.com`)"
      - "traefik.http.routers.authelia.entrypoints=websecure"
      - "traefik.http.routers.authelia.tls=true"
      - "traefik.http.services.authelia.loadbalancer.server.port=9091"
    restart: unless-stopped

networks:
  proxy:
    external: true

Zentrale Konfiguration ./authelia/config/configuration.yml:

# Authelia configuration.yml – Minimales Produktions-Beispiel

identity_validation:
  reset_password:
    jwt_secret: 'SICHER_ZUFAELLIG_64_ZEICHEN_HIER_EINTRAGEN'

server:
  address: 'tcp://:9091'
  # Vertrauenswürdige Proxys legen Sie in Traefik fest (forwardedHeaders.trustedIPs), nicht hier

log:
  level: 'info'

totp:
  issuer: 'example.com'

authentication_backend:
  file:
    path: '/config/users_database.yml'

session:
  name: 'authelia_session'
  secret: 'SICHER_ZUFAELLIG_64_ZEICHEN_HIER_EINTRAGEN'
  same_site: 'lax'
  inactivity: '5m'
  expiration: '1h'
  remember_me: '1M'
  cookies:
    - domain: 'example.com'
      authelia_url: 'https://auth.example.com'
      default_redirection_url: 'https://www.example.com'

regulation:
  max_retries: 3
  find_time: '2m'
  ban_time: '5m'

storage:
  encryption_key: 'SICHER_ZUFAELLIG_64_ZEICHEN_HIER_EINTRAGEN'
  local:
    path: '/config/db.sqlite3'

notifier:
  smtp:
    address: 'smtp://mail.example.com:587'
    username: 'authelia@example.com'
    password: 'SMTP_PASSWORT'
    sender: 'Authelia <authelia@example.com>'

Die drei Platzhalter-Secrets erzeugen Sie je mit openssl rand -hex 32. Benutzer stehen in ./authelia/config/users_database.yml, den Passwort-Hash liefert docker compose run --rm authelia authelia crypto hash generate argon2. Ältere Beispiele setzen jwt_secret und default_redirection_url auf oberster Ebene; seit Authelia 4.38 gehören sie unter identity_validation.reset_password bzw. session.cookies.

Verifizieren: docker compose ps zeigt den Container authelia als running (healthy), docker compose logs authelia enthält keine Zeile mit level=error, und https://auth.example.com zeigt die Anmeldeseite.

Schritt 3: Authelia Access Control und MFA-Erzwingung konfigurieren

Das Access-Control-System ist einer der stärksten Aspekte von Authelia. Sie können pro Domain oder Subdomain entscheiden, ob keine Authentifizierung (bypass), ein Faktor (one_factor) oder MFA (two_factor) erforderlich ist. Wichtig: Setzen Sie immer default_policy: 'deny' – sonst sind neue Container ohne Authentifizierung erreichbar. Mehr zur allgemeinen MFA-Strategie finden Sie in unserer Anleitung zu Zwei-Faktor-Authentifizierung und MFA einführen.

# Authelia Access Control – MFA-Erzwingung per App
access_control:
  default_policy: 'deny'
  rules:
    - domain: 'public.example.com'
      policy: 'bypass'
    - domain: 'traefik.example.com'
      policy: 'one_factor'
    - domain: 'vault.example.com'
      policy: 'two_factor'
    - domain: '*.example.com'
      policy: 'one_factor'

Regeln werden von oben nach unten geprüft, die erste passende gewinnt; spezielle Domains stehen daher vor *.example.com. Block in die configuration.yml aus Schritt 2 einfügen, dann docker compose restart authelia.

Verifizieren: docker compose logs authelia zeigt nach dem Neustart keine Konfigurationsfehler, und nach Schritt 4 verlangt https://vault.example.com nach dem Passwort zusätzlich einen zweiten Faktor, https://traefik.example.com nur das Passwort.

Schritt 4: Traefik ForwardAuth-Middleware für Authelia einrichten

Die Middleware wird einmalig als Label am Authelia-Container oder in einer Traefik-Konfigurationsdatei definiert; jede zu schützende App bekommt nur noch das Middleware-Label.

# Traefik Middleware für Authelia (Docker Compose Labels)
# Middleware definieren (am Authelia-Container):
- "traefik.http.middlewares.authelia.forwardAuth.address=http://authelia:9091/api/authz/forward-auth"
- "traefik.http.middlewares.authelia.forwardAuth.trustForwardHeader=true"
- "traefik.http.middlewares.authelia.forwardAuth.maxResponseBodySize=8192"
- "traefik.http.middlewares.authelia.forwardAuth.authResponseHeaders=Remote-User,Remote-Groups,Remote-Name,Remote-Email"

# An App-Container anhängen:
- "traefik.http.routers.meine-app.middlewares=authelia@docker"

Nach der Anmeldung reicht Authelia Remote-User, Remote-Groups, Remote-Name und Remote-Email weiter, mit denen unterstützende Apps den Nutzer ohne eigene Authentifizierung erkennen.

Verifizieren: Ein privates Browserfenster auf https://meine-app.example.com leitet auf https://auth.example.com um; nach der Anmeldung landen Sie wieder in der App. Im Traefik-Dashboard steht die Middleware authelia@docker ohne Fehler am Router meine-app.

Schritt 5: Authentik installieren (Alternative für komplexere Anforderungen)

Authentik benötigt PostgreSQL. Seit 2025.10 entfällt Redis (ältere Compose-Beispiele enthalten ihn noch), seit 2025.12 erwartet Authentik ein Datenverzeichnis unter /data. Das Compose-File folgt der offiziellen Vorlage für 2026.8:

# docker-compose.yml für Authentik (Version 2026.8)
services:
  postgresql:
    image: docker.io/library/postgres:16-alpine
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d authentik -U authentik"]
      interval: 30s
      timeout: 5s
      retries: 5
    volumes:
      - postgresql_data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${PG_PASS}
      POSTGRES_USER: authentik
      POSTGRES_DB: authentik

  authentik_server:
    image: ghcr.io/goauthentik/server:2026.8
    restart: unless-stopped
    command: server
    shm_size: 512mb
    volumes:
      - ./data:/data
    environment:
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: authentik
      AUTHENTIK_POSTGRESQL__NAME: authentik
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
      # AUTHENTIK_REDIS__HOST leer lassen – Redis ab 2025.10 nicht mehr benötigt
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authentik.rule=Host(`auth.example.com`)"
      - "traefik.http.routers.authentik.entrypoints=websecure"
      - "traefik.http.routers.authentik.tls=true"
      - "traefik.http.services.authentik.loadbalancer.server.port=9000"
    ports:
      - '9000:9000'
      - '9443:9443'
    depends_on:
      postgresql:
        condition: service_healthy

  authentik_worker:
    image: ghcr.io/goauthentik/server:2026.8
    restart: unless-stopped
    command: worker
    shm_size: 512mb
    volumes:
      - ./data:/data
    environment:
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: authentik
      AUTHENTIK_POSTGRESQL__NAME: authentik
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
    networks:
      - proxy
    depends_on:
      postgresql:
        condition: service_healthy

volumes:
  postgresql_data:

networks:
  proxy:
    external: true

Die .env-Werte erzeugen echo "PG_PASS=$(openssl rand -base64 36 | tr -d '\n')" >> .env und echo "AUTHENTIK_SECRET_KEY=$(openssl rand -base64 60 | tr -d '\n')" >> .env. Nach dem ersten Start folgt der Setup-Assistent unter https://auth.example.com/if/flow/initial-setup/.

Verifizieren: docker compose ps zeigt postgresql, authentik_server und authentik_worker als laufend (PostgreSQL healthy), und der Setup-Assistent fragt nach E-Mail und Passwort für das Konto akadmin.

Schritt 6: Traefik ForwardAuth-Middleware für Authentik einrichten

Authentik nutzt den Embedded Outpost im authentik_server-Container auf Port 9000. Die Middleware ähnelt der von Authelia, mit anderen Headern und Endpunkt:

# Authentik Traefik Middleware (Docker Compose Labels auf App-Container)
# Embedded Outpost läuft auf authentik_server (Port 9000)

- "traefik.http.middlewares.authentik.forwardAuth.address=http://authentik_server:9000/outpost.goauthentik.io/auth/traefik"
- "traefik.http.middlewares.authentik.forwardAuth.trustForwardHeader=true"
- "traefik.http.middlewares.authentik.forwardAuth.authResponseHeaders=X-authentik-username,X-authentik-groups,X-authentik-email,X-authentik-name,X-authentik-uid,X-authentik-jwt,X-authentik-meta-jwks,X-authentik-meta-outpost,X-authentik-meta-provider,X-authentik-meta-app,X-authentik-meta-version"

Weitergereicht werden u. a. X-authentik-username, X-authentik-groups und X-authentik-email.

Voraussetzung: ein Proxy-Provider im Modus „Forward auth (single application)“ oder „Forward auth (domain level)“ samt Anwendung unter Applications.

Verifizieren: curl -I https://meine-app.example.com liefert ohne Anmeldung eine Weiterleitung (302) auf auth.example.com statt der App-Seite.

Schritt 7: Authentik Single-App-Modus – Pflicht-Route gegen Redirect-Loops

Häufigster Fallstrick bei Authentik mit Traefik: Im Single-App-Modus muss Traefik wissen, wohin /outpost.goauthentik.io/ auf der App-Domain zeigt, sonst entsteht nach dem Login ein Redirect-Loop. Der Router braucht eine höhere Priorität als der App-Router. Traefik setzt die Priorität standardmäßig auf die Länge der Regel; ein zu kleiner fester Wert würde den Outpost-Router dahinter stellen.

# Authentik Single-App-Modus: Zusätzliche Route für Outpost-Pfad (PFLICHT)
# Diese Labels kommen an den App-Container zusätzlich zur normalen Route:

- "traefik.http.routers.meine-app-outpost.rule=Host(`meine-app.example.com`) && PathPrefix(`/outpost.goauthentik.io/`)"
- "traefik.http.routers.meine-app-outpost.priority=100"
- "traefik.http.routers.meine-app-outpost.entrypoints=websecure"
- "traefik.http.routers.meine-app-outpost.tls=true"
- "traefik.http.routers.meine-app-outpost.service=authentik@docker"

# Normale App-Route (Standardpriorität = Länge der Regel, hier kleiner als 100):
- "traefik.http.routers.meine-app.rule=Host(`meine-app.example.com`)"
- "traefik.http.routers.meine-app.middlewares=authentik@docker"

Tragen Sie die Anwendung außerdem unter Applications → Outposts → Embedded Outpost → Edit → Selected Applications ein; sonst schlägt ForwardAuth ohne erklärenden Fehler fehl.

Verifizieren: Nach der Anmeldung in einem privaten Browserfenster landen Sie direkt in der App, ohne Weiterleitungsschleife; https://meine-app.example.com/outpost.goauthentik.io/ping antwortet mit 204.

Troubleshooting / Typische Fehler

1. Redirect-Loop bei Authentik (Single-App-Modus): Route für /outpost.goauthentik.io/ fehlt oder ist falsch priorisiert. Separaten Router mit PathPrefix und hoher Priorität (z. B. 100) auf den Authentik-Dienst anlegen (Schritt 7).
2. Falsche Cookie-Domain in Authelia: domain in session.cookies muss exakt die Root-Domain sein (z. B. example.com, nicht sub.example.com), sonst Endlosweiterleitung trotz Login.
3. Falsche Client-IP oder Authelia startet nicht: Einen Schlüssel server.trusted_proxies kennt Authelia nicht („configuration key not expected“). Welchen Proxys X-Forwarded-*-Header geglaubt werden, legen Sie in Traefik mit entryPoints.<name>.forwardedHeaders.trustedIPs fest, nur mit den Netzen eigener Proxys, niemals 0.0.0.0/0.
4. Authelia-URL nicht per HTTPS erreichbar: authelia_url und Redirects brauchen HTTPS; intern reicht HTTP, Traefik terminiert TLS.
5. Authentik-Anwendung nicht mit Outpost verknüpft: siehe Schritt 7, Selected Applications.
6. Redis in Authentik-Compose-Dateien: seit 2025.10 überflüssig; harmlos, verwirrt aber bei der Fehlersuche.
7. MFA-Bypass durch fehlende default_policy in Authelia: Ohne deny sind alle nicht aufgeführten Domains freigegeben. Immer default_policy: 'deny' setzen.
8. Authentik mit Subdirectory-Apps: ForwardAuth ist auf Subdomains ausgelegt; Apps unter Pfaden (z. B. example.com/app) verursachen Routing-Konflikte beim Outpost-Callback.
9. Traefik v2 vs. v3 bei Kubernetes-CRDs: apiVersion wechselt von traefik.containo.us/v1alpha1 (v2) zu traefik.io/v1alpha1 (v3); ein falsches wird still ignoriert.

Häufige Fragen

Kann Authelia Apps schützen, die kein eigenes Login haben – z.B. das Traefik-Dashboard?

Ja, das ist der Hauptanwendungsfall. Das Label traefik.http.routers.meine-app.middlewares: 'authelia@docker' reicht; die App muss nichts von Authelia wissen.

Wann sollte ich Authentik statt Authelia wählen?

Bei SAML 2.0 (z. B. Microsoft 365 SSO, Nextcloud-SAML-App), LDAP für Legacy-Systeme, SCIM-Provisioning, Self-Service-Passwort-Reset mit anpassbaren Flows oder mehr als ca. 20 Nutzern mit zentraler Web-GUI-Verwaltung. Sonst siehe Faustregel in Schritt 1.

Kann ich Authelia und Authentik gleichzeitig betreiben?

Ja (Schritt 1): Beide teilen keine Ports und koexistieren im selben Docker-Netzwerk, solange die Middleware-Namen verschieden sind.

Wie erzwinge ich MFA für alle Nutzer in Authelia?

Mit default_policy: 'two_factor' global oder policy: 'two_factor' pro Domain für sensible Apps wie Passwortmanager oder Admin-Panels; per groups-Bedingung auch nur für bestimmte Gruppen.

Ist Authentik oder Authelia kostenlos?

Ja: Authelia unter Apache-2.0, Authentik als MIT-lizenzierte Community Edition. Authentiks Enterprise-Plan brauchen KMU-Setups meist nicht.

Funktioniert Authelia mit Traefik v3?

Ja. Die offizielle Doku nutzt traefik:v3.5; die Label-Konfiguration ist identisch, nur die Syntax der Traefik-Konfigurationsdatei unterscheidet sich.

Wie verwalte ich Nutzer in Authelia?

Im einfachsten Fall per users_database.yml mit gehashtem Passwort (argon2id empfohlen). Größere Setups binden LDAP (z. B. Active Directory oder OpenLDAP) als Quelle an; Authelia selbst ist kein LDAP-Server.

Fazit

Authelia schützt schlank Web-Apps per Subdomain, Authentik ist ein vollwertiger Identity Provider für SAML, LDAP oder ein User-Portal. Probleme entstehen meist bei Details: fehlende Outpost-Routen, falsche Cookie-Domain, falsch gesetzte trustedIPs in Traefik.

Wer den SSO-Stack weiter absichern möchte, findet ergänzende Grundlagen in unserer Anleitung zu Sichere Passwörter und Passkeys im Unternehmen. Für das Monitoring des laufenden Stacks empfiehlt sich Logs zentralisieren mit Grafana und Loki. Docker-Grundlagen liefert Docker-Netzwerke und Volumes verstehen.

Weiterführende Anleitungen und Quellen

1. Traefik mit Docker als Reverse Proxy und HTTPS einrichten
2. Docker Compose – Grundlagen und Stacks
3. Linux-Server absichern mit UFW und Fail2ban
4. Sichere Passwörter und Passkeys im Unternehmen

Quellen: Authelia Traefik Integration – Offizielle Dokumentation | Authentik Traefik Forward Auth – Offizielle Dokumentation | Authelia + Traefik Setup Guide – Offizieller Authelia-Blog | Authelia Session Configuration – Offizielle Dokumentation | Authelia vs. Authentik 2026 – Cerbos Blog | Traefik ForwardAuth Middleware – Offizielle Traefik-Dokumentation