---
title: "Autenticação usando REMOTE_USER"
version: 2.0
locale: pt-br
source: https://docs.djangoproject.com/pt-br/2.0/howto/auth-remote-user/
canonical: https://djangodocs.dev/pt-br/2.0/howto/auth-remote-user/
---
# Autenticação usando `REMOTE_USER`

Este documento descreve como usar fontes externas de autenticação (quando o servidor define a variável de ambiente `REMOTE_USER`) em suas aplicações Django. Este tipo de solução de autenticação é geralmente usado em sites de intranet, com soluções single sign-on como o IIS e autenticação Integrada do Windows ou Apache e [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://www.stanford.edu/services/webauth/), [mod\_auth\_sspi](https://sourceforge.net/projects/mod-auth-sspi), etc.

Quando o servidor Web se encarrega da autenticação ele normalmente define a variável de ambiente `REMOTE_USER` para uso na aplicação que está sendo executada. No Django, `REMOTE_USER` é disponibilizado no atributo [`request.META`](/pt-br/2.0/ref/request-response/#django.http.HttpRequest.META). O Django pode ser configurado para fazer uso do  `REMOTE_USER` usando as classes [`django.contrib.auth.middleware.RemoteUserMiddleware`](/pt-br/2.0/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware) e [`RemoteUserBackend`](/pt-br/2.0/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) encontrados em:mod:django.contrib.auth.

## Configuração

Primeiro você deve adicionar  [`django.contrib.auth.middleware.RemoteUserMiddleware`](/pt-br/2.0/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware) no [`MIDDLEWARE`](/pt-br/2.0/ref/settings/#std-setting-MIDDLEWARE) definindo **depois** do [`django.contrib.auth.middleware.AuthenticationMiddleware`](/pt-br/2.0/ref/middleware/#django.contrib.auth.middleware.AuthenticationMiddleware):

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

Depois você deve substituir a [`ModelBackend`](/pt-br/2.0/ref/contrib/auth/#django.contrib.auth.backends.ModelBackend) por [`RemoteUserBackend`](/pt-br/2.0/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) na configuração [`AUTHENTICATION_BACKENDS`](/pt-br/2.0/ref/settings/#std-setting-AUTHENTICATION_BACKENDS):

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

Com esta configuração, o :class:\`~django.contrib.auth.middleware.RemoteUserMiddleware irá detectar o \_\_username\_\_  em `request.META['REMOTE_USER']` e irá autenticar e automaticamente logar aquele usuário usando o [`RemoteUserBackend`](/pt-br/2.0/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend).

Esteja ciente de que essa definição em particular desabilita a autenticação com o padrão `ModelBackend`. Isso significa que se o valor de `REMOTE_USER` não estiver definido o usuário não conseguirá logar-se, mesmo utilizando a inteface do Django admin. Adicionando `django.contrib.auth.backends.ModelBackend` à lista `AUTHENTICATION_BACKENDS` ele será utilizado como um substituto se “REMOTE\_USER” estiver ausente, e esse problema não acontecerá.

O gerenciamento de usuários do Django, bem como as views em `contrib.admin`, e o comando de gerenciamento [`createsuperuser`](/pt-br/2.0/ref/django-admin/#django-admin-createsuperuser), não fazem integração com usuários remotos. Esta interface trabalha com usuários armazenados no banco de dados independente do `AUTHENTICATION_BACKENDS`.

> **Note**
>
> Um vez que `RemoteUserBackend` herda de `ModelBackend`, você ainda terá todos as mesmas permissões de verificação que estão implementadas em `ModelBackend`.
>
> Usuários com [`is_active=False`](/pt-br/2.0/ref/contrib/auth/#django.contrib.auth.models.User.is_active) não serão permitidos a fazer a autenticação. Use [`AllowAllUsersRemoteUserBackend`](/pt-br/2.0/ref/contrib/auth/#django.contrib.auth.backends.AllowAllUsersRemoteUserBackend) se você quiser permití-los.

Se o seu mecanismo de autenticação utilizar um cabeçalho HTTP costumizado e não o ```REMOTE_USER`, você pode utilizar a subclass ``RemoteUserMiddleware``` e definir o atributo `header` para atribuir a chave `request.META`. Por exemplo:

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

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

> **Warning**
>
> Tenha muito cuidado se usar a subclasse `RemoteUserMiddleware` com um cabeçalho HTTP customizado. Tenha certeza que o servidor de front-end sempre defina ou retire  o cabeçalho baseado nos checks de autenticação apropriados, nunca permitindo que um usuário submeta um falso (ou falsificado) valor no cabeçalho. Já que os cabeçalhos HTTP `X-Auth-User` e o `X-Auth_User` (por exemplo) são ambos normalizados para a chave `HTTP_X_AUTH_USER` no `request.META`, tem que ser verificado que o seu servidor web não aceita um cabeçalho falsificado usando “underscores” no lugar de traços.
>
> Este alerta não se aplica ao `RemoteUserMiddleware` na sua configuração default `header = 'REMOTE_USER'`, já que uma chave que não inicie com `HTTP_` em `request.META`  só pode ser setada pelo servidor WSGI, e não diretamente do cabeçalho da requisição HTTP

Se você precisa de mais controle, é possível criar seu próprio “backend” de autenticação que herda de [`RemoteUserBackend`](/pt-br/2.0/ref/contrib/auth/#django.contrib.auth.backends.RemoteUserBackend) e sobrescreve um ou mais de seus  atributos e métodos.

## Usando `REMOTE_USER` apenas nas páginas de login.

O middleware de autenticação `RemoteUserMiddleware` assume que o cabeçalho `REMOTE_USER` da requisição HTTP está presente em todas as requisições autenticadas. Isso é   esperado e até prático quando usado em uma autenticação HTTP básica com `htpasswd` ou um outro mecanismo simples, más com uma requisição Negotiate (GSSAPI/Kerberos)  ou  outro método de autenticação de fontes intensivas, a autenticação no servidor HTTP de front-end é comumente configurada para uma ou algumas poucas URLS de login, e depois de uma autenticação bem sucedida, é esperado que a aplicação mantenha a sessão de autenticação por conta própria.

A classe [`PersistentRemoteUserMiddleware`](/pt-br/2.0/ref/middleware/#django.contrib.auth.middleware.PersistentRemoteUserMiddleware) provê suporte para este caso de uso. Ele manterá a sessão de autenticação até o logout explícito do usuário. A classe pode ser usada como um substituto constante para [`RemoteUserMiddleware`](/pt-br/2.0/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware) na documentação acima.