GLPI 11: Verwenden Sie Authentik zur Authentifizierung über HTTP-Header

In diesem Tutorial werde ich Ihnen erklären, wie Sie Authentik in GLPI integrieren können, um die Benutzerauthentifizierung zu zentralisieren. Wir werden gemeinsam sehen, wie die Verbindung eingerichtet wird, indem wir die in den HTTP-Headern übermittelte Authentifizierung nutzen. Dies vereinfacht die Verwaltung der Konten und verbessert die Sicherheit Ihrer Umgebung

Was ist die Authentifizierung per HTTP-Anfrage?

Die HTTP-Request-Authentifizierung ist ein Mechanismus, der es einer Anwendung ermöglicht, die Verwaltung der Benutzeridentitäten an einen externen Dienst zu delegieren. Konkret bedeutet dies: Wenn ein Benutzer versucht, auf eine Anwendung wie GLPI zuzugreifen, wird er zunächst von einem Drittanbieter-Dienst (in diesem Fall Authentik) authentifiziert. Sobald die Identität überprüft wurde, werden die Benutzerdaten (z. B. sein Login oder seine E-Mail-Adresse) über einen HTTP-Header an die Zielanwendung übermittelt.

GLPI muss das Passwort des Benutzers also nicht direkt verwalten. Es stützt sich auf die in der HTTP-Anfrage bereitgestellten Daten, um die Person zu identifizieren und ihr den Zugriff zu gewähren. Diese Methode ist besonders interessant, um den Zugriff zu zentralisieren, die Kontoverwaltung zu vereinfachen und die Sicherheit zu erhöhen, indem die Anzahl der Speicherorte für Passwörter begrenzt wird.

Zusammenfassend lässt sich sagen, dass die HTTP-Authentifizierung als Vertrauensbrücke zwischen dem Authentifizierungsdienst (Authentik) und der Endanwendung (GLPI) fungiert.

Voraussetzungen

Zunächst müssen GLPI 11 und Authenik installiert sein. Idealerweise sollte ein Reverse-Proxy auf Nginx vorhanden sein (andernfalls müssen Sie die Anleitung an Ihre Umgebung anpassen).

Die Benutzer müssen in GLPI angelegt sein.

Konfiguration von Authenik für die HTTP-Authentifizierung in GLPI

Zunächst fügen wir den Provider und die GLPI-11-Anwendung in Authentik hinzu.

Klicken Sie im Menü „Anwendungen“ auf „Anbieter“ 1 und anschließend auf „Erstellen“ 2.

Klicken Sie in der Liste der Provider auf „Proxy-Provider“ 1 und anschließend auf die Schaltfläche „Weiter“ 2.

Benennen Sie den Provider 1, wählen Sie den Authentifizierungsfluss 2 aus, wählen Sie unter „Typ“ die Option „Authentifizierung weiterleiten (Einzelanwendung)“ 3 aus, geben Sie dann die URL von GLPI 4 ein und klicken Sie auf die Schaltfläche „Fertigstellen“ 5.

Der Provider wurde erstellt.

Erweitern Sie im Navigationsmenü den Punkt „Anwendungen“, gehen Sie dann zu „Anwendungen“ 1 und klicken Sie auf der Seite „Anwendungen“ auf die Schaltfläche „Erstellen“ 2.

Benennen Sie die Anwendung 1 und geben Sie den Slug 2 ein, falls dieser nicht automatisch generiert wird. Wählen Sie unter „Anbieter“ den zuvor erstellten GLPI 3 aus und klicken Sie auf die Schaltfläche „Erstellen“ 4.

Die Anwendung wurde erstellt.

Veröffentlichen Sie den GLPI-Anbieter auf dem Avant-Post (Outpost) von Authentik: Klicken Sie im Menü „Anwendungen“ auf „Outposts“ 1 und anschließend auf die Schaltfläche „Bearbeiten“ für „Authentik Embedded Outpost“ 2.

Fügen Sie die GLPI-Anwendung zu den ausgewählten Anwendungen 1 hinzu und klicken Sie auf „Aktualisieren“ 2.

Die Konfiguration auf Authentik-Seite ist abgeschlossen.

Aktivieren und Konfigurieren der Authentifizierung per HTTP-Anfrage in GLPI 11

Wir fahren nun mit der Konfiguration von GLPI 11 fort

Gehen Sie im Menü zu „Konfiguration“ / „Authentifizierung“ und klicken Sie auf „Weitere Authentifizierungsmethoden“ 1.

Auf der Konfigurationsseite müssen wir die Variable hinzufügen, die an Authentik übergeben wird. Klicken Sie dazu auf die Schaltfläche „+“ 1.

Geben Sie den Namen der Variablen ein: HTTP_X_AUTHENTIK_USERNAME 1 und klicken Sie anschließend auf „Hinzufügen“ 2.

Wählen Sie anschließend in GLPI die soeben erstellte Variable 1 im Feld „Speicherfeld für die Kennung in der HTTP-Anfrage“ aus und klicken Sie auf „Speichern“ 2.

Konfiguration von Nginx

Abschließend fahren wir mit der Konfiguration von Nginx fort, dem Reverse-Proxy für den Zugriff auf GLPI und Authentik.

Speichern Sie auf Ihrem Reverse-Proxy zunächst den VirtualHost für GLPI:

sudo cp vh-glpi vh-glpi.BACKUP

Um uns bei der Konfiguration des VirtualHosts zu helfen, stellt Authentik die erforderliche Konfiguration zur Verfügung. Klicken Sie dazu in der Liste der Provider auf den für GLPI vorgesehenen Provider.

In den Details des Providers gehen Sie in der Konfiguration zum Abschnitt „Nginx (standalone)“, wo Sie die für Nginx einzutragende Konfiguration sehen können.

Verwenden Sie die Konfigurationselemente und fügen Sie sie in den virtuellen Host von GLPI ein. Passen Sie die Anweisungenproxy_pass dabei gegebenenfalls an Ihre Umgebung an.

Zur Unterstützung finden Sie hier die Konfiguration meines GLPI-VirtualHosts:

server{
    listen 443 ssl;
    http2 on;
    server_name glpi.domain.tld;

    access_log /var/log/nginx/glpi.domain.tld_access.log;

    more_clear_headers Server;
    more_clear_headers X-Powered-By;

    client_max_body_size 0;

    ssl_certificate /etc/nginx/ssl/san-internal.pem;
    ssl_certificate_key /etc/nginx/ssl/san-internal.key;

    proxy_buffers 8 16k;
    proxy_buffer_size 32k;

    location /{
        proxy_pass http://ip-glpi-server;
        proxy_ssl_verify off;
        include proxy_params;

        ##############################
        # authentik-specific config
        ##############################
        auth_request     /outpost.goauthentik.io/auth/nginx;
        error_page       401 = @goauthentik_proxy_signin;
        auth_request_set $auth_cookie $upstream_http_set_cookie;
        add_header       Set-Cookie $auth_cookie;

        # translate headers from the outposts back to the actual upstream
        auth_request_set $authentik_username $upstream_http_x_authentik_username;
        auth_request_set $authentik_groups $upstream_http_x_authentik_groups;
        auth_request_set $authentik_entitlements $upstream_http_x_authentik_entitlements;
        auth_request_set $authentik_email $upstream_http_x_authentik_email;
        auth_request_set $authentik_name $upstream_http_x_authentik_name;
        auth_request_set $authentik_uid $upstream_http_x_authentik_uid;

        proxy_set_header X-authentik-username $authentik_username;
        proxy_set_header X-authentik-groups $authentik_groups;
        proxy_set_header X-authentik-entitlements $authentik_entitlements;
        proxy_set_header X-authentik-email $authentik_email;
        proxy_set_header X-authentik-name $authentik_name;
        proxy_set_header X-authentik-uid $authentik_uid;

        proxy_set_header HTTP_AUTH_USER $authentik_username;

    }

    # all requests to /outpost.goauthentik.io must be accessible without authentication
    location /outpost.goauthentik.io {
        # When using the embedded outpost, use:
        proxy_pass              http://ip-authentik:80/outpost.goauthentik.io;
        # For manual outpost deployments:
        # proxy_pass              http://outpost.company:9000;

        # Note: ensure the Host header matches your external authentik URL:
        proxy_set_header        Host $host;

        proxy_set_header        X-Original-URL $scheme://$http_host$request_uri;
        add_header              Set-Cookie $auth_cookie;
        auth_request_set        $auth_cookie $upstream_http_set_cookie;
        proxy_pass_request_body off;
        proxy_set_header        Content-Length "";
    }

    # Special location for when the /auth endpoint returns a 401,
    # redirect to the /start URL which initiates SSO
    location @goauthentik_proxy_signin {
        internal;
        add_header Set-Cookie $auth_cookie;
        return 302 /outpost.goauthentik.io/start?rd=$scheme://$http_host$request_uri;
        # For domain level, use the below error_page to redirect to your authentik server with the full redirect path
        # return 302 https://authentik.company/outpost.goauthentik.io/start?rd=$scheme://$http_host$request_uri;
    }


}
server{
    listen 80;
    server_name glpi.domain.tld;

    more_clear_headers Server;
    more_clear_headers X-Powered-By;

    if ($host = glpi.domain.tld;) {
        return 301 https://$host$request_uri;
    }

    return 404;
}

Testen Sie die Nginx-Konfiguration:

sudo nginx -t

Laden Sie die Konfiguration neu:

sudo systemctl reload nginx

Testen Sie die Authentifizierung mit Authentik

Rufen Sie in einem anderen Browser (oder im Inkognito-Modus) die GLPI-URL auf; Sie sollten nun zum Anmeldeformular von Authentik weitergeleitet werden. Geben Sie den Benutzernamen und das Passwort eines Benutzers ein, der in Authentik vorhanden ist und in GLPI eingerichtet wurde.

Wenn alles korrekt ist, bin ich bei GLPI angemeldet und habe Zugriff auf das Benutzerportal.

Als zusätzliche Hilfe bei der Konfiguration finden Sie hier die Liste der $_SERVER-Variablen von GLPI mit Authentik.

Fazit

Dank der Integration von Authentik in GLPI über die Authentifizierung per HTTP-Anfrage profitieren Sie von einer einfachen und sicheren Lösung zur Zentralisierung der Identitätsverwaltung. Diese Methode ermöglicht es, die Authentifizierung an einen dedizierten Dienst zu delegieren und gleichzeitig ein reibungsloses Nutzererlebnis zu gewährleisten, da sich die Benutzer nicht mehr mehrere Anmeldedaten merken müssen.

Durch die Einrichtung dieser Konfiguration vereinfachen Sie die Verwaltung Ihrer Umgebung und erhöhen gleichzeitig die allgemeine Sicherheit. Dieser Ansatz ist besonders nützlich in Infrastrukturen, in denen mehrere Anwendungen dasselbe Authentifizierungssystem gemeinsam nutzen müssen.