Wer Traefik als Reverse Proxy betreibt, hat die halbe Arbeit bereits getan – aber viele interne Apps wie das Traefik-Dashboard, Portainer oder Grafana haben kein eigenes Login oder ein schwaches. Single Sign-On per ForwardAuth schließt diese Lücke: Traefik leitet jede Anfrage zuerst an einen Authentifizierungsdienst weiter, der entscheidet, ob der Nutzer durchdarf. Die beiden führenden Open-Source-Kandidaten heißen Authelia und Authentik. Diese Anleitung hilft dir, die passende Lösung für dein Setup zu wählen, erklärt die komplette Konfiguration und zeigt, wie du typische Fallstricke vermeidest.

Voraussetzungen

Laufender Traefik Reverse Proxy (v2.11+ oder v3.x) mit aktiviertem Docker-Provider und API/Dashboard
Eigene Root-Domain mit DNS-Kontrolle (Subdomains wie auth.example.com, *.example.com) – reiner IP-Betrieb wird nicht unterstützt
Gültige TLS-Zertifikate für alle Subdomains (Let's Encrypt via Traefik ACME oder Wildcard-Zertifikat)
Gemeinsames Docker-Netzwerk, in dem Traefik, Authelia/Authentik und alle zu schützenden Apps kommunizieren können
Mindestens 512 MB freies RAM für ein Authelia-Setup; mindestens 1–2 GB für Authentik (Server + Worker + PostgreSQL)
SMTP-Server oder -Relay (z.B. Mailjet, Brevo) für E-Mail-Verifizierung und Passwort-Reset
PostgreSQL-Instanz (für Authentik zwingend; für Authelia optional, SQLite reicht für kleine Setups)

Schritt 1: Die richtige Lösung wählen

Bevor du konfigurierst, triff eine bewusste Entscheidung. Die folgende Tabelle fasst die wichtigsten Unterschiede zusammen:

Kriterium	Authelia	Authentik
Docker-Image-Größe	~20 MB	~500 MB
RAM im Leerlauf	~30 MB	~200–400 MB (Server + Worker + PostgreSQL)
Datenbank	SQLite (klein) oder PostgreSQL/MySQL	PostgreSQL (Pflicht)
Redis	Optional	Ab 2025.10 nicht mehr benötigt
OIDC-Provider	Ja (Beta Stage 7/8, gilt als stabil)	Ja (produktionsreif)
SAML 2.0	Nein (Issue #493, kein Zeitplan)	Ja
LDAP-Server	Nein	Ja
SCIM-Provisioning	Nein	Ja
Passkeys / WebAuthn	Ja (ab v4.38 mehrere Credentials, ab v4.39 Passwordless)	Ja
Web-UI für Admins	Minimal	Vollwertig
Traefik-Integration	ForwardAuth direkt	ForwardAuth via Outpost
Lizenz	Apache 2.0 (kostenlos)	MIT Community Edition (kostenlos); Enterprise kostenpflichtig
Empfohlen für	Bis ~15 Nutzer, nur Web-Apps, kein SAML	Ab ~20 Nutzer, SAML/LDAP-Bedarf, Self-Service-Portal

KMU-Faustregel: Wenn du nur Web-Apps schützen willst, keine SAML-fähigen Dienste betreibst und unter 15 Nutzer hast, wähle Authelia. Sobald du SAML, ein LDAP-Verzeichnis für Legacy-Systeme oder ein Self-Service-Passwort-Reset-Portal mit eigenen Flows brauchst, ist Authentik die richtige Wahl. Beides gleichzeitig zu betreiben ist möglich: Authelia als ForwardAuth-Proxy für alle Apps ohne eigenes Login, Authentik als OIDC-Provider für Apps wie Grafana, Nextcloud oder Gitea.

Schritt 2: Authelia installieren und grundlegend konfigurieren

Erstelle ein Verzeichnis für Authelia und lege die configuration.yml an. Das Minimalbeispiel unten deckt Session-Management, Access Control und Storage ab. Achte darauf, dass Authelia im selben Docker-Netzwerk wie Traefik erreichbar ist – zur Grundkonfiguration von Traefik mit Docker findest du 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:latest
    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

Die zentrale Konfigurationsdatei ./authelia/config/configuration.yml:

# Authelia configuration.yml – Minimales Produktions-Beispiel

jwt_secret: 'SICHER_ZUFAELLIG_64_ZEICHEN_HIER_EINTRAGEN'

default_redirection_url: 'https://www.example.com'

server:
  address: 'tcp://:9091'
  trusted_proxies:
    - '172.16.0.0/12'   # Standard Docker-Bridge-Netzwerk
    - '10.0.0.0/8'
    - '192.168.0.0/16'
  # Nur eigene Proxy-IP-Bereiche – NIEMALS 0.0.0.0/0 !

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>'

Schritt 3: Authelia Access Control und MFA-Erzwingung konfigurieren

Das Access-Control-System ist einer der stärksten Aspekte von Authelia. Du kannst pro Domain oder Subdomain entscheiden, ob keine Authentifizierung (bypass), ein Faktor (one_factor) oder MFA (two_factor) erforderlich ist. Wichtig: Setze immer default_policy: 'deny' – sonst sind neue Container ohne Authentifizierung erreichbar. Mehr zur allgemeinen MFA-Strategie findest du 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'

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

Die Middleware wird einmalig als Label am Authelia-Container oder als Traefik-Konfigurationsdatei definiert. Danach reicht es, bei jeder zu schützenden App das Middleware-Label anzuhängen – die App selbst muss nichts wissen.

# 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 erfolgter Authentifizierung gibt Authelia die Header Remote-User, Remote-Groups, Remote-Name und Remote-Email an die App weiter. Damit kann die App – sofern sie es unterstützt – den eingeloggten Nutzer identifizieren, ohne eigene Authentifizierung.

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

Authentik benötigt PostgreSQL. Ab Version 2025.10 ist Redis als Abhängigkeit entfallen – viele ältere Compose-Beispiele im Netz enthalten noch einen Redis-Container, der jetzt überflüssig ist. Das folgende Compose-File ist auf dem aktuellen Stand:

# docker-compose.yml für Authentik (ab Version 2025.10)
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:2025.10
    restart: unless-stopped
    command: server
    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:2025.10
    restart: unless-stopped
    command: worker
    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

Nach dem ersten Start erreichst du den Authentik-Setup-Wizard unter https://auth.example.com/if/flow/initial-setup/.

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

Authentik nutzt den sogenannten Embedded Outpost, der im authentik_server-Container auf Port 9000 läuft. Die Middleware-Definition sieht ähnlich wie bei Authelia aus, hat aber andere Header und einen anderen 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"

Authentik gibt nach erfolgreicher Authentifizierung u.a. X-authentik-username, X-authentik-groups und X-authentik-email weiter – vergleichbar mit Authelias Remote-*-Headern.

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

Das ist der häufigste Fallstrick bei Authentik mit Traefik. Im „Single-App-Modus" muss Traefik wissen, wohin /outpost.goauthentik.io/ auf der App-Domain zeigt. Ohne diese zusätzliche Route entsteht ein Redirect-Loop nach dem Login. Der Router muss eine höhere Priorität als der App-Router haben:

# 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=15"
- "traefik.http.routers.meine-app-outpost.entrypoints=websecure"
- "traefik.http.routers.meine-app-outpost.tls=true"
- "traefik.http.routers.meine-app-outpost.service=authentik_server@docker"

# Normale App-Route (niedrigere Priorität, Standard ist 1):
- "traefik.http.routers.meine-app.rule=Host(`meine-app.example.com`)"
- "traefik.http.routers.meine-app.middlewares=authentik@docker"

Vergiss außerdem nicht, die neue Anwendung in der Authentik-Web-UI unter Applications → Outposts → Embedded Outpost → Edit → Selected Applications einzutragen. Ohne diesen Schritt schlägt die ForwardAuth-Anfrage ohne erklärendem Fehlerhinweis fehl.

Troubleshooting / Typische Fehler

Redirect-Loop bei Authentik (Single-App-Modus): Fehlende oder falsch priorisierte Route für /outpost.goauthentik.io/. Fix: Separaten Router mit PathPrefix und priority: 15 anlegen, der auf den Authentik-Server zeigt (siehe Schritt 7).
Falsche Cookie-Domain in Authelia: Die domain in session.cookies muss exakt dem Root-Domain entsprechen (z.B. example.com, nicht sub.example.com). Folge: Endlosweiterleitung zur Auth-Seite trotz erfolgtem Login.
Authelia HTTP-500 durch fehlende trusted_proxies: Ohne Eintrag des Docker-Subnetzes kennt Authelia die echte Client-IP nicht. Mindest-Konfiguration: 172.16.0.0/12, 10.0.0.0/8, 192.168.0.0/16 – niemals 0.0.0.0/0.
Authelia-URL nicht per HTTPS erreichbar: Authelia besteht auf HTTPS für authelia_url und Redirects. Traefik übernimmt TLS-Terminierung; Authelia kann intern HTTP sprechen, muss aber nach außen unter einer HTTPS-URL erreichbar sein.
Authentik-Anwendung nicht mit Outpost verknüpft: Nach Anlage einer neuen Anwendung muss diese explizit unter Outposts → Embedded Outpost → Edit → Selected Applications eingetragen werden.
Veraltete Redis-Abhängigkeit in Authentik-Compose-Dateien: Viele im Netz verfügbare Beispiele enthalten noch einen Redis-Container. Ab Authentik 2025.10 ist Redis entfallen – ein solcher Container ist harmlos, kann aber bei der Fehlersuche verwirren.
MFA-Bypass durch fehlende default_policy in Authelia: Wird default_policy nicht auf deny gesetzt, sind alle nicht explizit aufgeführten Domains standardmäßig freigegeben. Immer explizit default_policy: 'deny' setzen.
Authentik mit Subdirectory-Apps: Authentik ForwardAuth ist auf Subdomain-Routing ausgelegt. Apps unter Pfaden (z.B. example.com/app) statt eigener Subdomains führen zu Routing-Konflikten beim Outpost-Callback.
Traefik v2 vs. v3 bei Kubernetes-CRDs: Das apiVersion wechselt von traefik.containo.us/v1alpha1 (v2) zu traefik.io/v1alpha1 (v3). Falsches apiVersion führt dazu, dass Middlewares still ignoriert werden.

Häufige Fragen

Ja, das ist der Hauptanwendungsfall von Authelia als Forward-Auth-Proxy. Das Label traefik.http.routers.meine-app.middlewares: 'authelia@docker' reicht vollständig aus; die App selbst muss nichts von Authelia wissen. Damit lassen sich Traefik-Dashboard, Portainer, Grafana ohne native Authentifizierung oder andere interne Tools zuverlässig absichern.

Wann sollte ich Authentik statt Authelia wählen?

Authentik ist die richtige Wahl, wenn mindestens eine dieser Anforderungen besteht: SAML 2.0 (z.B. für Microsoft 365 SSO, Nextcloud-SAML-App), LDAP-Verzeichnis für Legacy-Systeme, SCIM-Provisioning, Self-Service-Passwort-Reset-Portal mit anpassbaren Flows, oder mehr als ca. 20 Nutzer mit zentraler Benutzerverwaltung über eine Web-GUI. Für reine Web-App-Setups unter 15 Nutzern ohne SAML-Bedarf ist Authelia ressourcensparender und einfacher zu betreiben.

Kann ich Authelia und Authentik gleichzeitig betreiben?

Ja, das ist eine sinnvolle Kombination: Authelia schützt per ForwardAuth alle Apps ohne eigenes Login, während Authentik als OIDC-Provider für Apps mit nativer OIDC-Unterstützung (Nextcloud, Grafana, Gitea) agiert. Beide teilen keine Ports und können im selben Docker-Netzwerk koexistieren, solange die Traefik-Middleware-Namen unterschiedlich sind.

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

Über die Access-Control-Regeln: Setze default_policy: 'two_factor' für globale MFA-Pflicht, oder definiere pro Domain policy: 'two_factor' für sensible Apps wie Passwortmanager oder interne Admin-Panels. Alternativ kann MFA per groups-Bedingung nur für bestimmte Gruppen erzwungen werden.

Ist Authentik oder Authelia kostenlos?

Beide haben eine vollständig funktionsfähige kostenlose Open-Source-Version: Authelia unter Apache-2.0-Lizenz, Authentik als MIT-lizenzierte Community Edition. Authentik bietet zusätzlich einen kostenpflichtigen Enterprise-Plan – für typische KMU-Self-Hosted-Setups ist dieser nicht erforderlich.

Funktioniert Authelia mit Traefik v3?

Ja. Die offizielle Authelia-Dokumentation nennt explizit Traefik v3.7.1 und v2.11.46 als getestete Versionen (Stand 2025). Die Middleware-Konfiguration per Labels ist identisch; lediglich die Traefik-eigene Konfigurationsdatei-Syntax unterscheidet sich zwischen v2 und v3.

Wie verwalte ich Nutzer in Authelia?

Im einfachsten Fall per users_database.yml-Datei, in der Benutzer mit gehashtem Passwort (argon2id empfohlen) eingetragen werden. Für größere Setups unterstützt Authelia einen LDAP-Backend-Connect (z.B. zu Active Directory oder OpenLDAP) als Authentifizierungsquelle – Authelia selbst ist aber kein LDAP-Server.

Fazit

SSO im Self-Hosted-Stack ist mit Authelia oder Authentik und Traefik ForwardAuth kein Hexenwerk – aber die Entscheidung zwischen beiden Lösungen sollte bewusst getroffen werden. Authelia ist der schlanke, ressourcensparende Forward-Auth-Proxy für KMU, die ihre Web-Apps per Subdomain schützen wollen, ohne eine eigene IdP-Infrastruktur zu betreiben. Authentik liefert den vollen Funktionsumfang eines Identity Providers und ist die richtige Wahl, sobald SAML, LDAP oder ein selbstverwaltetes User-Portal ins Spiel kommen. Die häufigsten Probleme entstehen nicht bei der Grundkonfiguration, sondern bei Details: fehlende Outpost-Routen, falsche Cookie-Domain, vergessene trusted_proxies-Einträge. Mit den Configs aus dieser Anleitung und der Troubleshooting-Liste hast du die kritischsten Stolpersteine bereits im Blick.

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

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