---
title: "Come autenticarsi usando REMOTE_USER"
version: 4.2
locale: it
source: https://docs.djangoproject.com/it/4.2/howto/auth-remote-user/
canonical: https://djangodocs.dev/it/4.2/howto/auth-remote-user/
---
# Come autenticarsi usando `REMOTE_USER`

Questo documento descrive come utilizzare fonti di autenticazione esterne (dove il web server imposta la variabile di ambiente `REMOTE_USER`) nelle applicazioni Django. Questo tipo di soluzione di autenticazione tipicamente si vede in siti intranet, con soluzioni single sign-on come IIS e Integrated Windows Authentication oppure Apache and [mod\_authnz\_ldap](https://httpd.apache.org/docs/2.2/mod/mod_authnz_ldap.html), [CAS](https://www.apereo.org/projects/cas), [Cosign](http://weblogin.org), [WebAuth](https://uit.stanford.edu/service/authentication), [mod\_auth\_sspi](https://sourceforge.net/projects/mod-auth-sspi), ecc.

Quando il web server si occupa dell’autenticazione tipicamente imposta la variabile d’ambiente `REMOTE_USER` da usare nell’applicazione. In Django `REMOTE_USER` viene resa disponibile nell’attributo [`request.META`](/it/4.2/ref/request-response/#django.http.HttpRequest.META). Django può essere configurato per usare il valore di `REMOTE_USER` usando le classi `RemoteUserMiddleware` o `PersistentRemoteUserMiddleware` e [`RemoteUserBackend`](/it/4.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) che si trovano in [`django.contrib.auth`](/it/4.2/topics/auth/#module-django.contrib.auth).

## Configurazione

In primo luogo, devi aggiungere la classe [`django.contrib.auth.middleware.RemoteUserMiddleware`](/it/4.2/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware) nel file settings.py [`MIDDLEWARE`](/it/4.2/ref/settings/#std-setting-MIDDLEWARE)  posizionato **dopo** la classe [`django.contrib.auth.middleware.AuthenticationMiddleware`](/it/4.2/ref/middleware/#django.contrib.auth.middleware.AuthenticationMiddleware):

```
MIDDLEWARE = [
    "...",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.auth.middleware.RemoteUserMiddleware",
    "...",
]
```

Poi, devi sostituire [`ModelBackend`](/it/4.2/ref/contrib/auth/#django.contrib.auth.backends.ModelBackend) con [`RemoteUserBackend`](/it/4.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) nella impostazione di [`AUTHENTICATION_BACKENDS`](/it/4.2/ref/settings/#std-setting-AUTHENTICATION_BACKENDS)

```
AUTHENTICATION_BACKENDS = [
    "django.contrib.auth.backends.RemoteUserBackend",
]
```

Con questa configurazione, `RemoteUserMiddleware` rileverà il nome utente in `request.META['REMOTE_USER']` e autenticherà e farà login automaticamente di quell’utente usando la [`RemoteUserBackend`](/it/4.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend).

Sii cosciente che questa particolare configurazione disabilita l’autenticazione con il `ModelBackend` di default. Questo significa che se il valore di  `REMOTE_USER` non è impostato, l’utente non potrà fare log in, anche utilizzando l’interfaccia di amministrazione di Django. Aggiungendo `'django.contrib.auth.backends.ModelBackend'` all’elenco `AUTHENTICATION_BACKENDS` si userà `ModelBackend` come ripiego se è assente `REMOTE_USER` , risolvendo questo inconveniente.

La gestione utenti di Django, come le view in `contrib.admin` e il comando di gestione [`createsuperuser`](/it/4.2/ref/django-admin/#django-admin-createsuperuser) , non si integrano con gli utenti remoti. Queste interfacce lavorano con gli utenti memorizzati nel database, indipendentemente dagli `AUTHENTICATION_BACKENDS`.

> **Note**
>
> Poiché il `RemoteUserBackend` eredita da `ModelBackend`, avrai ancora tutto il controllo sui permessi che è implementato in `ModelBackend`.
>
> Gli utenti con l’attributo [`is_active=False`](/it/4.2/ref/contrib/auth/#django.contrib.auth.models.User.is_active) non avranno il permesso di autenticarsi. Usa [`AllowAllUsersRemoteUserBackend`](/it/4.2/ref/contrib/auth/#django.contrib.auth.backends.AllowAllUsersRemoteUserBackend) se vuoi permettere l’autenticazione.

Se il tuo meccanismo di autenticazione usa una intestazione HTTP personalizzata, e non `REMOTE_USER`, puoi derivare `RemoteUserMiddleware` e impostare l’attributo `header` alla chiave `request.META` desiderata.  Per esempio:

```
from django.contrib.auth.middleware import RemoteUserMiddleware

class CustomHeaderMiddleware(RemoteUserMiddleware):
    header = "HTTP_AUTHUSER"
```

> **Warning**
>
> Sii molto attento se utilizzi una sottoclasse di `RemoteUserMiddleware` con un’intersatione HTTP personalizzata. Devi essere sicuro che il tuo  front-end web server imposti sempre o rimuova quella intestazione in base agli appropriati controlli di autenticazione, impedendo ad un utente di inviare un falso (o «spoofed») valore di intestazione . Poiché le intestazioni HTTP `X-Auth-User` e `X-Auth_User` (per esempio) sono entrambe normalizzate alla chiave `HTTP_X_AUTH_USER` in `request.META`, devi anche controllare che il tuo  web server non permetta intestazioni false utilizzando trattini bassi al posto dei trattini.
>
> Questo avvertimento non si applica a `RemoteUserMiddleware` nella sua configurazione di default con `header = 'REMOTE_USER'`, perché una chiave che non inizia con `HTTP_` in `request.META` può essere impostata solo dal tuo server WSGI, non direttamente da una intestazione di richiesta HTTP.

Se hai necessità di più controllo, puoi creare il tuo backend di autenticazione che eredita da [`RemoteUserBackend`](/it/4.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) e sostituisce uno o più dei suoi attributi e metodi.

## Usare `REMOTE_USER` solo sulle pagine di login

Il `RemoteUserMiddleware` presuppone che l’intestazione HTTP `REMOTE_USER` sia presente in tutte le richieste che necessitano di autenticazione. Può essere quindi usato quando si ha a che fare con il Basic HTTP Auth con `htpasswd` o altri semplici meccanismi; quando invece si usa Negotiate (GSSAPI/Kerberos) o un altro metodo di autenticazione che richiede maggiori risorse, l’autenticazione nel server HTTP di front-end è normalmente utilizzata in ambienti ristretti con pochi URL di accesso, e dopo un’autenticazione riuscita, si suppone che l’applicazione mantenga autonomamente la sessione autenticata.

[`PersistentRemoteUserMiddleware`](/it/4.2/ref/middleware/#django.contrib.auth.middleware.PersistentRemoteUserMiddleware) fornisce supporto per questo caso d’uso. Mantiene la sessione autenticata fino ad un logout esplicito dell’utente. La classe può essere usata in sostituzione in cascata di [`RemoteUserMiddleware`](/it/4.2/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware) nella documentazione di cui sopra.