Zum Inhalt

RFC-003: Zentrales Identity-Management mit Authelia + lldap

Feld Wert
Status draft
Datum 2026-03-22
Betrifft homelab-external, novabrands-mgmt, homeserver
Tracking-Issues noch keine
Verwandt RFC-002 (VPN-Redesign), RFC-004 (VLANs, geplant)

Problem

Jeder Service verwaltet seine eigenen User und Credentials. VPN-Zugang laeuft ueber Pre-Auth-Keys ohne Multi-Faktor-Authentifizierung. Es gibt keinen zentralen Ort fuer User, Gruppen und Berechtigungen.

Konkrete Probleme:

  1. Kein SSO: User brauchen fuer jeden Service separate Zugangsdaten
  2. Kein MFA: VPN und die meisten Services haben nur Passwort-Schutz
  3. Dezentrale User-Verwaltung: User-Anlage und -Aenderungen muessen pro Service manuell durchgefuehrt werden
  4. Kein Self-Service: Passwort-Aenderung erfordert Admin-Eingriff
  5. Pre-Auth-Keys fuer Personen: VPN-Zugang ohne interaktiven Login, kein MFA moeglich
  6. Skalierungsproblem: Mit wachsendem Team (Robin, Thies, evtl. weitere) wird die dezentrale Verwaltung unuebersichtlich und fehleranfaellig

Vorschlag

Deployment eines zentralen Identity-Stacks auf dem Hetzner vServer bestehend aus:

  • lldap als leichtgewichtiger LDAP-Server (User, Gruppen, Web-UI, Passwort-Self-Service)
  • Authelia als OIDC-Provider und Traefik Forward-Auth (SSO, MFA)

Warum Authelia + lldap (und nicht Authentik/Keycloak)?

Kriterium Authelia + lldap Authentik Keycloak
RAM ~60-130 MB ~530-830 MB ~1-2 GB
Container 2 + PostgreSQL 4 + PostgreSQL 2 + PostgreSQL
Admin-UI lldap Web-UI Umfangreiche UI Umfangreiche UI
OIDC Ja Ja Ja
SAML Nein Ja Ja
Traefik Forward-Auth Nativ Via Outpost Aufwaendig
CX23-tauglich (4 GB) Problemlos Eng Knapp

Authelia + lldap deckt alle aktuellen Anforderungen ab (OIDC, Forward-Auth, LDAP, MFA, Admin-UI) bei einem Bruchteil der Ressourcen. Falls spaeter SAML benoetigt wird, ist eine Migration zu Authentik moeglich (lldap-User koennen exportiert werden).

Explizit nicht in Scope

  • SAML-Support — Aktuell nicht benoetigt. Migrationspfad zu Authentik wird als Zukunftsoption dokumentiert.
  • VLAN-spezifische Auth-Regeln — Details in RFC-004.

Ist-Zustand

Authentifizierung pro Service

Service Standort Aktuelle Auth Ziel-Auth
Headscale VPN Hetzner Pre-Auth-Keys OIDC (Personen), Pre-Auth-Keys (Server)
Headplane Hetzner API-Key Forward-Auth (Authelia)
Uptime Kuma Hetzner Eigener Login Forward-Auth (Authelia)
ntfy Hetzner Token-basiert Forward-Auth (Authelia)
Healthchecks Hetzner Eigener Login Forward-Auth (Authelia)
Nextcloud Novabrands Eigener Login OIDC + LDAP-Backend
OpenProject Novabrands Eigener Login LDAP-Backend
Coder Novabrands Eigener Login OIDC
Grafana Homelab Eigener Login OIDC (Phase 3c)
Immich Homelab Eigener Login OIDC (Web + Mobile-App via Custom-Scheme)
Jellyfin Homelab Eigener Login OIDC via SSO-Plugin (Web); Mobile-Apps nutzen native Jellyfin-Auth
Home Assistant Homelab Eigener Login OIDC (Web); Companion-App nutzt Long-Lived Access Token

Aktuelle User-Verwaltung

Kein zentrales Verzeichnis. Jeder Service hat eigene User-Datenbanken. Robin ist ueberall Admin, Thies hat noch keine Accounts (Novabrands noch nicht produktiv).

Soll-Zustand

Architektur

                    ┌──────────────────────────────────┐
                    │  Hetzner CX23                    │
                    │                                  │
                    │  Traefik ──┬── Authelia (OIDC +  │
                    │            │   Forward-Auth)     │
                    │            ├── lldap (Web-UI +   │
                    │            │   LDAP :3890/:6360) │
                    │            ├── Headscale         │
                    │            ├── Headplane         │
                    │            ├── Uptime Kuma       │
                    │            ├── ntfy              │
                    │            └── Healthchecks      │
                    │                                  │
                    │  identity-db (PostgreSQL)        │
                    │  headscale-db (PostgreSQL)       │
                    │  healthchecks-db (PostgreSQL)    │
                    └──────────┬───────────────────────┘
                               │ Tailscale VPN
                    ┌──────────┴───────────────────────┐
                    │  Novabrands (OVH)                │
                    │                                  │
                    │  Nextcloud ──→ lldap (LDAP)      │
                    │  OpenProject ──→ lldap (LDAP)    │
                    │  Coder ──→ Authelia (OIDC)       │
                    └──────────────────────────────────┘

                    ┌──────────────────────────────────┐
                    │  NUC (Homelab)                   │
                    │                                  │
                    │  Immich ──→ Authelia (OIDC,      │
                    │    Web + Mobile)                 │
                    │  Jellyfin ──→ Authelia (OIDC,    │
                    │    Web via Plugin)               │
                    │  Home Assistant ──→ Authelia     │
                    │    (OIDC Web, LLT Mobile)        │
                    │  Grafana ──→ Authelia (OIDC)     │
                    └──────────────────────────────────┘

OIDC-Endpoints von Authelia sind ueber die oeffentliche URL auth.homelab-external.robinwerner.net erreichbar. Homelab-Services bleiben unter *.home.robinwerner.net (interne Domain, oeffentlich via Traefik auf dem NUC). Der Browser-Redirect-Flow laeuft ueber das Internet, kein Tailscale-Hop im OIDC-Pfad. Forward-Auth-Anbindungen (nur falls spaeter benoetigt) wuerden ueber Tailscale laufen.

Datenfluss

VPN-Login (Personen):

  1. User oeffnet Tailscale-Client
  2. Headscale leitet zu Authelia-OIDC-Endpoint
  3. Authelia zeigt Login-Seite (Credentials aus lldap + MFA)
  4. Nach erfolgreicher Authentifizierung: Redirect zurueck zu Headscale
  5. Headscale erstellt/aktualisiert den Node

Web-SSO via Forward-Auth:

  1. User ruft uptimekuma.homelab-external.robinwerner.net auf
  2. Traefik fragt Authelia Forward-Auth-Endpoint
  3. Authelia prueft Session-Cookie
  4. Fehlende Session → Redirect zur Login-Seite (lldap + MFA)
  5. Nach Login → Redirect zurueck zum Service

Web-SSO via OIDC:

  1. User ruft cloud.novabrands.org auf
  2. Nextcloud leitet zu Authelia-OIDC-Endpoint
  3. Login (lldap + MFA) → Redirect mit Token zurueck
  4. Nextcloud validiert Token und erstellt/mappt User

Mobile-App OIDC (Immich):

  1. Familie oeffnet Immich-App und verbindet sich mit https://fotos.home.robinwerner.net
  2. App oeffnet System-Browser mit Authorization-Request an auth.homelab-external.robinwerner.net
  3. Authelia Login (lldap + MFA)
  4. Redirect auf Custom-Scheme app.immich:///oauth-callback
  5. System leitet zurueck in die Immich-App, Access/Refresh-Token wird lokal im Keychain gespeichert
  6. Folge-Starts: App sendet Token direkt, Session bleibt solange der Refresh-Token gueltig ist (30 Tage, siehe Session-Tabelle)

Home Assistant Companion-App (Fallback ohne OIDC):

  1. User loggt sich einmalig per Web in ha.home.robinwerner.net ein (OIDC via Authelia)
  2. In HA: Profil → Long-Lived Access Token generieren
  3. Token in Companion-App eintragen → ab dann silent-auth
  4. Begruendung: HA-Companion-Apps unterstuetzen kein OIDC und brechen hinter Forward-Auth. Offizielle HA-Empfehlung: mTLS oder VPN fuer zusaetzliche Schicht. Im Homelab-Kontext reicht der LLT, da der Zugang bereits ueber Traefik (HTTPS + CrowdSec) abgesichert ist.

LDAP-Direktanbindung:

  1. Nextcloud/OpenProject binden lldap als User-Backend an
  2. Verbindung laeuft ueber Tailscale-VPN (Novabrands → lldap auf Hetzner)
  3. User-Suche, Gruppen-Zuordnung, Passwort-Validierung via LDAP

Netzwerk

Verbindung Protokoll Pfad
Authelia → lldap LDAP (:3890) Lokal auf Hetzner (internal-Netzwerk)
Authelia → identity-db TCP (:5432) Lokal auf Hetzner (internal-Netzwerk)
lldap → identity-db TCP (:5432) Lokal auf Hetzner (internal-Netzwerk)
Headscale → Authelia OIDC (HTTPS) Lokal auf Hetzner
Traefik → Authelia Forward-Auth (HTTP) Lokal auf Hetzner
Novabrands → lldap LDAP (:3890) Ueber Tailscale-VPN (kein LDAPS, da VPN-Tunnel bereits verschluesselt)
Novabrands → Authelia OIDC (HTTPS) Ueber Tailscale-VPN
Homelab → Authelia OIDC (HTTPS) Ueber Tailscale-VPN

Container-Konfiguration

lldap:

Parameter Wert
Image lldap/lldap:latest (Version pinnen bei Deployment)
Netzwerke proxy, internal
Ports (intern) 3890 (LDAP), 6360 (LDAPS), 17170 (Web-UI)
Traefik-Route ldap.homelab-external.robinwerner.net → :17170 (nur Web-UI!)
Nicht exponiert Ports 3890/6360 sind nur im internal-Netzwerk erreichbar, nicht ueber Traefik
Datenbank PostgreSQL (identity-db, Datenbank lldap)

Authelia:

Parameter Wert
Image authelia/authelia:latest (Version pinnen bei Deployment)
Netzwerke proxy, internal
Port (intern) 9091
Traefik-Route auth.homelab-external.robinwerner.net → :9091
Datenbank PostgreSQL (identity-db, Datenbank authelia)
Session-Storage PostgreSQL (alternativ Redis, aber unnoetig bei kleiner User-Zahl)

identity-db (PostgreSQL):

Parameter Wert
Image postgres:17-alpine (Version wie bestehende DBs)
Netzwerk internal (kein Traefik-Zugriff)
Datenbanken authelia, lldap
Daten /opt/homelab-data/identity-postgres

LDAP-Gruppen-Struktur

Gruppe Zweck Mitglieder
vpn-users VPN-Zugang via OIDC robin, thies
homelab-admin Vollzugriff auf Homelab-Services (HA, Grafana, admin) robin
homelab-user Familien-Zugriff auf Immich und Jellyfin robin, $familienmitglieder
novabrands-admin Admin-Zugriff auf Novabrands-Services robin
novabrands-user User-Zugriff auf Novabrands-Services robin, thies
hetzner-admin Admin-Zugriff auf Headplane, Healthchecks robin
hetzner-user Lesezugriff auf Uptime Kuma, ntfy robin, thies

Die Gruppen-Struktur ist flach (keine Hierarchie). Robin ist explizit in allen benoetigten Gruppen Mitglied (hetzner-admin UND hetzner-user), da lldap keine automatische Gruppen-Vererbung unterstuetzt.

Authelia nutzt die Gruppen-Mitgliedschaft fuer Autorisierungsentscheidungen: - Forward-Auth prueft, ob der User in der fuer den Service benoetigten Gruppe ist - OIDC-Claims enthalten die Gruppen, sodass Services eigene Rollen-Mappings machen koennen

Zusammenspiel mit RFC-002 VPN-ACLs: Die VPN-ACLs (RFC-002, Regel 6) erlauben group:novabrands-team Zugriff auf tag:hetzner:80,443. Authelia-Forward-Auth verfeinert diesen Zugriff weiter: Thies kann zwar den Hetzner-Server ueber VPN auf Port 443 erreichen, aber Authelia sperrt Headplane (nur hetzner-admin). Das ist beabsichtigt (Defense-in-Depth: VPN-ACL = Netzwerkzugriff, Authelia = Applikationszugriff).

MFA-Konfiguration

Parameter Wert
TOTP Aktiviert (6-stellig, 30s Intervall, SHA1)
WebAuthn Aktiviert (FIDO2/Passkeys)
Pflicht Fuer alle User verpflichtend (erzwungen durch policy: two_factor in allen Access-Control-Regeln)
Enrollment User registrieren MFA-Geraete ueber Authelia-Portal

Headscale OIDC-Konfiguration

# headscale/config.yaml (Auszug)
oidc:
  issuer: https://auth.homelab-external.robinwerner.net
  client_id: headscale
  client_secret_path: /run/secrets/headscale_oidc_secret
  scope: ["openid", "profile", "email", "groups"]
  allowed_groups:
    - vpn-users

Headscale erstellt automatisch einen User basierend auf dem preferred_username-Claim. Die bestehenden User robin und thies (aus RFC-002) werden mit den OIDC-Claims gematcht. Wichtig: Die lldap-Usernamen muessen exakt (lowercase) den Headscale-Usernamen entsprechen, da Headscale case-sensitiv matcht.

Der groups-Scope muss in der Authelia-OIDC-Client-Konfiguration fuer den Headscale-Client explizit freigeschaltet werden, damit der groups-Claim im ID-Token enthalten ist.

Server-Nodes behalten Pre-Auth-Keys (headless, kein Browser-basierter Login moeglich).

Authelia Access-Control-Regeln

# authelia/configuration.yml (Auszug)
access_control:
  default_policy: deny
  rules:
    # Headplane: nur hetzner-admin
    - domain: headscale.homelab-external.robinwerner.net
      resources: ["^/admin.*$"]
      policy: two_factor
      subject:
        - "group:hetzner-admin"

    # Uptime Kuma: hetzner-user
    - domain: uptimekuma.homelab-external.robinwerner.net
      policy: two_factor
      subject:
        - "group:hetzner-user"

    # ntfy: hetzner-user
    - domain: ntfy.homelab-external.robinwerner.net
      policy: two_factor
      subject:
        - "group:hetzner-user"

    # Healthchecks: hetzner-admin
    - domain: healthchecks.homelab-external.robinwerner.net
      policy: two_factor
      subject:
        - "group:hetzner-admin"

    # lldap Web-UI: hetzner-admin
    - domain: ldap.homelab-external.robinwerner.net
      policy: two_factor
      subject:
        - "group:hetzner-admin"

    # Authelia Portal selbst: alle authentifizierten User
    - domain: auth.homelab-external.robinwerner.net
      policy: two_factor

Homelab-Services (Immich, Jellyfin, Home Assistant, Grafana) werden nicht ueber Forward-Auth geschuetzt, sondern ueber OIDC. Die Gruppen-Filterung erfolgt im jeweiligen Service anhand des groups-Claims im ID-Token.

OIDC-Clients fuer Homelab-Services

# authelia/configuration.yml (Auszug)
identity_providers:
  oidc:
    clients:
      - client_id: 'immich'
        client_name: 'Immich'
        client_secret: '$pbkdf2-sha512$...'
        public: false
        authorization_policy: 'two_factor'
        require_pkce: true
        pkce_challenge_method: 'S256'
        redirect_uris:
          - 'https://fotos.home.robinwerner.net/auth/login'
          - 'https://fotos.home.robinwerner.net/user-settings'
          - 'app.immich:///oauth-callback'
        scopes: ['openid', 'profile', 'email', 'groups']
        response_types: ['code']
        grant_types: ['authorization_code']
        # Immich prueft groups-Claim: nur homelab-user oder homelab-admin

      - client_id: 'jellyfin'
        client_name: 'Jellyfin'
        client_secret: '$pbkdf2-sha512$...'
        public: false
        authorization_policy: 'two_factor'
        require_pkce: true
        pkce_challenge_method: 'S256'
        redirect_uris:
          - 'https://stream.home.robinwerner.net/sso/OID/redirect/authelia'
        scopes: ['openid', 'profile', 'groups']
        response_types: ['code']
        grant_types: ['authorization_code']

      - client_id: 'home-assistant'
        client_name: 'Home Assistant'
        client_secret: '$pbkdf2-sha512$...'
        public: false
        authorization_policy: 'two_factor'
        require_pkce: true
        pkce_challenge_method: 'S256'
        redirect_uris:
          - 'https://ha.home.robinwerner.net/auth/oidc/callback'
        scopes: ['openid', 'profile', 'email', 'groups']
        response_types: ['code']
        grant_types: ['authorization_code']
        # HA prueft groups-Claim: nur homelab-admin

Verfuegbarkeit und Fallback

lldap laeuft zentral auf Hetzner. Bei einem Hetzner-Ausfall:

  • VPN: Bestehende Verbindungen bleiben aktiv (WireGuard-Tunnel sind persistent). Neue Anmeldungen sind nicht moeglich bis Hetzner wieder verfuegbar ist.
  • Novabrands-Services: LDAP/OIDC nicht erreichbar. Lokale Admin-Accounts auf jedem Service dienen als Break-Glass-Zugang.
  • Homelab-Services: Nur betroffen wenn bereits auf OIDC migriert. Services mit eigenem Login funktionieren weiterhin.

Lokale Admin-Accounts werden auf allen Services als Notfall-Zugang beibehalten. Credentials in Proton Pass (Vault "Break-Glass Accounts").

User-Deaktivierung

Wenn ein User entfernt werden soll, ist ein Zwei-Schritt-Prozess noetig:

  1. lldap: User deaktivieren/loeschen → verhindert neue Logins
  2. Headscale: Node(s) des Users loeschen → trennt aktive VPN-Verbindungen

Bestehende VPN-Tunnel sind WireGuard-basiert und persistent. Ein lldap-Lockout allein trennt die VPN-Verbindung nicht. Der Headscale-Schritt ist zwingend.

Backup

Die identity-db (PostgreSQL) wird in den bestehenden Backup-Zyklus aufgenommen:

  • pg_dump der Datenbanken authelia und lldap (wie bestehende Headscale-DB)
  • Sicherung durch Borgmatic auf Hetzner StorageBox
  • RPO: < 24 Stunden (wie bestehende Datenbanken)

Session- und Token-Lifetimes

Parameter Empfohlener Wert Beschreibung
Authelia Session 12h (inactivity), 24h (max) Browser-Session fuer Forward-Auth
OIDC Access Token 1h Kurzlebig, wird automatisch erneuert
OIDC Refresh Token 30d Ermoeglicht Token-Erneuerung ohne Re-Login
Headscale OIDC Nutzt Refresh Token VPN-Session bleibt aktiv solange Refresh Token gueltig

Konkrete Werte werden bei der Implementierung feingestellt.

Audit-Logging

Authelia loggt alle Authentifizierungsereignisse (Logins, fehlgeschlagene Versuche, MFA-Registrierungen). Die Logs werden ueber den bestehenden Alloy Log-Collector (Homelab-Monitoring-Stack) erfasst und in VictoriaLogs gespeichert.

Relevante Log-Events: - Erfolgreiche und fehlgeschlagene Login-Versuche - MFA-Enrollment und -Nutzung - OIDC-Token-Ausgabe - Access-Control-Entscheidungen (erlaubt/verweigert)

Betroffene Repos

Repo Aenderung
homelab-external lldap + Authelia + identity-db deployen, Headscale OIDC konfigurieren, Traefik Forward-Auth einrichten
novabrands-mgmt LDAP-Backend fuer Nextcloud/OpenProject, OIDC fuer Coder
homeserver OIDC fuer Immich, Jellyfin, Home Assistant (Web), Grafana; DNS-Eintraege fotos/stream/ha auf oeffentliche NUC-IP; Traefik-Middlewares fuer Rate-Limit + GeoBlock + CrowdSec
homelab-documentation Dokumentation aktualisieren

Umsetzungsphasen

Phase 1: Identity-Stack deployen

  1. Backup: Bestehende Hetzner-Config sichern (docker-compose, .env)
  2. Eigene PostgreSQL-Instanz (identity-db) aufsetzen
  3. lldap deployen, Web-UI ueber Traefik (ldap.homelab-external.robinwerner.net)
  4. Authelia deployen, Portal ueber Traefik (auth.homelab-external.robinwerner.net)
  5. Authelia an lldap anbinden (LDAP-Backend-Konfiguration)
  6. User robin und thies in lldap anlegen
  7. Gruppen anlegen (vpn-users, homelab-admin, novabrands-admin, novabrands-user, hetzner-admin, hetzner-user)
  8. MFA-Enrollment fuer beide User (TOTP + WebAuthn). Bootstrapping: Authelia-Access-Control temporaer auf one_factor setzen, damit User sich erstmalig einloggen und MFA registrieren koennen. Nach Enrollment aller User auf two_factor umschalten.
  9. Testen: Login ueber Authelia-Portal mit lldap-Credentials + MFA

Phase 2: Headscale OIDC-Integration

  1. OIDC-Client headscale in Authelia registrieren
  2. Headscale oidc-Sektion in config.yaml konfigurieren
  3. OIDC-User-Mapping testen: lldap-User robin → Headscale-User robin
  4. VPN-Login per Browser-Flow testen (Tailscale → Authelia → MFA → VPN)
  5. Uebergang Pre-Auth-Keys → OIDC: Die in RFC-002 erstellten Pre-Auth-Keys fuer persoenliche Geraete von Robin/Thies werden nicht erneuert, sobald OIDC funktioniert. Bestehende Geraete koennen sich per OIDC neu authentifizieren. Server-Nodes (NUC, Hetzner, Novabrands) behalten Pre-Auth-Keys (headless).
  6. Dokumentation aktualisieren (Headscale-Doku, VPN-Anleitung fuer Thies)

Phase 3: Service-SSO schrittweise ausrollen

Phase 3a: Hetzner-Services (Forward-Auth)

  1. Traefik-Middleware authelia konfigurieren (Forward-Auth-Endpoint)
  2. Headplane: Forward-Auth aktivieren (Gruppe hetzner-admin)
  3. Uptime Kuma: Forward-Auth aktivieren (Gruppe hetzner-user)
  4. ntfy: Forward-Auth aktivieren (Gruppe hetzner-user)
  5. Healthchecks: Forward-Auth aktivieren (Gruppe hetzner-admin)
  6. Testen: Alle Hetzner-Services erfordern Authelia-Login

Phase 3b: Novabrands-Services (OIDC + LDAP)

  1. OIDC-Clients fuer Nextcloud und Coder in Authelia registrieren
  2. Nextcloud: LDAP-Backend fuer User-Provisioning (lldap ueber VPN) + OIDC fuer Login konfigurieren. Strategie: LDAP synchronisiert User/Gruppen periodisch, OIDC wird fuer den eigentlichen Login verwendet. Nextcloud matcht OIDC-User auf den via LDAP provisionierten Account anhand der E-Mail-Adresse.
  3. OpenProject: LDAP-Backend konfigurieren
  4. Coder: OIDC-Provider konfigurieren
  5. Lokale Admin-Accounts als Break-Glass behalten
  6. Testen: Login auf Novabrands-Services mit lldap-Credentials + MFA

Phase 3c: Homelab-Services (Familie + Admin)

Voraussetzungen: Familienmitglieder in lldap anlegen, Gruppe homelab-user zuordnen. DNS fotos.home.robinwerner.net, stream.home.robinwerner.net, ha.home.robinwerner.net auf NUC-public-IP. Traefik auf dem NUC mit CrowdSec + Rate-Limit + GeoBlock (DE/AT/CH) vorbereitet.

  1. OIDC-Clients immich, jellyfin, home-assistant, grafana in Authelia registrieren (siehe Config-Auszug oben). Redirect-URIs inklusive Mobile-Custom-Scheme app.immich:///oauth-callback.
  2. Immich: OIDC-Provider in Admin-Settings konfigurieren. Auto-Register aktivieren, User-Mapping via preferred_username. Gruppen-Filter auf homelab-user oder homelab-admin.
  3. Jellyfin: jellyfin-plugin-sso installieren, Authelia als OIDC- Endpoint eintragen (client_secret_post, Pushed Authorization deaktivieren wegen bekannter Inkompatibilitaet — siehe Issue 9p4/jellyfin-plugin-sso#305). SSO-Plugin funktioniert nur im Web-Client; Mobile-Apps nutzen Jellyfin-native Auth. Optional Jellyfin-LDAP-Plugin fuer Passwort-Sync mit lldap, damit Familie ein Passwort fuer alle Services verwendet.
  4. Home Assistant: OIDC-Integration aktivieren (offizielle Core- Integration falls verfuegbar, sonst auth_oidc Custom-Component aus HACS). Companion-App: Long-Lived Access Token einmalig im Web generieren und in App eintragen. Kein Forward-Auth (bricht Companion-App).
  5. Grafana: OIDC-Provider konfigurieren, nur Gruppe homelab-admin.
  6. Testen pro Service: Web-Login mit lldap-Credentials + MFA, Mobile-App einmalig einloggen und auf persistente Session pruefen, Gruppen- Zugriffsregeln durch Test-User homelab-user verifizieren (darf nicht auf HA/Grafana zugreifen koennen).

Offene Aktionspunkte

  • lldap-Version und Image-Tag recherchieren und pinnen
  • Authelia-Version und Image-Tag recherchieren und pinnen
  • Authelia-Konfiguration im Detail ausarbeiten (Session, Storage, OIDC-Clients)
  • DNS-Eintraege auth.homelab-external.robinwerner.net und ldap.homelab-external.robinwerner.net anlegen
  • Secrets generieren (OIDC Client Secrets, JWT Secret, Session Secret, DB-Passwoerter)
  • Break-Glass-Accounts fuer Novabrands-Services in Proton Pass dokumentieren
  • Headscale OIDC-Konfiguration gegen aktuelle Headscale-Version validieren
  • ACL-Update (RFC-002): tag:hetzner → lldap Port 3890 fuer Novabrands-Zugriff (oder besser: Novabrands verbindet sich direkt zu lldap ueber Tailnet-IP)
  • OIDC-Client-Secrets fuer immich, jellyfin, home-assistant, grafana generieren (authelia crypto hash generate pbkdf2 --variant sha512)
  • DNS-Eintraege fotos.home.robinwerner.net, stream.home.robinwerner.net, ha.home.robinwerner.net auf NUC-public-IP pruefen/anlegen
  • Home-Assistant OIDC-Integration pruefen: offizielle Core-Integration (in Review, PR home-assistant/core) oder auth_oidc Custom-Component aus HACS (stabil, aber Third-Party)
  • Jellyfin-SSO-Plugin-Version gegen Authelia-Version testen (Pushed-Authorization-Bug mit Authelia 4.38+)
  • Familienmitglieder und deren E-Mail-Adressen fuer lldap-User-Anlage sammeln; Onboarding-Anleitung (TOTP-Setup) schreiben
  • NUC-Traefik um CrowdSec-Bouncer, Rate-Limit- und GeoBlock- Middlewares erweitern

Risiken

Risiko Mitigation
Hetzner-Ausfall = kein Login moeglich Break-Glass Admin-Accounts auf allen Services, VPN-Tunnel bleiben persistent
lldap ist relativ junges Projekt Aktive Entwicklung, Rust-basiert (stabil), Daten in PostgreSQL (portabel). Fallback: Export und Migration zu Authentik.
OIDC-Token-Ablauf sperrt VPN-Session Headscale holt periodisch neue Tokens. Session-Dauer in Authelia konfigurierbar.
Authelia-Konfigurationsfehler sperrt alles Config-Validierung vor Deployment (authelia validate-config). Traefik Forward-Auth hat trustForwardHeader-Einstellung. Rollback-Plan: Forward-Auth-Middleware entfernen.
lldap-Passwort-Hashes nicht kompatibel mit Migration lldap nutzt bcrypt (industriestandard). Export/Import zu den meisten IdPs moeglich.
MFA-Geraet verloren Admin kann MFA-Registrierung in lldap/Authelia zuruecksetzen. Prozess dokumentieren.
HA Companion-App unterstuetzt kein OIDC Long-Lived Access Token als Workaround; HA-native Auth bleibt aktiv. Risikoanalyse: LLT ist langlebig, darf nicht in Git/Chats/unverschluesselten Notizen landen. Bei Geraete-Verlust Token in HA widerrufen.
Jellyfin Mobile-Apps unterstuetzen SSO-Plugin nicht zuverlaessig Mobile-Apps nutzen Jellyfin-native Auth; Passwort-Sync via Jellyfin-LDAP-Plugin macht das transparent fuer Familie.
Oeffentlicher Zugriff auf NUC-Services (Port 443 offen) Defense-in-Depth: CrowdSec-Bouncer, Rate-Limit, GeoBlock (DE/AT/CH), Authelia-OIDC mit 2FA-Pflicht. Traefik und alle Services automatisch gepatcht via Watchtower/Renovate.
Hetzner-Ausfall sperrt Familie aus Immich/Jellyfin aus OIDC-Refresh-Token ist 30 Tage gueltig, laufende Sessions auf Mobile halten. Web-User muessen warten. Admin-Break-Glass: NUC-lokale Notfall-Accounts in Immich/Jellyfin (in Proton Pass).

Zukunftsaussichten

  • Migration zu Authentik: Falls SAML oder erweiterte Flows noetig werden. lldap-User koennen exportiert werden, Authelia-OIDC-Clients muessen in Authentik neu konfiguriert werden. Aufwand: mittel.
  • Hetzner-Upgrade: Bei steigender User-Zahl (>10) oder zusaetzlichen Services kann der CX23 auf CX32 (8 GB) oder CX42 (16 GB) geupgradet werden.
  • LDAP-Replikation: Falls Hochverfuegbarkeit fuer lldap noetig wird, ist eine Read-Replica auf Novabrands denkbar (erfordert Custom-Loesung, lldap hat keine native Replikation).
  • Passkeys: WebAuthn-Support in Authelia ermoeglicht passwortlosen Login ueber Passkeys. Kann aktiviert werden sobald alle User kompatible Geraete haben.