Authentik auf Ubuntu mit Docker Compose installieren und absichern

Authentik ist ein Open-Source-Identity-Provider (IdP), der OAuth 2.0, OpenID Connect (OIDC) und SAML unterstützt. Durch die Bereitstellung von Authentik auf einer Cloud-Compute-Instanz behältst du die volle Kontrolle über die Authentifizierung, ermöglichst Single Sign-on (SSO) für interne Anwendungen und speicherst Benutzerdaten sicher in deiner eigenen Infrastruktur.

Diese Anleitung zeigt dir, wie du Authentik mit Docker Compose installierst, mit HTTPS hinter einem Reverse Proxy wie Caddy oder NGINX absicherst, deinen Ubuntu 24.04-Server härtest und einen OAuth 2.0-Client konfigurierst, um eine Beispielanwendung zu schützen. Nach Abschluss aller Schritte steht dir ein produktionsreifes, selbst gehostetes Authentifizierungssystem zur Verfügung.

Voraussetzungen

Bevor du beginnst, stelle sicher, dass die folgenden Anforderungen erfüllt sind:

• Zugriff auf einen Ubuntu-24.04-Server als Nicht-Root-Benutzer mit sudo-Rechten.
• Ein DNS-A-Record, der auf die IP-Adresse deines Servers zeigt (z. B. auth.example.com). Ersetze diesen Domainnamen im gesamten Leitfaden durch deine tatsächliche Domain.
• Installiertes Docker und Docker Compose auf deinem Server.

Authentik mit Docker Compose bereitstellen

Lege in deinem Home-Verzeichnis ein separates Projektverzeichnis für Authentik an.

$ mkdir ~/authentik && cd ~/authentik

Geheimen Schlüssel generieren

Erstelle einen 64-stelligen hexadezimalen Geheimschlüssel für Authentik.

$ openssl rand -hex 32

Kopiere den erzeugten Schlüssel, um ihn im nächsten Schritt zu verwenden.

Eine .env-Datei erstellen

Speichere deine Konfigurationsdaten in einer .env-Datei.

$ nano .env

Füge den folgenden Inhalt ein, um die Umgebungsvariablen festzulegen:

# Datenbankkonfiguration
PG_DB=authentik
PG_USER=authentik
PG_PASS=<POSTGRES_USER_PASSWORD>

# Geheimschlüssel für Authentik
AUTHENTIK_SECRET_KEY=<64_CHAR_SECRET_KEY>

# Optional: Feste Image-Version definieren
# AUTHENTIK_TAG=2025.8.4

# Lokale Portzuweisungen
COMPOSE_PORT_HTTP=127.0.0.1:9000
COMPOSE_PORT_HTTPS=127.0.0.1:9443

Ersetze <POSTGRES_USER_PASSWORD> und <64_CHAR_SECRET_KEY> durch dein eigenes sicheres Passwort und den zuvor generierten Schlüssel. Speichere die Datei anschließend.

Docker-Compose-Manifest herunterladen

Lade die offizielle docker-compose.yml-Datei aus der Authentik-Dokumentation herunter.

$ wget -O docker-compose.yml https://docs.goauthentik.io/docker-compose.yml

Container starten

Starte Authentik und alle zugehörigen Dienste im Hintergrundmodus.

$ sudo docker compose up -d

Laufende Dienste überprüfen

Zeige alle Container an und überprüfe, ob alle Dienste fehlerfrei laufen.

$ sudo docker compose ps

Beispielausgabe:

NAME                     IMAGE                                  COMMAND                  SERVICE      CREATED          STATUS                    PORTS
authentik-postgresql-1   docker.io/library/postgres:16-alpine   "docker-entrypoint.s…"   postgresql   25 min ago    Up (healthy)    5432/tcp
authentik-redis-1        docker.io/library/redis:alpine         "docker-entrypoint.s…"   redis        25 min ago    Up (healthy)    6379/tcp
authentik-server-1       ghcr.io/goauthentik/server:2025.8.4    "dumb-init -- ak ser…"   server       25 min ago    Up (healthy)    127.0.0.1:9000->9000/tcp, 127.0.0.1:9443->9443/tcp
authentik-worker-1       ghcr.io/goauthentik/server:2025.8.4    "dumb-init -- ak wor…"   worker       25 min ago    Up (healthy)

Caddy oder NGINX mit HTTPS konfigurieren

Stelle sicher, dass deine Domain korrekt auf die öffentliche IP-Adresse des Servers zeigt, auf dem Authentik läuft. Die Ausstellung eines TLS-Zertifikats schlägt fehl, wenn DNS-Einträge falsch sind oder die benötigten Ports gesperrt sind.

Firewall-Status prüfen

Überprüfe den aktuellen Status der Uncomplicated Firewall (UFW).

$ sudo ufw status

Wenn die Firewall als inaktiv angezeigt wird, aktiviere sie und erlaube den SSH-Zugriff:

$ sudo ufw enable && sudo ufw allow 22

HTTP- und HTTPS-Ports freigeben

Öffne die Ports 80 (HTTP) und 443 (HTTPS), um Webzugriffe und verschlüsselten Datenverkehr zu ermöglichen.

$ sudo ufw allow 80
$ sudo ufw allow 443

Detaillierten Firewall-Status anzeigen

$ sudo ufw status verbose

Caddy Webserver installieren

Installiere Caddy über den Paketmanager. Er dient als Reverse Proxy für Authentik.

$ sudo apt update
$ sudo apt install -y caddy

Caddyfile erstellen und konfigurieren

Bearbeite die Caddy-Konfigurationsdatei, um eingehende HTTPS-Anfragen an den Authentik-Dienst weiterzuleiten.

$ sudo nano /etc/caddy/Caddyfile

Lösche die Standardkonfiguration und füge Folgendes hinzu:

auth.example.com {
    reverse_proxy 127.0.0.1:9000
}

Speichere die Datei und schließe sie anschließend.

Konfiguration formatieren und validieren

Nutze die integrierten Caddy-Werkzeuge, um die Konfigurationsdatei zu formatieren und zu prüfen.

$ sudo caddy fmt --overwrite /etc/caddy/Caddyfile
$ sudo caddy validate --config /etc/caddy/Caddyfile

Caddy-Dienst neu laden

Starte den Caddy-Webserver neu, um die Änderungen zu übernehmen.

$ sudo systemctl reload caddy

Caddy erstellt und erneuert TLS-Zertifikate automatisch, wenn deine DNS-Einträge korrekt gesetzt sind und die Ports 80/443 erreichbar sind.

Erste Authentik-Einrichtung durchführen

Nach der Bereitstellung öffne im Browser die Setup-Seite, um das erste Administratorkonto zu erstellen.

https://auth.example.com/if/flow/initial-setup/

Gib deine E-Mail-Adresse und ein sicheres Passwort ein, um die Administrator-Einrichtung abzuschließen und Zugriff auf das Authentik-Dashboard zu erhalten.

Fehlerbehebung beim Caddy-Start

Wenn Authentik im Browser nicht erreichbar ist, überprüfe die Caddy-Protokolle auf mögliche Konfigurationsfehler.

$ sudo journalctl -u caddy --no-pager -n 100

Achte auf Fehlermeldungen im Zusammenhang mit DNS-Auflösung, SSL-Zertifikaten oder fehlerhaften Proxy-Routen.

Beispielanwendung mit Authentik verbinden

In diesem Abschnitt registrierst du einen OAuth 2.0-Client in Authentik und richtest eine einfache Node.js-Anwendung ein, um die Authentifizierung per OAuth2 zu testen.

OAuth2-Client registrieren

Melde dich in der Administrationsoberfläche von Authentik an:

https://auth.example.com/if/admin/

Erstelle einen OAuth2/OpenID Provider für deine Testanwendung über den folgenden Pfad:

Applications → Providers → Create → OAuth2/OpenID Provider

• Name: Sample App Provider
• Authorization Flow: default-provider-authorization-explicit-consent

Unter Protocol Settings konfigurierst du:

• Client Type: Confidential
• Redirect URIs/Origins (RegEx): https://app.example.com/auth/callback

Erzeuge und speichere anschließend Client ID und Client Secret.

Unter Advanced Flow Settings wähle:

• Authentication Flow: default-authentication-flow
• Invalidation Flow: Standard beibehalten (optional)

Unter Advanced Protocol Settings:

• Subject Mode: Basierend auf der gehashten Benutzer-ID

Erstelle anschließend eine Anwendung, die mit diesem Provider verknüpft ist:

Applications → Applications → Create

• Name: Sample Web App
• Slug: sample-web-app
• Provider: Wähle Sample App Provider
• Policy Engine Mode: ANY
• Launch URL: https://auth.example.com

Node.js OAuth2-Beispielanwendung

Folge diesen Schritten, um eine einfache Webanwendung einzurichten und die Authentifizierung über den Authorization Code Flow mit Authentik zu testen.

Beispielprojekt herunterladen

$ git clone https://github.com/example/code-samples.git
$ cd code-samples/authentik-oauth2-demo-app

npm installieren

$ sudo apt install -y npm

Projektabhängigkeiten installieren

$ npm install

Sitzungsgeheimnis generieren

$ openssl rand -hex 32

Umgebungsvariablen konfigurieren

$ nano .env

Füge folgende Werte in die Datei ein:

AUTHENTIK_URL=https://auth.example.com
PUBLIC_BASE_URL=https://app.example.com
CLIENT_ID=<CLIENT_ID_FROM_AUTHENTIK_PROVIDER>
CLIENT_SECRET=<CLIENT_SECRET_FROM_AUTHENTIK_PROVIDER>
SESSION_SECRET=<RANDOM_SESSION_SECRET_GENERATED_ABOVE>
PORT=3000

Ersetze jeden Platzhalter durch die entsprechenden Werte aus deiner Authentik-Konfiguration:

• AUTHENTIK_URL → URL deiner Authentik-Instanz
• PUBLIC_BASE_URL → URL deiner Beispiel-App
• CLIENT_ID und CLIENT_SECRET → Zugangsdaten aus deinem Authentik-Provider
• SESSION_SECRET → zufällig generierter Schlüssel aus dem vorherigen Schritt

Anwendung starten

$ npm start &

Richte einen Reverse Proxy und SSL für die Beispiel-App ein – analog zur Authentik-Konfiguration, jedoch über Port 3000.

Öffne dann im Browser:

https://app.example.com

Klicke auf Login with Authentik, melde dich mit deinen Zugangsdaten an und du wirst nach erfolgreicher Anmeldung auf die geschützte Seite weitergeleitet.

Fehlerbehebung

Wenn die Verbindung oder Authentifizierung fehlschlägt, führe folgende Schritte zur Fehleranalyse durch:

• Überprüfe die Einstellungen von Authentik Provider und Application – insbesondere die Redirect URI (https://app.example.com/auth/callback).
• Analysiere die Authentik-Protokolle, um mögliche Fehler während der Anmeldung oder beim Token-Austausch zu erkennen:

$ sudo docker compose logs -f server

• Achte auf Warnungen oder Fehler in Bezug auf OAuth2-Flows, Redirect-URIs oder Authentifizierungsprobleme.
• Stelle sicher, dass dein Reverse Proxy (Caddy oder NGINX) Anfragen korrekt an 127.0.0.1:9000 weiterleitet und HTTPS richtig konfiguriert ist.
• Bei OAuth2-State-Konflikten lösche Cookies oder teste im privaten Browsermodus.

Fazit

Du hast erfolgreich eine selbst gehostete Authentik-Instanz mit Docker Compose eingerichtet, sie mit HTTPS abgesichert und eine Node.js-Anwendung über OAuth2-SSO angebunden. Auf dieser Basis kannst du weitere Anwendungen integrieren, E-Mail-Authentifizierungen aktivieren und deine Identitätsinfrastruktur skalieren – bei voller Kontrolle über die Benutzerdaten.