O que é Django Allauth?

O que é o Django Allauth?

O django-allauth é o pacote de autenticação mais completo para Django. Ele resolve de uma vez todos os problemas comuns de autenticação: registro de usuários, login, logout, verificação de e-mail, recuperação de senha e login social (Google, GitHub, Facebook, etc.).

Nos projetos do canal, o allauth é sempre a primeira instalação após criar o projeto Django. Isso porque implementar autenticação segura do zero é complexo e sujeito a vulnerabilidades — o allauth tem anos de revisões de segurança e uma comunidade enorme. Não faz sentido reinventar a roda.

O que o Allauth oferece

• Registro de usuários com validação completa de senha e e-mail
• Verificação de e-mail obrigatória ou opcional antes do primeiro login
• Login social com mais de 50 provedores (Google, GitHub, Facebook, Apple, Twitter/X, Discord...)
• Recuperação de senha por e-mail com token seguro
• Múltiplos e-mails por conta de usuário (primário + secundários)
• Conexão de contas sociais a uma conta existente
• Integração com DRF via dj-rest-auth ou modo headless nativo para APIs
• Adaptadores customizáveis para controlar cada etapa do fluxo

Instalação

# Instalação básica
pip install django-allauth

# Para APIs com DRF (abordagem clássica):
pip install dj-rest-auth

# Para o modo headless nativo (recomendado em projetos novos):
pip install "django-allauth[headless]"

# Para JWT com dj-rest-auth:
pip install djangorestframework-simplejwt

Configuração no settings.py

INSTALLED_APPS = [
    # Apps padrão do Django
    'django.contrib.sites',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Allauth
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    # Provedores que você quer usar:
    'allauth.socialaccount.providers.google',
    'allauth.socialaccount.providers.github',

    # Para APIs (modo headless):
    'allauth.headless',     # OU instale dj-rest-auth se preferir

    # Suas apps
    'users',
    'blog',
]

SITE_ID = 1

AUTHENTICATION_BACKENDS = [
    # Permite login com username/email padrão do Django
    'django.contrib.auth.backends.ModelBackend',
    # Permite login via allauth (e-mail, provedores sociais)
    'allauth.account.auth_backends.AuthenticationBackend',
]

# Middleware necessário para allauth
MIDDLEWARE = [
    ...
    'allauth.account.middleware.AccountMiddleware',
]

# Configurações do allauth
ACCOUNT_EMAIL_REQUIRED = True
ACCOUNT_USERNAME_REQUIRED = False          # login por e-mail, sem username
ACCOUNT_AUTHENTICATION_METHOD = 'email'   # ou 'username' ou 'username_email'
ACCOUNT_EMAIL_VERIFICATION = 'mandatory'  # 'mandatory', 'optional', 'none'
ACCOUNT_UNIQUE_EMAIL = True
ACCOUNT_SESSION_REMEMBER = True
ACCOUNT_SIGNUP_PASSWORD_ENTER_TWICE = True

LOGIN_REDIRECT_URL = '/'
LOGOUT_REDIRECT_URL = '/'

# Configuração de e-mail (desenvolvimento)
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

# Em produção, use algo como:
# EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
# EMAIL_HOST = 'smtp.sendgrid.net'
# EMAIL_PORT = 587
# EMAIL_USE_TLS = True
# EMAIL_HOST_USER = 'apikey'
# EMAIL_HOST_PASSWORD = env('SENDGRID_API_KEY')
# DEFAULT_FROM_EMAIL = 'noreply@meusite.com'

URLs

from django.urls import path, include

urlpatterns = [
    # Para sites com templates (não SPA):
    path('accounts/', include('allauth.urls')),

    # Para APIs com dj-rest-auth:
    path('api/auth/', include('dj_rest_auth.urls')),
    path('api/auth/registration/', include('dj_rest_auth.registration.urls')),

    # Para modo headless (allauth nativo):
    path('_allauth/', include('allauth.headless.urls')),
]

# O allauth.urls cria automaticamente:
# /accounts/login/
# /accounts/logout/
# /accounts/signup/
# /accounts/password/reset/
# /accounts/email/
# /accounts/social/login/{provider}/  ← login social

Configurar Login com Google

O processo completo para habilitar o login com Google em um projeto Django:

1. Acesse o Google Cloud Console (console.cloud.google.com) e crie um projeto
2. Ative a Google+ API ou People API no projeto
3. Vá em "APIs e Serviços" → "Tela de consentimento OAuth" e configure como "Externo"
4. Vá em "Credenciais" → "Criar credenciais" → "ID do cliente OAuth 2.0"
5. Selecione "Aplicativo da Web" e adicione as URIs de redirecionamento autorizados:

# URIs de redirecionamento para o Google Console:
# Desenvolvimento:
http://localhost:8000/accounts/google/login/callback/

# Produção:
https://meusite.com/accounts/google/login/callback/

# Para modo headless/dj-rest-auth:
https://meusite.com/api/auth/google/

Após criar as credenciais, configure o provedor Google no settings.py (recomendado) ou via admin Django:

# settings.py — configuração via código (sem precisar do admin)
SOCIALACCOUNT_PROVIDERS = {
    'google': {
        'SCOPE': ['profile', 'email'],
        'AUTH_PARAMS': {'access_type': 'online'},
        'APP': {
            'client_id': env('GOOGLE_CLIENT_ID'),
            'secret': env('GOOGLE_CLIENT_SECRET'),
            'key': '',
        }
    },
    'github': {
        'SCOPE': ['user:email'],
        'APP': {
            'client_id': env('GITHUB_CLIENT_ID'),
            'secret': env('GITHUB_CLIENT_SECRET'),
        }
    }
}

Se preferir configurar via admin Django, vá em "Sites" e certifique-se que o site tem o domínio correto, depois vá em "Social Applications" e adicione Google com o Client ID e Secret.

Usando com dj-rest-auth (API + JWT)

Para APIs que precisam de autenticação JWT com login social, a combinaçãodj-rest-auth + django-allauth + simplejwt é o padrão:

# settings.py
REST_USE_JWT = True
JWT_AUTH_COOKIE = 'access-token'
JWT_AUTH_REFRESH_COOKIE = 'refresh-token'
JWT_AUTH_SECURE = True   # apenas HTTPS em produção
JWT_AUTH_HTTPONLY = True  # previne acesso via JavaScript

# Configurações dj-rest-auth
REST_AUTH = {
    'USE_JWT': True,
    'JWT_AUTH_COOKIE': 'access-token',
    'JWT_AUTH_REFRESH_COOKIE': 'refresh-token',
    'JWT_AUTH_SECURE': False,  # True em produção
    'JWT_AUTH_HTTPONLY': True,
    'SESSION_LOGIN': False,
}

# Opcional: serializer customizado para o registro
REST_AUTH_REGISTER_SERIALIZERS = {
    'REGISTER_SERIALIZER': 'users.serializers.CustomRegisterSerializer',
}

# Exemplo: registro + login com dj-rest-auth

# POST /api/auth/registration/
{
    "email": "usuario@exemplo.com",
    "password1": "MinhaSenh@123",
    "password2": "MinhaSenh@123"
}
# Resposta: 201 Created + envia e-mail de verificação

# POST /api/auth/login/
{
    "email": "usuario@exemplo.com",
    "password": "MinhaSenh@123"
}
# Resposta: 200 OK + cookies JWT ou:
{
    "access": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
    "refresh": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
    "user": {
        "id": 1,
        "email": "usuario@exemplo.com",
        ...
    }
}

Adaptadores customizados

Os Adapters são o ponto de extensão principal do allauth. Você pode customizar praticamente qualquer comportamento:

# users/adapters.py
from allauth.account.adapter import DefaultAccountAdapter
from allauth.socialaccount.adapter import DefaultSocialAccountAdapter

class MeuAccountAdapter(DefaultAccountAdapter):
    """Customiza o comportamento de contas locais."""

    def is_open_for_signup(self, request):
        # Desabilita registro público (somente convite)
        return getattr(settings, 'ACCOUNT_ALLOW_REGISTRATION', True)

    def save_user(self, request, user, form, commit=True):
        user = super().save_user(request, user, form, commit=False)
        # Adicione campos extras ao salvar
        user.nome_completo = form.cleaned_data.get('nome_completo', '')
        if commit:
            user.save()
        return user

    def send_confirmation_mail(self, request, emailconfirmation, signup):
        # Customiza o e-mail de confirmação
        # Ex: usar um template de e-mail transacional específico
        super().send_confirmation_mail(request, emailconfirmation, signup)

class MeuSocialAccountAdapter(DefaultSocialAccountAdapter):
    """Customiza o comportamento de contas sociais."""

    def pre_social_login(self, request, sociallogin):
        # Executado antes do login social ser processado
        # Ex: conectar conta social a conta existente pelo e-mail
        if sociallogin.is_existing:
            return
        email = sociallogin.account.extra_data.get('email')
        if email:
            from django.contrib.auth import get_user_model
            User = get_user_model()
            try:
                user = User.objects.get(email=email)
                sociallogin.connect(request, user)
            except User.DoesNotExist:
                pass

    def is_open_for_signup(self, request, sociallogin):
        return True

# settings.py — registrar os adapters customizados
ACCOUNT_ADAPTER = 'users.adapters.MeuAccountAdapter'
SOCIALACCOUNT_ADAPTER = 'users.adapters.MeuSocialAccountAdapter'

Signals do Allauth

O allauth emite signals em pontos-chave do fluxo de autenticação, permitindo executar lógica customizada:

from allauth.account.signals import user_signed_up, email_confirmed
from allauth.socialaccount.signals import social_account_added
from django.dispatch import receiver

@receiver(user_signed_up)
def usuario_registrado(request, user, **kwargs):
    """Executado após o registro bem-sucedido."""
    # Enviar e-mail de boas-vindas personalizado
    # Adicionar ao plano gratuito
    # Criar dados iniciais para o usuário
    Perfil.objects.get_or_create(usuario=user)
    enviar_email_boas_vindas.delay(user.id)  # via Celery

@receiver(email_confirmed)
def email_verificado(request, email_address, **kwargs):
    """Executado após o usuário verificar o e-mail."""
    user = email_address.user
    # Ativar recursos que requerem e-mail verificado
    user.perfil.email_verificado = True
    user.perfil.save()

@receiver(social_account_added)
def conta_social_adicionada(request, sociallogin, **kwargs):
    """Executado quando uma conta social é conectada."""
    provider = sociallogin.account.provider
    # Registrar analytics, sincronizar foto de perfil, etc.

Modelo de usuário customizado

A prática recomendada é sempre criar um modelo de usuário customizado no início do projeto, antes da primeira migration. O allauth se adapta automaticamente:

# users/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models

class User(AbstractUser):
    """Usuário customizado — adicione campos conforme precisar."""
    email = models.EmailField(unique=True)
    nome_completo = models.CharField(max_length=200, blank=True)
    avatar = models.ImageField(upload_to='avatars/', blank=True, null=True)
    bio = models.TextField(blank=True)
    criado_em = models.DateTimeField(auto_now_add=True)

    USERNAME_FIELD = 'email'  # login por e-mail
    REQUIRED_FIELDS = ['username']  # necessário para createsuperuser

    def __str__(self):
        return self.email

    @property
    def nome_exibido(self):
        return self.nome_completo or self.username or self.email.split('@')[0]

# settings.py
AUTH_USER_MODEL = 'users.User'  # DEVE ser configurado antes da primeira migration

Perguntas Frequentes