-
Was ist ein vServer?
-
vServer und Sicherheit
-
vServer - Anwendungsfälle
-
vServer bei dogado
-
vServer und Plesk
-
vServer Betriebssyteme
-
vServer Glossar
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.
0. Überblick
- Verwendetes System: Debian 13 64 Bit
- Genutzter User: Ich nehme alles als „root“ vor
- Zeitdauer: ca. 10 Minuten
- Schwierigkeit: Einfach. Nur Code kopieren 😉
- Besonderheiten:
- Grundlage ist folgende Anleitung: Traefik Reverseproxy auf vServer installieren
Diese Anleitung muss zuerst ausgeführt werden. - Die Installation von Docker / Docker Compose wird hier vorausgesetzt.
- Grundlage ist folgende Anleitung: Traefik Reverseproxy auf vServer installieren
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:
| Abschnitt | Erklärung |
|---|---|
| theme | Die Anmeldeseite passt sich automatisch an den hellen oder dunklen Modus eures Geräts an. |
| totp | Einstellungen für die Einmalcodes. Der issuer erscheint später als Name in eurer Authenticator-App. |
| identity_validation | Geheimer Schlüssel, mit dem Authelia die Links zum Zurücksetzen von Passwörtern signiert. |
| authentication_backend | Die Benutzer stehen in der Datei users_database.yml. |
| access_control | Die 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. |
| session | Gilt 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. |
| regulation | Nach drei Fehlversuchen innerhalb von zwei Minuten wird der Benutzer für fünf Minuten gesperrt. |
| storage | Authelia speichert z. B. die Zwei-Faktor-Geräte in einer SQLite-Datenbank. Sensible Daten darin werden mit dem encryption_key verschlüsselt. |
| notifier | Nachrichten 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:
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.
Nun könnt ihr auf eure Webseite (https://auth.euredomain.de) gehen und solltet Folgendes sehen:
Hier loggt ihr euch nun mit euren Zugangsdaten aus Kapitel 1.6 ein. Nach dem erfolgreichen Login solltet ihr Folgendes sehen:
3. Zwei-Faktor-Authentifizierung einrichten
Hierzu klickt ihr auf „Gerät registrieren“.
Anschließend wählt ihr „Einmal-Passwort“ aus:
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:
Kopiert den Code und gebt ihn in das Feld auf der Webseite ein. Jetzt könnt ihr mit der Einrichtung fortfahren.
Nutzt hier die Authenticator-App eurer Wahl. Dies kann Google Authenticator, Microsoft Authenticator oder auch die App eures Passwortmanagers sein.
Nachdem ihr den QR-Code mit der App eurer Wahl eingescannt habt, gebt ihr nun den in der App generierten Code bei Authelia ein.
Nun habt ihr diese Methode erfolgreich eurem Benutzeraccount hinzugefügt.
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:
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.
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“:
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:
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.
Nach korrekter Verifizierung seht ihr den Dienst:
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:
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:
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
Ä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