O desenvolvimento de APIs RESTful representa 73% dos projetos web modernos, segundo pesquisas recentes. Django, com seu robusto ecossistema, oferece ferramentas poderosas para criar APIs seguras e escaláveis. Este tutorial demonstra como implementar uma API REST completa com autenticação JWT, focando em práticas de segurança modernas.

Preparação do Ambiente de Desenvolvimento

Inicie criando um ambiente virtual isolado para evitar conflitos de dependências. Instale Python 3.8+ e configure o projeto base:

python -m venv venv
source venv/bin/activate  
 Linux/Mac

venv\\Scripts\\activate     
 Windows


django-admin startproject api_usuarios
cd api_usuarios

Instale as dependências essenciais para nossa API REST com suporte JWT:

pip install django>=4.2.0
pip install djangorestframework==3.14.0
pip install djangorestframework-simplejwt==5.3.0
pip install django-cors-headers==4.3.0

Configuração Base do Django REST Framework

Configure o arquivo settings.py com as configurações necessárias para JWT e CORS:

import datetime
from pathlib import Path

INSTALLED_APPS = [
    \'django.contrib.admin\',
    \'django.contrib.auth\',
    \'django.contrib.contenttypes\',
    \'django.contrib.sessions\',
    \'django.contrib.messages\',
    \'django.contrib.staticfiles\',
    \'rest_framework\',
    \'rest_framework_simplejwt.token_blacklist\',
    \'corsheaders\',
    \'usuarios\',
]

MIDDLEWARE = [
    \'corsheaders.middleware.CorsMiddleware\',
    \'django.middleware.security.SecurityMiddleware\',
    
 outros middlewares...

]

REST_FRAMEWORK = {
    \'DEFAULT_AUTHENTICATION_CLASSES\': (
        \'rest_framework_simplejwt.authentication.JWTAuthentication\',
    ),
    \'DEFAULT_PERMISSION_CLASSES\': [
        \'rest_framework.permissions.IsAuthenticated\',
    ],
}

SIMPLE_JWT = {
    \'ACCESS_TOKEN_LIFETIME\': datetime.timedelta(minutes=60),
    \'REFRESH_TOKEN_LIFETIME\': datetime.timedelta(days=7),
    \'ROTATE_REFRESH_TOKENS\': True,
}

Criando o Modelo de Usuário Customizado

Crie uma aplicação dedicada para gerenciar usuários:

python manage.py startapp usuarios

Implemente um modelo de usuário customizado no arquivo usuarios/models.py:

from django.contrib.auth.models import AbstractUser
from django.db import models

class UsuarioCustomizado(AbstractUser):
    email = models.EmailField(unique=True)
    data_criacao = models.DateTimeField(auto_now_add=True)
    ativo = models.BooleanField(default=True)
    perfil = models.CharField(
        max_length=20,
        choices=[(\'admin\', \'Administrador\'), (\'user\', \'Usuário\')],
        default=\'user\'
    )
    
    USERNAME_FIELD = \'email\'
    REQUIRED_FIELDS = [\'username\']
    
    class Meta:
        db_table = \'usuarios_customizado\'
        verbose_name = \'Usuário\'
        verbose_name_plural = \'Usuários\'

Configure o modelo customizado em settings.py:

AUTH_USER_MODEL = \'usuarios.UsuarioCustomizado\'

Implementando Serializers e ViewSets

Crie o arquivo usuarios/serializers.py para definir como os dados serão serializados:

from rest_framework import serializers
from django.contrib.auth.password_validation import validate_password
from .models import UsuarioCustomizado

class UsuarioSerializer(serializers.ModelSerializer):
    password = serializers.CharField(write_only=True, validators=[validate_password])
    password_confirm = serializers.CharField(write_only=True)
    
    class Meta:
        model = UsuarioCustomizado
        fields = (\'id\', \'username\', \'email\', \'password\', \'password_confirm\', \'perfil\')
    
    def validate(self, attrs):
        if attrs[\'password\'] != attrs[\'password_confirm\']:
            raise serializers.ValidationError("Senhas não coincidem.")
        return attrs
    
    def create(self, validated_data):
        validated_data.pop(\'password_confirm\')
        user = UsuarioCustomizado.objects.create_user(validated_data)
        return user

Implemente as views em usuarios/views.py:

from rest_framework import viewsets, status, permissions
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework_simplejwt.views import TokenObtainPairView
from .models import UsuarioCustomizado
from .serializers import UsuarioSerializer

class UsuarioViewSet(viewsets.ModelViewSet):
    queryset = UsuarioCustomizado.objects.all()
    serializer_class = UsuarioSerializer
    
    def get_permissions(self):
        if self.action == \'create\':
            permission_classes = [permissions.AllowAny]
        else:
            permission_classes = [permissions.IsAuthenticated]
        return [permission() for permission in permission_classes]
    
    @action(detail=False, methods=[\'get\'])
    def perfil(self, request):
        serializer = self.get_serializer(request.user)
        return Response(serializer.data)

Configurando URLs e Endpoints

Configure as rotas em usuarios/urls.py:

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView
from .views import UsuarioViewSet

router = DefaultRouter()
router.register(r\'usuarios\', UsuarioViewSet)

urlpatterns = [
    path(\'api/\', include(router.urls)),
    path(\'api/auth/login/\', TokenObtainPairView.as_view(), name=\'token_obtain_pair\'),
    path(\'api/auth/refresh/\', TokenRefreshView.as_view(), name=\'token_refresh\'),
]

Inclua as URLs principais em urls.py do projeto:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path(\'admin/\', admin.site.urls),
    path(\'\', include(\'usuarios.urls\')),
]

Medidas de Segurança Avançadas

A segurança em APIs REST vai além da autenticação básica. Implemente validações rigorosas e rate limiting:

 settings.py

REST_FRAMEWORK.update({
    \'DEFAULT_THROTTLE_CLASSES\': [
        \'rest_framework.throttling.AnonRateThrottle\',
        \'rest_framework.throttling.UserRateThrottle\'
    ],
    \'DEFAULT_THROTTLE_RATES\': {
        \'anon\': \'10/hour\',
        \'user\': \'100/hour\'
    }
})


 Configurações de segurança adicionais

SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = \'DENY\'

Comparação de Métodos de Autenticação

Método Vantagens Desvantagens Uso Recomendado
Sessions Simples implementação Não escalável Aplicações monolíticas
JWT Stateless, escalável Tokens podem ser grandes APIs REST modernas
API Keys Controle granular Gestão complexa Integrações B2B

Testes e Validação da API

Execute as migrações e teste a API:

python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser
python manage.py runserver

Teste os endpoints principais usando curl ou ferramentas como Postman:

 Registro de usuário

curl -X POST http://localhost:8000/api/usuarios/ \\
  -H "Content-Type: application/json" \\
  -d \'{"username":"teste","email":"teste@exemplo.com","password":"senha123","password_confirm":"senha123"}\'


 Login e obtenção do token

curl -X POST http://localhost:8000/api/auth/login/ \\
  -H "Content-Type: application/json" \\
  -d \'{"email":"teste@exemplo.com","password":"senha123"}\'

Deploy e Monitoramento

Para ambientes de produção, considere usar servidores VPS robustos que suportem Django adequadamente. Configure logs detalhados e monitore métricas de performance:

 settings.py para produção

LOGGING = {
    \'version\': 1,
    \'disable_existing_loggers\': False,
    \'handlers\': {
        \'file\': {
            \'level\': \'INFO\',
            \'class\': \'logging.FileHandler\',
            \'filename\': \'api.log\',
        },
    },
    \'loggers\': {
        \'django\': {
            \'handlers\': [\'file\'],
            \'level\': \'INFO\',
            \'propagate\': True,
        },
    },
}

Esta implementação fornece uma base sólida para APIs REST em Django com autenticação JWT segura. A arquitetura modular permite expansões futuras e integração com outros serviços, mantendo sempre os princípios de segurança e escalabilidade.