---
title: "Hur man autentiserar med hjälp av REMOTE_USER"
version: 5.2
locale: sv
source: https://docs.djangoproject.com/sv/5.2/howto/auth-remote-user/
canonical: https://djangodocs.dev/sv/5.2/howto/auth-remote-user/
---
# Hur man autentiserar med hjälp av `REMOTE_USER`

Detta dokument beskriver hur man använder externa autentiseringskällor (där webbservern ställer in miljövariabeln `REMOTE_USER`) i dina Django-applikationer.  Den här typen av autentiseringslösning används vanligtvis på intranätplatser, med lösningar för enkel inloggning som IIS och Integrated Windows Authentication eller Apache och [mod\_authnz\_ldap](https://httpd.apache.org/docs/current/mod/mod_authnz_ldap.html), [CAS](https://www.apereo.org/projects/cas), [WebAuth](https://uit.stanford.edu/service/authentication), [mod\_auth\_sspi](https://sourceforge.net/projects/mod-auth-sspi), etc.

När webbservern tar hand om autentisering ställer den vanligtvis in miljövariabeln `REMOTE_USER` för användning i den underliggande applikationen.  I Django görs `REMOTE_USER` tillgänglig i attributet [`request.META`](/sv/5.2/ref/request-response/#django.http.HttpRequest.META).  Django kan konfigureras för att använda värdet `REMOTE_USER` med hjälp av `RemoteUserMiddleware` eller `PersistentRemoteUserMiddleware` och [`RemoteUserBackend`](/sv/5.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend)-klasserna som finns i [`django.contrib.auth`](/sv/5.2/topics/auth/#module-django.contrib.auth).

## Konfiguration

Först måste du lägga till [`django.contrib.auth.middleware.RemoteUserMiddleware`](/sv/5.2/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware) i inställningen [`MIDDLEWARE`](/sv/5.2/ref/settings/#std-setting-MIDDLEWARE) **efter** [`django.contrib.auth.middleware.AuthenticationMiddleware`](/sv/5.2/ref/middleware/#django.contrib.auth.middleware.AuthenticationMiddleware):

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

Därefter måste du ersätta [`ModelBackend`](/sv/5.2/ref/contrib/auth/#django.contrib.auth.backends.ModelBackend) med [`RemoteUserBackend`](/sv/5.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) i inställningen [`AUTHENTICATION_BACKENDS`](/sv/5.2/ref/settings/#std-setting-AUTHENTICATION_BACKENDS):

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

Med denna inställning kommer `RemoteUserMiddleware` att upptäcka användarnamnet i `request.META['REMOTE_USER']` och autentisera och automatiskt logga in den användaren med hjälp av [`RemoteUserBackend`](/sv/5.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend).

Var medveten om att just denna inställning inaktiverar autentisering med standard `ModelBackend`. Detta innebär att om värdet `REMOTE_USER` inte är inställt kan användaren inte logga in, inte ens med hjälp av Djangos administratörsgränssnitt. Genom att lägga till `'django.contrib.auth.backends.ModelBackend'` i listan `AUTHENTICATION_BACKENDS` kommer `ModelBackend` att användas som reserv om `REMOTE_USER` saknas, vilket kommer att lösa dessa problem.

Djangos användarhantering, till exempel vyerna i `contrib.admin` och kommandot [`createsuperuser`](/sv/5.2/ref/django-admin/#django-admin-createsuperuser), integreras inte med fjärranvändare. Dessa gränssnitt fungerar med användare som är lagrade i databasen oavsett `AUTHENTICATION_BACKENDS`.

> **Note**
>
> Eftersom `RemoteUserBackend` ärver från `ModelBackend` kommer du fortfarande att ha samma behörighetskontroll som implementeras i `ModelBackend`.
>
> Användare med [`is_active=False`](/sv/5.2/ref/contrib/auth/#django.contrib.auth.models.User.is_active) tillåts inte att autentisera sig. Använd [`AllowAllUsersRemoteUserBackend`](/sv/5.2/ref/contrib/auth/#django.contrib.auth.backends.AllowAllUsersRemoteUserBackend) om du vill tillåta dem att göra det.

Om din autentiseringsmekanism använder en anpassad HTTP-header och inte `REMOTE_USER`, kan du subklassa `RemoteUserMiddleware` och ställa in attributet `header` till önskad `request.META`-nyckel.  Till exempel:

*`mysite/middleware.py`*

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

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

Denna anpassade middleware används sedan i inställningen [`MIDDLEWARE`](/sv/5.2/ref/settings/#std-setting-MIDDLEWARE) istället för [`django.contrib.auth.middleware.RemoteUserMiddleware`](/sv/5.2/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware):

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

> **Warning**
>
> Var mycket försiktig om du använder en `RemoteUserMiddleware`-underklass med en anpassad HTTP-header. Du måste vara säker på att webbservern i frontend alltid ställer in eller tar bort rubriken baserat på lämpliga autentiseringskontroller och aldrig tillåter en slutanvändare att skicka in ett falskt (eller ”spoofat”) rubrikvärde. Eftersom HTTP-rubrikerna `X-Auth-User` och `X-Auth_User` (till exempel) båda normaliseras till nyckeln `HTTP_X_AUTH_USER` i `request.META`, måste du också kontrollera att din webbserver inte tillåter en förfalskad rubrik som använder understreck i stället för bindestreck.
>
> Denna varning gäller inte för `RemoteUserMiddleware` i dess standardkonfiguration med `header = 'REMOTE_USER'`, eftersom en nyckel som inte börjar med `HTTP_` i `request.META` endast kan ställas in av din WSGI-server, inte direkt från en HTTP-förfrågningsrubrik.

Om du behöver mer kontroll kan du skapa din egen autentiseringsbackend som ärver från [`RemoteUserBackend`](/sv/5.2/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) och åsidosätta ett eller flera av dess attribut och metoder.

## Använda `REMOTE_USER` endast på inloggningssidor

Autentiseringsmellanvaran `RemoteUserMiddleware` förutsätter att HTTP-förfrågningshuvudet `REMOTE_USER` finns med i alla autentiserade förfrågningar. Detta kan vara förväntat och praktiskt när grundläggande HTTP-autentisering med `htpasswd` eller liknande mekanismer används, men med Negotiate (GSSAPI/Kerberos) eller andra resurskrävande autentiseringsmetoder konfigureras autentiseringen i HTTP-frontservern vanligtvis bara för en eller ett fåtal inloggningsadresser, och efter en lyckad autentisering är det meningen att applikationen själv ska upprätthålla den autentiserade sessionen.

[`PersistentRemoteUserMiddleware`](/sv/5.2/ref/middleware/#django.contrib.auth.middleware.PersistentRemoteUserMiddleware) ger stöd för detta användningsfall. Den kommer att behålla den autentiserade sessionen tills användaren uttryckligen loggar ut. Klassen kan användas som en drop-in-ersättning av [`RemoteUserMiddleware`](/sv/5.2/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware) i dokumentationen ovan.