TL;DR — Kurzzusammenfassung

Authelia als SSO- und 2FA-Authentifizierungsproxy einrichten. Behandelt Docker Compose, Traefik-Integration, TOTP, WebAuthn, LDAP-Backends und OpenID Connect.

Authelia ist ein Open-Source-Authentifizierungsportal, das als Forward-Auth-Companion für Ihren Reverse-Proxy fungiert. Anstatt jedem selbst gehosteten Dienst eigene Login-Formulare hinzuzufügen, fängt Authelia jede Anfrage ab, validiert die Sitzung und erzwingt 2FA-Richtlinien — alles über ein einziges Portal. Dieser Leitfaden behandelt ein vollständiges Produktions-Setup mit Docker Compose, Traefik, TOTP und einem OpenID Connect-Anbieter.

Voraussetzungen

  • Docker und Docker Compose v2 auf einem Linux-Host.
  • Funktionierender Traefik v2/v3 Reverse-Proxy (oder Nginx/Caddy — Integrationshinweise enthalten).
  • Eine Domain mit DNS, der auf Ihren Server zeigt (Authelia benötigt eine echte Domain für Cookies).
  • Grundkenntnisse in YAML und Container-Networking.

Architektur von Authelia

Der Anforderungsfluss:

  1. Der Browser fordert app.beispiel.de an.
  2. Traefik fängt ab und ruft den ForwardAuth-Endpunkt unter auth.beispiel.de/api/authz/forward-auth auf.
  3. Authelia prüft den Sitzungs-Cookie, wendet Zugriffskontrollregeln an und gibt 200 OK oder 401 Unauthorized zurück.
  4. Bei 401 leitet Traefik den Benutzer zum Authelia-Login-Portal weiter.
  5. Der Benutzer authentifiziert sich (Passwort + 2FA), erhält einen signierten Sitzungs-Cookie und wird zurückgeleitet.

Schlüsselkomponenten:

  • Authentifizierungsportal — Login-UI, bereitgestellt auf der Authelia-Subdomain.
  • Sitzungsspeicher — Redis für verteilte/HA-Deployments; In-Memory für einzelne Knoten.
  • Speicher-Backend — SQLite (Einzelknoten) oder PostgreSQL/MySQL für HA.
  • Richtlinien-Engine — Zugriffskontrollregeln werden von oben nach unten ausgewertet.

Schritt 1: Docker Compose Stack

Erstellen Sie /opt/authelia/docker-compose.yml:

version: "3.9"
networks:
  proxy:
    external: true

services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    volumes:
      - ./config:/config
    environment:
      - AUTHELIA_JWT_SECRET_FILE=/config/secrets/jwt_secret
      - AUTHELIA_SESSION_SECRET_FILE=/config/secrets/session_secret
      - AUTHELIA_STORAGE_ENCRYPTION_KEY_FILE=/config/secrets/storage_key
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`auth.beispiel.de`)"
      - "traefik.http.routers.authelia.entrypoints=websecure"
      - "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.authResponseHeaders=Remote-User,Remote-Groups,Remote-Name,Remote-Email"

  redis:
    image: redis:7-alpine
    container_name: authelia-redis
    restart: unless-stopped
    networks:
      - proxy
    volumes:
      - redis-data:/data

volumes:
  redis-data:

Secrets generieren:

mkdir -p /opt/authelia/config/secrets
tr -dc 'A-Za-z0-9' </dev/urandom | head -c 64 > /opt/authelia/config/secrets/jwt_secret
tr -dc 'A-Za-z0-9' </dev/urandom | head -c 64 > /opt/authelia/config/secrets/session_secret
tr -dc 'A-Za-z0-9' </dev/urandom | head -c 64 > /opt/authelia/config/secrets/storage_key

Schritt 2: Kernkonfiguration

Erstellen Sie /opt/authelia/config/configuration.yml:

server:
  host: 0.0.0.0
  port: 9091

log:
  level: info

totp:
  issuer: beispiel.de
  period: 30
  skew: 1

authentication_backend:
  file:
    path: /config/users.yml
    password:
      algorithm: argon2id
      iterations: 3
      memory: 65536
      parallelism: 4

access_control:
  default_policy: deny
  rules:
    - domain: "auth.beispiel.de"
      policy: bypass
    - domain: "*.beispiel.de"
      subject: "group:admins"
      policy: two_factor
    - domain: "intern.beispiel.de"
      networks:
        - 192.168.1.0/24
      policy: one_factor

session:
  name: authelia_session
  domain: beispiel.de
  expiration: 1h
  inactivity: 5m
  remember_me: 1M
  redis:
    host: redis
    port: 6379

regulation:
  max_retries: 5
  find_time: 2m
  ban_time: 10m

storage:
  local:
    path: /config/db.sqlite3

notifier:
  smtp:
    host: smtp.beispiel.de
    port: 587
    username: noreply@beispiel.de
    password: ihrpasswort
    sender: "Authelia <noreply@beispiel.de>"

Schritt 3: Authentifizierungs-Backends

Dateibasiert (users.yml)

users:
  max:
    displayname: "Max Mustermann"
    password: "$argon2id$v=19$m=65536,t=3,p=4$..."
    email: max@beispiel.de
    groups:
      - admins
      - users

Argon2-Hashes generieren:

docker run authelia/authelia:latest authelia crypto hash generate argon2 --password 'ihrpasswort'

LDAP / Active Directory Backend

authentication_backend:
  ldap:
    address: ldap://ldap.beispiel.de:389
    implementation: activedirectory
    base_dn: dc=beispiel,dc=de
    username_attribute: sAMAccountName
    users_filter: "(&({username_attribute}={input})(objectClass=person))"
    groups_filter: "(member={dn})"
    user: cn=authelia,ou=Dienstkonten,dc=beispiel,dc=de
    password: ldappassword

Schritt 4: Zugriffskontrolle

Regeln werden von oben nach unten ausgewertet; die erste Übereinstimmung gewinnt.

FeldBeschreibungBeispiel
domainDomain(s) mit Platzhalter"*.beispiel.de"
resourcesURL-Pfad-Regex["^/api/.*"]
subjectBenutzer oder Gruppe"group:admins"
networksCIDR-Blöcke["10.0.0.0/8"]
policyAktionone_factor, two_factor, bypass, deny

Schritt 5: Zwei-Faktor-Methoden

TOTP

Benutzer registrieren sich im Authelia-Portal. Kompatibel mit Google Authenticator, Authy und jeder TOTP-App.

WebAuthn / FIDO2-Passkeys

Unterstützt in allen modernen Browsern. Benutzer registrieren einen Hardware-Schlüssel (YubiKey) oder Plattform-Authentifikator (Face ID, Windows Hello).

Duo Push

duo_api:
  hostname: api-XXXXXXXX.duosecurity.com
  integration_key: DIXXXXXXXXXXXXXXXXXX
  secret_key: ihr_duo_secret

Schritt 6: OpenID Connect-Anbieter

identity_providers:
  oidc:
    hmac_secret: ein_zufaelliges_geheimnis_mit_mindestens_32_zeichen
    clients:
      - id: grafana
        secret: "$argon2id$v=19$..."
        authorization_policy: two_factor
        redirect_uris:
          - "https://grafana.beispiel.de/login/generic_oauth"
        scopes:
          - openid
          - profile
          - email
          - groups
        pkce_challenge_method: S256

Authelia vs. Alternativen

FunktionAutheliaAuthentikKeycloakVouch ProxyOAuth2 Proxy
2FA/MFATOTP, WebAuthn, DuoTOTP, WebAuthn, DuoTOTP, WebAuthnJe nach IdPJe nach IdP
OIDC-AnbieterJa (v4.34+)Ja (vollst. IdP)Ja (Enterprise)NeinNein
LDAP/ADJaJaJaNeinNein
RAM~50 MB~300 MB~512 MB~10 MB~10 MB
KomplexitätNiedrig-MittelMittelHochNiedrigNiedrig

Fehlerbehebung

ProblemLösung
401-Schleife nach LoginPrüfen Sie, ob session.domain mit der Cookie-Domain aller geschützten Dienste übereinstimmt
2FA-Registrierungs-E-Mail nicht erhaltenSMTP mit startup_check_address testen; Notifier-Logs prüfen
WebAuthn-Registrierung schlägt fehlHTTPS muss aktiv sein; RP ID muss genau mit der Session-Domain übereinstimmen
LDAP-Auth schlägt fehllog.level: debug aktivieren; Bind-DN-Zugangsdaten und Base-DN prüfen
Regulierung sperrt legitime Benutzerregulation.find_time prüfen; max_retries erhöhen bei gemeinsam genutzten IPs

Zusammenfassung

  • Authelia ist ein leichtgewichtiger SSO + 2FA-Proxy mit integrierter Richtlinien-Engine.
  • Das Forward-Auth-Muster ermöglicht jedem Reverse-Proxy, Authentifizierung ohne Änderung der Upstream-Apps durchzusetzen.
  • TOTP, WebAuthn und Duo bieten flexible 2FA-Optionen.
  • Der OIDC-Anbieter erlaubt Authelia, als vollständiger IdP für OAuth2-Apps zu agieren.
  • Die Regulierung bietet nativen Schutz vor Brute-Force-Angriffen.

Verwandte Artikel