GLPI 11: utilizzare Authentik per l'autenticazione tramite intestazione HTTP

In questo tutorial vi spiegherò come integrare Authentik con GLPI per centralizzare l’autenticazione degli utenti. Vedremo insieme come configurare la connessione basandoci sull’autenticazione trasmessa nelle intestazioni HTTP, il che consente di semplificare la gestione degli account e di migliorare la sicurezza del vostro ambiente

Sommario

Che cos’è l’autenticazione tramite richiesta HTTP?

L’autenticazione tramite richiesta HTTP è un meccanismo che consente a un’applicazione di delegare la gestione dell’identità degli utenti a un servizio esterno. In pratica, quando un utente tenta di accedere a un’applicazione come GLPI, viene prima autenticato da un servizio di terze parti (in questo caso Authentik). Una volta verificata l’identità, le informazioni dell’utente (ad esempio il suo nome utente o il suo indirizzo e-mail) vengono trasmesse all’applicazione di destinazione tramite un’intestazione HTTP.

GLPI non ha quindi bisogno di gestire direttamente la password dell’utente. Si basa sui dati forniti nella richiesta HTTP per identificare la persona e concederle l’accesso. Questo metodo è particolarmente interessante per centralizzare gli accessi, semplificare la gestione degli account e rafforzare la sicurezza limitando i punti di archiviazione delle password.

In sintesi, l’autenticazione HTTP funge da ponte di fiducia tra il servizio di autenticazione (Authentik) e l’applicazione finale (GLPI).

Prerequisiti

Per iniziare, è necessario avere GLPI 11 e Authenik installati. Idealmente, un reverse proxy su Nginx (altrimenti è necessario adattare il tutorial al proprio ambiente).

Gli utenti devono essere configurati in GLPI.

Configurazione di Authentik per l’autenticazione HTTP in GLPI

Per iniziare, aggiungeremo il provider e l’applicazione GLPI 11 in Authentik.

Nel menu Applicazioni, cliccare su Provider 1, quindi su Crea 2.

Nell’elenco dei provider, cliccare su Proxy Provider 1, quindi sul pulsante Avanti 2.

Assegnare un nome al provider 1, selezionare il flusso di autenticazione 2, nel campo Tipo selezionare Inoltra autenticazione (singola applicazione) 3, quindi inserire l’URL di GLPI 4 e fare clic sul pulsante Fine 5.

Il provider è stato creato.

Nel menu di navigazione, espandere «Applicazioni», quindi andare su «Applicazioni» 1 e, nella pagina delle applicazioni, cliccare sul pulsante «Crea» 2.

Assegnare un nome all’applicazione 1 e inserire lo slug 2 se non viene generato automaticamente; nel campo «Provider» selezionare GLPI 3, creato in precedenza, e fare clic sul pulsante «Crea» 4.

L’applicazione è stata creata.

Pubblicare il provider GLPI sull’Avant-Post (Outpost) di Authentik: dal menu Applicazioni, fare clic su Outposts 1, quindi sul pulsante di modifica di Authentik Embedded Outpost 2.

Aggiungere l’applicazione GLPI alle applicazioni selezionate 1 e fare clic su «Aggiorna» 2.

La configurazione in Authentik è completata.

Attivare e configurare l’autenticazione tramite richiesta HTTP in GLPI 11

Passiamo ora alla configurazione di GLPI 11

Dal menu, andare su Configurazione / Autenticazione e cliccare su Altri metodi di autenticazione 1.

Nella pagina di configurazione, dovremo aggiungere la variabile che viene passata ad Authentik; fare clic sul pulsante + 1.

Inserire il nome della variabile, ovvero: HTTP_X_AUTHENTIK_USERNAME 1, quindi fare clic su Aggiungi 2.

Successivamente, in GLPI, selezionare la variabile appena creata 1 nel campo: Campo di memorizzazione dell’identificativo nella richiesta HTTP e fare clic su Salva 2.

Configurazione di Nginx

Infine, passeremo alla configurazione di Nginx, che funge da reverse proxy per l’accesso a GLPI e ad Authentik.

Sul proprio reverse proxy, iniziare salvando il virtualhost di GLPI:

sudo cp vh-glpi vh-glpi.BACKUP

Per aiutarci a configurare il virtualhost, Authentik ci fornisce la configurazione da implementare; a tal fine, nell’elenco dei Provider, cliccare su quello dedicato a GLPI.

Nei dettagli del provider, nella sezione di configurazione, andate alla sezione Nginx (standalone) e potrete vedere la configurazione da applicare a Nginx.

Utilizzate gli elementi di configurazione per incollarli nel virtualhost di GLPI, avendo cura di adattare le direttiveproxy_passal vostro ambiente.

Per aiutarvi, ecco la configurazione del mio virtualhost GLPI:

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;
}

Verifica la configurazione di Nginx:

sudo nginx -t

Ricaricare la configurazione:

sudo systemctl reload nginx

Verifica l’autenticazione con Authentik

Da un altro browser (o in modalità privata), accedere all’URL di GLPI; si dovrebbe visualizzare il modulo di autenticazione di Authentik. Inserire l’ID e la password di un utente presente in Authentik e che è stato configurato in GLPI.

Se tutto è a posto, sarò connesso a GLPI e avrò accesso al portale utente.

Inoltre, per aiutarvi nella configurazione, ecco l’elenco delle variabili $_SERVER di GLPI con Authentik.

Conclusione

Grazie all’integrazione di Authentik con GLPI tramite l’autenticazione tramite richiesta HTTP, potrete beneficiare di una soluzione semplice e sicura per centralizzare la gestione delle identità. Questo metodo consente di delegare l’autenticazione a un servizio dedicato, garantendo al contempo un’esperienza fluida per gli utenti, che non devono più ricordare più credenziali.

Implementando questa configurazione, semplificate l’amministrazione del vostro ambiente rafforzando al contempo la sicurezza complessiva. Questo approccio è particolarmente utile nelle infrastrutture in cui più applicazioni devono condividere lo stesso sistema di autenticazione.