Wähle einen Artikel
Authelia auf vServer/VPS installieren
Authelia auf vServer/VPS installieren

VPS von dogado - gehostet in Deutschland

Behalte die Kontrolle über deinen vServer/VPS und steuere deine Online-Präsenz souverän. Profitiere von Hochgeschwindigkeits-NVME-SSDs, die bis zu 6-mal schneller sind als herkömmliche.

Server-Racks mit blauer Beleuchtung, Frontpaneele mit Laufwerkschächten, Lüftungsgitter und Netzwerkausrüstung.

0. Überblick

1. Authelia installieren

1.1 Einleitung

Authelia (https://www.authelia.com) ist ein Open-Source-Authentifizierungsserver. Bei jedem Aufruf eines geschützten Dienstes wird eine Anfrage an Authelia geschickt, ob der Benutzer angemeldet ist und die Berechtigung zum Besuch des Dienstes hat. Hat der Benutzer keine Berechtigung oder ist nicht angemeldet, so lässt sich die Webseite nicht öffnen. Dieser Schutz funktioniert unabhängig vom Dienst und wird in dieser Anleitung zusammen mit Traefik umgesetzt.

1.2 Infos zu yml-Dateien

Bei yml-Dateien ist es sehr wichtig, dass die Zeilen alle richtig eingerückt sind. Die Zeilen MÜSSEN immer mit der Leertaste eingerückt werden. Es dürfen KEINE Tabs enthalten sein.

1.3 Vorbereitung

Diese Anleitung basiert auf dem aktuellen Betriebssystem Debian 13. Authelia werden wir unter Docker realisieren. Dies ermöglicht uns später sehr schnelle Updates und eine schnelle Installation.

Um Authelia neben anderen Diensten auf unserem Server betreiben zu können, nutzen wir hier den Reverse Proxy Traefik. Die Anleitung dazu findet ihr hier: Traefik Reverseproxy auf vServer installieren

Wir führen nachfolgend alle Befehle mit dem Benutzer „root“ aus. Zu dem Benutzer könnt ihr mit folgendem Befehl wechseln:

sudo -i

1.3.1 Verzeichnis erstellen

Ihr erstellt zuerst ein Verzeichnis für Authelia und anschließend passt ihr die Rechte dazu an.

mkdir -p /opt/containers/authelia/config
chmod 700 /opt/containers/authelia/config

Ihr könnt hier auch ein anderes Verzeichnis verwenden. Dann müsst ihr aber die gesamte Anleitung entsprechend anpassen.

1.3.2 docker-compose.yml erstellen

Nun können wir mit der eigentlichen „Installation“ von Authelia beginnen. Dazu öffnet ihr folgende Datei:

nano /opt/containers/authelia/docker-compose.yml

Nun kopiert ihr folgenden Code in die Datei. Dieser Code ist unser Bauplan für unseren Authelia-Container.

services:
  authelia:
    image: authelia/authelia:4.39
    container_name: authelia
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    environment:
      - TZ=Europe/Berlin
    volumes:
      - ./config:/config
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`auth.euredomain.de`)"
      - "traefik.http.routers.authelia.entrypoints=websecure"
      - "traefik.http.routers.authelia.middlewares=security-headers@file"
      - "traefik.http.services.authelia.loadbalancer.server.port=9091"

networks:
  proxy:
    external: true

Ihr müsst hier nichts ändern. Alle Anpassungen erledigen wir später in Kapitel 1.6 mithilfe eines Skripts.

1.4 configuration.yml erstellen

Nun erstellen wir uns noch eine Konfigurationsdatei. Gebt dazu Folgendes ein:

nano /opt/containers/authelia/config/configuration.yml

Kopiert folgenden Inhalt:

###############################################################
#                  Authelia-Konfiguration                      #
###############################################################

theme: 'auto'

server:
  address: 'tcp://:9091/'

log:
  level: 'info'

totp:
  issuer: 'euredomain.de'

identity_validation:
  reset_password:
    jwt_secret: 'JWT_PLATZHALTER'

authentication_backend:
  file:
    path: '/config/users_database.yml'

access_control:
  default_policy: 'deny'
  rules:
    - domain: 'public.euredomain.de'
      policy: 'bypass'
    - domain: 'secure.euredomain.de'
      policy: 'one_factor'
    - domain: 'two.euredomain.de'
      policy: 'two_factor'

session:
  cookies:
    - domain: 'euredomain.de'
      authelia_url: 'https://auth.euredomain.de'
      expiration: '1 hour'
      inactivity: '5 minutes'

regulation:
  max_retries: 3
  find_time: '2 minutes'
  ban_time: '5 minutes'

storage:
  encryption_key: 'SCHLUESSEL_PLATZHALTER'
  local:
    path: '/config/db.sqlite3'

notifier:
  filesystem:
    filename: '/config/notification.txt'

Auch hier müsst ihr nichts anpassen, da dies später ein Skript erledigen wird.

Erklärung der einzelnen Abschnitte:

AbschnittErklärung
themeDie Anmeldeseite passt sich automatisch an den hellen oder dunklen Modus eures Geräts an.
totpEinstellungen für die Einmalcodes. Der issuer erscheint später als Name in eurer Authenticator-App.
identity_validationGeheimer Schlüssel, mit dem Authelia die Links zum Zurücksetzen von Passwörtern signiert.
authentication_backendDie Benutzer stehen in der Datei users_database.yml.
access_controlDie Regeln, welche Domain wie geschützt ist. default_policy: 'deny' sperrt alles, wofür keine Regel existiert. Die Domains „public“, „secure“ und „two“ nutzen wir gleich für unsere Testdienste.
sessionGilt für eure Hauptdomain und alle Subdomains. Eine Sitzung läuft nach einer Stunde ab, bei fünf Minuten Inaktivität schon früher. Wer beim Login „Angemeldet bleiben“ wählt, bleibt standardmäßig einen Monat eingeloggt.
regulationNach drei Fehlversuchen innerhalb von zwei Minuten wird der Benutzer für fünf Minuten gesperrt.
storageAuthelia speichert z. B. die Zwei-Faktor-Geräte in einer SQLite-Datenbank. Sensible Daten darin werden mit dem encryption_key verschlüsselt.
notifierNachrichten wie Bestätigungscodes landen zunächst in einer Datei. Wie ihr stattdessen E-Mails verschickt, zeigen wir weiter unten.

1.5 users_database.yml anlegen

Diese Datei dient später zum Speichern unserer Benutzer.

nano /opt/containers/authelia/config/users_database.yml

Kopiert nun folgende Platzhalter in die Datei:

users:
  BENUTZER_PLATZHALTER:
    disabled: false
    displayname: 'BENUTZER_PLATZHALTER'
    password: 'HASH_PLATZHALTER'
    email: 'MAIL_PLATZHALTER'
    groups:
      - 'admins'

1.6 Konfigurationsskript erstellen

Nun erstellt ihr ein Skript, welches die vorher erstellten Dateien an eure Domain und Benutzer anpasst.

nano /opt/containers/authelia/setup.sh

Inhalt:

#!/bin/bash
#

read -rp "Eure Domain ohne Subdomain (z. B. meinedomain.de): " DOMAIN
read -rp "Adresse der Anmeldeseite (z. B. auth.meinedomain.de): " AUTHHOST
read -rp "Benutzername für Authelia: " AUSER
read -rp "E-Mail-Adresse des Benutzers: " AMAIL
read -rsp "Passwort: " APASS
echo

JWT="$(tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 64)"
KEY="$(tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 64)"

echo "Passwort-Hash wird erzeugt, das dauert einen Moment ..."
HASH="$(docker run --rm authelia/authelia:4.39 authelia crypto hash generate argon2 --password "$APASS" | sed -n 's/^Digest: //p')"

sed -i "s|auth\.euredomain\.de|${AUTHHOST}|g; s|euredomain\.de|${DOMAIN}|g" docker-compose.yml config/configuration.yml
sed -i "s|JWT_PLATZHALTER|${JWT}|; s|SCHLUESSEL_PLATZHALTER|${KEY}|" config/configuration.yml
sed -i "s|BENUTZER_PLATZHALTER|${AUSER}|; s|MAIL_PLATZHALTER|${AMAIL}|; s|HASH_PLATZHALTER|${HASH}|" config/users_database.yml
unset APASS HASH JWT KEY

chmod 600 config/configuration.yml config/users_database.yml

echo
echo "Fertig."
echo "Portal: https://${AUTHHOST}"
echo "Login:  ${AUSER}"

Führt das Skript anschließend aus:

cd /opt/containers/authelia/
chmod +x setup.sh
./setup.sh

So sieht es bei mir aus:

Schwarzes Terminalfenster mit weißem Monospace-Text; Eingabeaufforderung root@testbereich:/opt/containers/authelia#.

1.7 Traefik anpassen

Damit Traefik bei geschützten Diensten die Anfrage korrekt an Authelia weiterleitet, legt ihr eine neue Middleware an.

nano /opt/containers/traefik/dynamic/authelia.yml

Inhalt:

http:
  middlewares:
    authelia:
      forwardAuth:
        address: "http://authelia:9091/api/authz/forward-auth"
        trustForwardHeader: true
        maxResponseBodySize: 8192
        authResponseHeaders:
          - "Remote-User"
          - "Remote-Groups"
          - "Remote-Email"
          - "Remote-Name"

Über das Label „authelia@file“ könnt ihr später Authelia zu jedem Container hinzufügen. Ein Neustart von Traefik ist nicht notwendig, da Dateien im Ordner „dynamic“ automatisch geladen werden.

2. Authelia starten

Nun können wir Authelia starten. Dazu gebt ihr Folgendes ein:

cd /opt/containers/authelia
docker compose up -d

Anschließend schaut ihr euch das Log an:

docker compose logs -f

Sobald ihr „Startup complete“ seht, ist Authelia fertig gestartet. Das Log könnt ihr dann mit „STRG+C“ beenden.

Schwarzes Terminalfenster mit vielen Logzeilen in Weiß und Gelb; Prompt oben links.

Nun könnt ihr auf eure Webseite (https://auth.euredomain.de) gehen und solltet Folgendes sehen:

Login-Formular mit Avatar, Felder für Benutzername und Passwort, Checkbox Angemeldet bleiben und blauer Button ANMELDEN.

Hier loggt ihr euch nun mit euren Zugangsdaten aus Kapitel 1.6 ein. Nach dem erfolgreichen Login solltet ihr Folgendes sehen:

Profilbild oben, 'Hallo test'; Pinke Buttons 'ABMELDEN | VERFAHREN'; Info-Karte mit blauem Symbol und Überschrift 'Einmal-Passwort'

3. Zwei-Faktor-Authentifizierung einrichten

Hierzu klickt ihr auf „Gerät registrieren“.

Blaues Info-Symbol, Überschrift 'Einmal-Passwort', Text zur Zwei-Faktor-Authentifizierung, Button 'Gerät registrieren'.

Anschließend wählt ihr „Einmal-Passwort“ aus:

Einstellungsseite mit zwei Karten: Einmal-Passwort und WebAuthn-Zugangsdaten, jeweils mit blauem HINZUFÜGEN-Button.

Ihr erhaltet nun die Meldung, dass ihr einen Einmal-Code per E-Mail erhalten habt. Da ihr zu diesem Zeitpunkt noch keine E-Mail eingerichtet habt, müsst ihr den Code aus folgender Datei beziehen:

cat /opt/containers/authelia/config/notification.txt

Der Inhalt sollte so aussehen:

Screenshot eines Textfensters mit Betreff 'Confirm your identity', Einmal-Code im gelb markierten Codeblock und Link unten.

Kopiert den Code und gebt ihn in das Feld auf der Webseite ein. Jetzt könnt ihr mit der Einrichtung fortfahren.

Dialog: Einmal-Passwort registrieren; drei Schritte: Start, Registrieren, Bestätigen; Buttons: Vorherige, Abbrechen, Nächste.

Nutzt hier die Authenticator-App eurer Wahl. Dies kann Google Authenticator, Microsoft Authenticator oder auch die App eures Passwortmanagers sein.

Dialog zur Registrierung eines Einmal-Passworts mit QR-Code, drei Schritte; QR-Code, App-Store-Badges und Navigationsknöpfe.

Nachdem ihr den QR-Code mit der App eurer Wahl eingescannt habt, gebt ihr nun den in der App generierten Code bei Authelia ein.

Dialog 'Einmal-Passwort registrieren' mit drei Schritten, blaue Haken, runde schwarze Scheibe, sechs Eingabefelder.

Nun habt ihr diese Methode erfolgreich eurem Benutzeraccount hinzugefügt.

Screenshot der Einstellungen: blauer Kopfbereich, Titel 'Einmal-Passwort', grauer Button 'HINZUFÜGEN'; Karte mit QR-Code und 'testbereich.net'.

4. Testdienste anlegen

Um zu verifizieren, dass Authelia korrekt funktioniert, legt ihr drei kleine Testdienste per Docker an. Jeder der Dienste deckt eine andere Sicherheitsstufe ab.

Authelia bietet folgende Sicherheitsstufen:

  • bypass: Der Dienst ist ohne Anmeldung erreichbar.
  • one_factor: Der Dienst ist durch Benutzernamen und Passwort geschützt.
  • two_factor: Zusätzlich zum Benutzernamen und Passwort muss noch ein zweiter Faktor genutzt werden.
  • deny: Der Zugriff wird immer verweigert.

Zum Test legt ihr folgende Datei an:

mkdir /opt/containers/authelia-test
nano /opt/containers/authelia-test/docker-compose.yml

Inhalt:

services:
  public:
    image: traefik/whoami
    container_name: authelia-public
    restart: unless-stopped
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.public.rule=Host(`public.euredomain.de`)"
      - "traefik.http.routers.public.entrypoints=websecure"
      - "traefik.http.routers.public.middlewares=authelia@file,security-headers@file"

  secure:
    image: traefik/whoami
    container_name: authelia-secure
    restart: unless-stopped
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.secure.rule=Host(`secure.euredomain.de`)"
      - "traefik.http.routers.secure.entrypoints=websecure"
      - "traefik.http.routers.secure.middlewares=authelia@file,security-headers@file"

  two:
    image: traefik/whoami
    container_name: authelia-two
    restart: unless-stopped
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.two.rule=Host(`two.euredomain.de`)"
      - "traefik.http.routers.two.entrypoints=websecure"
      - "traefik.http.routers.two.middlewares=authelia@file,security-headers@file"

networks:
  proxy:
    external: true

Jetzt führt ihr folgendes Skript aus, damit die Domains korrekt an eure Webseite angepasst werden:

D=$(grep -B1 authelia_url /opt/containers/authelia/config/configuration.yml | sed -n "s/.*domain: '\(.*\)'/\1/p") && sed -i "s|euredomain\.de|$D|g" /opt/containers/authelia-test/docker-compose.yml && grep Host /opt/containers/authelia-test/docker-compose.yml

Als Ausgabe solltet ihr drei Zeilen mit eurer korrekten Domain sehen:

Drei Traefik-Host-Regeln in Codezeilen: public.testbereich.net, secure.testbereich.net, two.testbereich.net.

Anschließend startet ihr die drei Testdienste:

cd /opt/containers/authelia-test/
docker compose up -d

Führt die nachfolgenden Tests in einem neuen privaten Tab durch. Wenn ihr den aktuellen Tab verwendet, seid ihr noch angemeldet und Test 1 und Test 2 lassen sich nicht überprüfen.

5. Test 1: bypass

Bei dieser Schutzstufe könnt ihr eure Domain öffnen und solltet keine Abfrage sehen. Gebt dazu „public.euredomain.de“ ein.

Screenshot eines Browserfensters mit HTTP-Headern: Hostname, IP 127.0.0.1, GET / HTTP/1.1, User-Agent.

6. Test 2: one_factor

Für diesen Test solltet ihr euch mit eurem Authelia-Benutzer anmelden müssen, damit ihr den Dienst seht. Geht dazu auf „secure.euredomain.de“:

Anmeldeseite mit Profil-Symbol, Überschrift Anmelden, Felder Benutzername und Passwort, Checkbox und blauer Button ANMELDEN.

In der URL seht ihr, dass ihr direkt zu Authelia umgeleitet werdet. Nachdem ihr euch dort erfolgreich angemeldet habt, steht euch der Dienst zur Verfügung:

Screenshot eines Browserfensters mit Terminal-/Konsolenausgabe, die Hostname und IP-Adressen zeigt.

7. Test 3: two_factor

Bei diesem Test reicht eine reine Authelia-Anmeldung nicht aus. Ihr müsst euch zusätzlich mittels Zwei-Faktor-Authentifizierung ausweisen. Zum Test geht ihr auf folgende Webseite: „two.euredomain.de“.

Da ihr bereits angemeldet seid, müsst ihr euch nur noch mittels eures Einmal-Kennworts verifizieren. Wenn ihr die Seite in einem privaten Tab neu öffnet, müsst ihr euch zusätzlich noch mittels Benutzernamen und Kennwort anmelden.

Login-Bildschirm: Avatar-Symbol, 'Hallo test', pinke Links; Karte 'Einmal-Passwort' mit Kreis-Icon und fünf leeren Quadraten.

Nach korrekter Verifizierung seht ihr den Dienst:

Browser-Fenster zeigt eine Seite mit HTTP-Headern (Hostname, IP, User-Agent, Accepted-Language).

Nachdem ihr alle drei Dienste getestet habt, könnt ihr die dazugehörigen Docker-Container wieder beenden:

cd /opt/containers/authelia-test/
docker compose down

8. Eigene Dienste mit Authelia absichern

Nachdem ihr Authelia erfolgreich eingerichtet und getestet habt, könnt ihr beliebige Dienste damit schützen. Besonders sinnvoll ist das bei Admin-Oberflächen wie Portainer, dem Uptime Monitor, n8n oder Grafana. Hierzu sind zwei Schritte notwendig.

Zuerst müsst ihr in der entsprechenden Docker-Compose-Datei des zu schützenden Dienstes das Label um „authelia@file“ erweitern. So könnte dies dann aussehen:

      - "traefik.http.routers.meindienst.middlewares=authelia@file,security-headers@file"

Nach der Änderung startet ihr den Dienst neu mit folgendem Befehl:

docker compose up -d

Jetzt wird der Dienst immer eine Anfrage an Authelia schicken. Damit Authelia diese beantwortet, müsst ihr den Dienst noch hinterlegen. Dazu öffnet ihr folgende Datei:

nano /opt/containers/authelia/config/configuration.yml

Fügt dort unter „rules“ die Domain des Dienstes sowie die Schutzstufe ein. Dies könnte so aussehen:

    - domain: 'meindienst.euredomain.de'
      policy: 'two_factor'

Bei mir würde dies so aussehen:

Terminalfenster mit Code-Block: access_control:, default_policy 'deny', Domain-Policy-Zuweisungen.

Dies könnt ihr mit beliebig vielen Diensten machen. Anschließend startet ihr Authelia neu, damit die Änderungen übernommen werden:

cd /opt/containers/authelia/
docker compose restart

9. Weitere Benutzer anlegen

Ihr habt die Möglichkeit, mehrere Benutzer in Authelia anzulegen. Damit ihr dies nicht von Hand machen müsst, nutzen wir ein kleines Skript. Dazu legt ihr folgende Datei an:

nano /opt/containers/authelia/add-user.sh

Inhalt:

#!/bin/bash
#

DATEI="/opt/containers/authelia/config/users_database.yml"

read -rp "Benutzername (Kleinbuchstaben und Zahlen): " AUSER
if grep -qE "^ +${AUSER}:$" "$DATEI"; then
  echo "Den Benutzer ${AUSER} gibt es bereits."
  exit 1
fi
read -rp "Anzeigename (z. B. Max Mustermann): " ANAME
read -rp "E-Mail-Adresse: " AMAIL
read -rp "Gruppe (z. B. admins oder users): " AGROUP
read -rsp "Passwort: " APASS
echo
read -rsp "Passwort wiederholen: " APASS2
echo
if [ "$APASS" != "$APASS2" ]; then
  echo "Die Passwörter stimmen nicht überein."
  exit 1
fi

echo "Passwort-Hash wird erzeugt, das dauert einen Moment ..."
HASH="$(docker run --rm authelia/authelia:4.39 authelia crypto hash generate argon2 --password "$APASS" | sed -n 's/^Digest: //p')"
unset APASS APASS2

# Einrückung der vorhandenen Benutzer übernehmen (Authelia schreibt die Datei
# nach einer Passwortänderung mit 4 statt 2 Leerzeichen neu)
E="$(sed -n '/^users:/{n;s/^\( *\).*/\1/p;q}' "$DATEI")"

cat >> "$DATEI" <<EOF
${E}${AUSER}:
${E}${E}disabled: false
${E}${E}displayname: '${ANAME//\'/\'\'}'
${E}${E}password: '${HASH}'
${E}${E}email: '${AMAIL}'
${E}${E}groups:
${E}${E}${E}- '${AGROUP}'
EOF
unset HASH

echo
echo "Benutzer ${AUSER} wurde angelegt."

Anschließend macht ihr das Skript ausführbar.

chmod +x /opt/containers/authelia/add-user.sh

Nun könnt ihr beliebig viele neue Nutzer anlegen:

/opt/containers/authelia/add-user.sh

Der Dialog sieht so aus:

Terminalfenster zeigt Benutzereinrichtung: Benutzername dogado, Anzeigename dogado, E-Mail dogado@testbereich.net; Angelegt.

Anschließend startet ihr Authelia neu, damit der Benutzer aktiv ist:

docker restart authelia

10. E-Mail-Versand einrichten

Aktuell werden alle Benachrichtigungen in eine Textdatei geschrieben. Das ist für Testzwecke gut, eignet sich aber nicht für den Alltag. Hierzu benötigt ihr eine E-Mail-Adresse.

Öffnet folgende Konfigurationsdatei:

nano /opt/containers/authelia/config/configuration.yml

Ersetzt den letzten Block „notifier“ durch folgenden Code:

notifier:
  smtp:
    address: 'submission://smtp.euredomain.de:587'
    username: 'authelia@euredomain.de'
    password: 'EUER_PASSWORT'
    sender: 'Authelia <authelia@euredomain.de>'

Die Daten müsst ihr entsprechend anpassen. Submission auf Port 587 verwendet STARTTLS. Sollte euer Anbieter dies nicht unterstützen, so ändert die Zeile ab:

    address: 'submissions://smtp.euredomain.de:465'

Startet anschließend Authelia neu:

cd /opt/containers/authelia/
docker compose restart

Zur Sicherheit solltet ihr noch ins Log schauen, ob es Fehlermeldungen gibt:

docker compose logs

11. Authelia aktualisieren

Mittels Docker könnt ihr Authelia sehr leicht updaten. Aktuell ist die Version 4.39 in der Docker-Compose-Datei festgelegt:

  authelia:
    image: authelia/authelia:4.39

Wenn ihr auf eine andere Version updaten möchtet, so könnt ihr euch hier die neuesten Versionen anschauen: https://hub.docker.com/r/authelia/authelia/tags

Screenshot einer Produktseite für authelia/authelia mit Logo links, Sponsored OSS, Titel und Tags.

Ändert dann in der Docker-Compose-Datei entsprechend die Version ab:

nano /opt/containers/authelia/docker-compose.yml

Anschließend startet ihr Authelia neu und ladet die aktuelle Version herunter:

cd /opt/containers/authelia/
docker compose down
docker compose pull
docker compose up -d

Im Log könnt ihr schauen, ob es Fehlermeldungen gibt:

docker compose logs
Nächster Artikel
Big Blue Button auf vServer/VPS installieren
Weitere passende Themen
Finde den passenden vServer zu deinem Projekt