Authentik in Docker einrichten und betreiben - Die komplette Schritt-für-Schritt-Anleitung für SSO

, , , , , ,

Was ist Authentik und warum solltest du es nutzen?

Authentik ist ein Open-Source Identity Provider und Access Management System, das sich nahtlos in Docker-Umgebungen integrieren lässt. Mit Authentik kannst du zentralisiertes Single Sign-On (SSO) für all deine Self-Hosted-Anwendungen einrichten.

Statt dich bei jedem Service neu anzumelden, authentifizierst du dich einmal bei Authentik und erhältst Zugriff auf alle verbundenen Anwendungen. Das spart Zeit, erhöht die Sicherheit und vereinfacht das Nutzermanagement erheblich.

Voraussetzungen für die Installation

Bevor wir mit der Einrichtung beginnen, stelle sicher, dass folgende Komponenten bereitstehen:

  • Ein Server mit Docker und Docker Compose installiert
  • Mindestens 2 GB RAM (empfohlen: 4 GB)
  • Eine Domain oder Subdomain für Authentik
  • Ein Reverse Proxy wie Traefik oder Nginx Proxy Manager
  • Grundlegende Kenntnisse in Docker und YAML

Schritt 1: Erstelle die Verzeichnisstruktur

Erstelle zunächst ein dediziertes Verzeichnis für Authentik:

1
2
mkdir -p ~/authentik/{certs,media,custom-templates}
cd ~/authentik

Diese Struktur trennt Datenbank, Medien und Konfiguration übersichtlich voneinander.

Schritt 2: Die docker-compose.yml erstellen

Erstelle eine Datei namens docker-compose.yml mit folgendem Inhalt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
version: "3.4"

services:
  postgresql:
    image: docker.io/library/postgres:16-alpine
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 5s
    volumes:
      - database:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${PG_PASS}
      POSTGRES_USER: ${PG_USER}
      POSTGRES_DB: ${PG_DB}
    env_file:
      - .env

  redis:
    image: docker.io/library/redis:alpine
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 3s
    volumes:
      - redis:/data

  server:
    image: ghcr.io/goauthentik/server:2024.12.3
    restart: unless-stopped
    command: server
    container_name: authentik-server
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
    volumes:
      - ./media:/media
      - ./certs:/certs
      - ./custom-templates:/templates
    ports:
      - "9000:9000"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authentik.rule=Host(`auth.deinedomain.de`)"
      - "traefik.http.routers.authentik.entrypoints=websecure"
      - "traefik.http.routers.authentik.tls.certresolver=letsencrypt"
      - "traefik.http.services.authentik.loadbalancer.server.port=9000"
    depends_on:
      - postgresql
      - redis

  worker:
    image: ghcr.io/goauthentik/server:2024.12.3
    restart: unless-stopped
    command: worker
    container_name: authentik-worker
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
    user: root
    volumes:
      - ./media:/media
      - ./certs:/certs
      - ./custom-templates:/templates
      - /tmp:/tmp
    depends_on:
      - postgresql
      - redis

volumes:
  database:
  redis:

Schritt 3: Umgebungsvariablen konfigurieren

Erstelle eine .env Datei im selben Verzeichnis:

1
2
3
4
# PostgreSQL Konfiguration
PG_USER=authentik
PG_DB=authentik
PG_PASS=dein-sicheres-passwort-hier-einfuegen

Verwende für das Passwort einen sicheren Generator:

1
openssl rand -base64 36

Schritt 4: Container starten

Starte die Container mit folgendem Befehl:

1
docker compose up -d

Überprüfe den Status:

1
docker compose logs -f

Warte bis die Datenbank initialisiert ist und der Server bereit ist.

Schritt 5: Ersteinrichtung durchführen

Rufe deine konfigurierte Domain im Browser auf, zum Beispiel:
https://auth.deinedomain.de

Beim ersten Start erscheint der Setup-Assistent:

  1. Admin-Benutzer anlegen: Username, E-Mail-Adresse und Passwort festlegen
  2. Verifizierung: Prüfe ob die Domain korrekt erreichbar ist
  3. Sicherheitseinstellungen: Optional kannst du Zwei-Faktor-Authentifizierung aktivieren

Schritt 6: Anwendungen einbinden

Beispiel: Portainer über OAuth2 verbinden

  1. Gehe in Authentik zu Applications → Providers

  2. Klicke auf Create und wähle OAuth2/OIDC Provider

  3. Konfiguriere folgende Werte:

    • Name: portainer
    • Authorization Flow: default-provider-authorization-implicit-consent
    • Client Type: Public
    • Redirect URIs: https://portainer.deinedomain.de

  4. Erstelle eine neue Application unter Applications → Applications

    • Wähle den eben erstellten Provider
    • Vergebe einen Anzeigenamen

  5. In Portainer unter Settings → Authentication:

    • Authentication method: OAuth
    • Provider: Custom
    • Client ID: (aus Authentik kopieren)
    • Client Secret: (aus Authentik kopieren)
    • Authorization URL: https://auth.deinedomain.de/application/o/authorize/
    • Token URL: https://auth.deinedomain.de/application/o/token/
    • User info URL: https://auth.deinedomain.de/application/o/userinfo/

Schritt 7: Benutzer und Gruppen verwalten

Die Stärke von Authentik zeigt sich bei der Benutzerverwaltung:

  1. Verzeichnis synchronisieren: Verbinde LDAP, Active Directory oder externe Provider
  2. Gruppen erstellen: Organisiere Benutzer nach Berechtigungen (z.B. admins, users, readonly)
  3. Richtlinien definieren: Erstelle Zugriffsrichtlinien basierend auf Gruppen oder Attributen

Schritt 8: Backup und Wartung

Automatisches Backup einrichten

Erstelle ein Backup-Skript backup.sh:

1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/bash
BACKUP_DIR="/backups/authentik"
DATE=$(date +%Y%m%d_%H%M%S)

# Datenbank sichern
docker exec authentik-postgresql pg_dump -U authentik authentik > $BACKUP_DIR/db_$DATE.sql

# Medien sichern
tar -czf $BACKUP_DIR/media_$DATE.tar.gz ~/authentik/media

# Alte Backups löschen (älter als 30 Tage)
find $BACKUP_DIR -type f -mtime +30 -delete

Updates durchführen

Aktualisiere regelmäßig auf neue Versionen:

1
2
3
4
cd ~/authentik
docker compose pull
docker compose up -d
docker compose logs -f

Sicherheitstipps

  • Aktiviere immer HTTPS mit gültigem Zertifikat
  • Verwende starke Passwörter und Zwei-Faktor-Authentifizierung
  • Beschränke den Zugriff auf die Authentik-Admin-Oberfläche
  • Aktiviere Logging und Überwachung
  • Führe regelmäßig Sicherheitskopien durch

Fazit

Mit Authentik hast du eine professionelle SSO-Lösung in deiner Docker-Umgebung installiert. Die zentrale Authentifizierung vereinfacht nicht nur den Login-Prozess für Benutzer, sondern erhöht auch die Sicherheit durch konsistente Authentifizierungsstandards über alle Anwendungen hinweg.

Die Initialkonfiguration erfordert etwas Zeit, aber der Aufwand zahlt sich durch vereinfachte Nutzerverwaltung und verbesserte Sicherheit vielfach aus.

Nächste Schritte:

  • Implementiere regelmäßige Backups
  • Dokumentiere alle verbundenen Anwendungen
  • Erstelle einen Überwachungs-Alert für den SSO-Service