Tutorial Autenticación Django JWT: Guía Completa para Crear un Sistema Login Seguro

En este tutorial detallado aprenderás a implementar un sistema de autenticación seguro en Django usando JSON Web Tokens (JWT). Está dirigido a desarrolladores principiantes e intermedios que desean crear APIs con autenticación fiable y sencilla de usar.

Índice

Introducción
Configuración del Proyecto Django
Instalación y Configuración de Librerías JWT
Creación de Endpoints de Registro, Login y Renovación de Tokens
Protección de Vistas y Manejo de Permisos
Pruebas con Postman
Conclusión y Buenas Prácticas

Introducción

Django es un framework web muy potente y seguro que facilita la creación de aplicaciones robustas. Para proyectos con APIs REST, la autenticación basada en JSON Web Tokens es popular porque es stateless, escalable y compatible con múltiples clientes.

En este tutorial aprenderás:

Configurar y crear un proyecto completamente funcional con Django y Django REST Framework.
Instalar la librería djangorestframework-simplejwt para manejar JWT.
Crear endpoints para registro de usuarios, login (emisión de tokens) y renovación de tokens.
Proteger rutas usando permisos y autenticación basada en JWT.
Probar el sistema usando Postman para verificar que funciona correctamente.

Configuración del Proyecto Django

Paso 1: Crear un entorno virtual y nuevo proyecto

Recomendamos usar un entorno virtual para gestionar dependencias separadas. En la terminal:

python -m venv env
source env/bin/activate  # Linux/macOS
env\Scripts\activate     # Windows

python -m venv env

source env/bin/activate # Linux/macOS

env\Scripts\activate # Windows

Luego instalamos Django y Django REST Framework:

pip install django djangorestframework

1 2	pip install django djangorestframework

Creamos un nuevo proyecto llamado auth_project y una app llamada users:

django-admin startproject auth_project
cd auth_project
python manage.py startapp users

django-admin startproject auth_project

cd auth_project

python manage.py startapp users

Paso 2: Configurar settings.py

Abre auth_project/settings.py y añade las apps al arreglo INSTALLED_APPS:

INSTALLED_APPS = [
    # apps de Django
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # apps externas
    'rest_framework',

    # app del proyecto
    'users',
]

INSTALLED_APPS = [

# apps de Django

'django.contrib.admin',

'django.contrib.auth',

'django.contrib.contenttypes',

'django.contrib.sessions',

'django.contrib.messages',

'django.contrib.staticfiles',

# apps externas

'rest_framework',

# app del proyecto

'users',

]

Configura el REST Framework para usar JWT en las vistas protegidas:

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

REST_FRAMEWORK = {

'DEFAULT_AUTHENTICATION_CLASSES': (

'rest_framework_simplejwt.authentication.JWTAuthentication',

'DEFAULT_PERMISSION_CLASSES': (

'rest_framework.permissions.IsAuthenticated',

}

Instalación y Configuración de Librerías JWT

Paso 3: Instalar Simple JWT

Para manejar JWT en Django REST Framework, instalamos djangorestframework-simplejwt:

pip install djangorestframework-simplejwt

1 2	pip install djangorestframework-simplejwt

Paso 4: Configuración básica de Simple JWT

Agrega las configuraciones para los tokens JWT en settings.py (opcionalmente puedes ajustar la duración de los tokens):

from datetime import timedelta

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=30),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=7),
    'AUTH_HEADER_TYPES': ('Bearer',),
}

from datetime import timedelta

SIMPLE_JWT = {

'ACCESS_TOKEN_LIFETIME': timedelta(minutes=30),

'REFRESH_TOKEN_LIFETIME': timedelta(days=7),

'AUTH_HEADER_TYPES': ('Bearer',),

}

Esto define que el token de acceso dura 30 minutos y el token de renovación una semana.

Creación de Endpoints de Registro, Login y Renovación de Tokens

Paso 5: Crear el serializer para registro

Dentro de la app users, crea el archivo serializers.py con el siguiente contenido:

from rest_framework import serializers
from django.contrib.auth.models import User

class RegisterSerializer(serializers.ModelSerializer):
    password = serializers.CharField(write_only=True, required=True)
    password2 = serializers.CharField(write_only=True, required=True)

    class Meta:
        model = User
        fields = ['username', 'email', 'password', 'password2']

    def validate(self, attrs):
        if attrs['password'] != attrs['password2']:
            raise serializers.ValidationError({'password': "Las contraseñas no coinciden."})
        return attrs

    def create(self, validated_data):
        user = User.objects.create(
            username=validated_data['username'],
            email=validated_data['email'],
        )
        user.set_password(validated_data['password'])
        user.save()
        return user

from rest_framework import serializers

from django.contrib.auth.models import User

class RegisterSerializer(serializers.ModelSerializer):

password = serializers.CharField(write_only=True, required=True)

password2 = serializers.CharField(write_only=True, required=True)

class Meta:

model = User

fields = ['username', 'email', 'password', 'password2']

def validate(self, attrs):

if attrs['password'] != attrs['password2']:

raise serializers.ValidationError({'password': "Las contraseñas no coinciden."})

return attrs

def create(self, validated_data):

user = User.objects.create(

username=validated_data['username'],

email=validated_data['email'],

)

user.set_password(validated_data['password'])

user.save()

return user

Paso 6: Crear la vista para el registro

Edita users/views.py:

from rest_framework import generics, status
from rest_framework.response import Response
from .serializers import RegisterSerializer

class RegisterView(generics.CreateAPIView):
    serializer_class = RegisterSerializer
    permission_classes = []  # Permitir acceso sin autenticación

    def post(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        user = serializer.save()
        return Response({'message': 'Usuario creado correctamente!'}, status=status.HTTP_201_CREATED)

from rest_framework import generics, status

from rest_framework.response import Response

from .serializers import RegisterSerializer

class RegisterView(generics.CreateAPIView):

serializer_class = RegisterSerializer

permission_classes = [] # Permitir acceso sin autenticación

def post(self, request, *args, **kwargs):

serializer = self.get_serializer(data=request.data)

serializer.is_valid(raise_exception=True)

user = serializer.save()

return Response({'message': 'Usuario creado correctamente!'}, status=status.HTTP_201_CREATED)

Paso 7: Configurar URLs para login y renovación usando SimpleJWT

Creamos users/urls.py:

from django.urls import path
from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
)
from .views import RegisterView

urlpatterns = [
    path('register/', RegisterView.as_view(), name='register'),
    path('login/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]

from django.urls import path

from rest_framework_simplejwt.views import (

TokenObtainPairView,

TokenRefreshView,

)

from .views import RegisterView

urlpatterns = [

path('register/', RegisterView.as_view(), name='register'),

path('login/', TokenObtainPairView.as_view(), name='token_obtain_pair'),

path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),

]

Luego enlaza la app users en el archivo general de URLs auth_project/urls.py:

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/auth/', include('users.urls')),
]

from django.contrib import admin

from django.urls import path, include

urlpatterns = [

path('admin/', admin.site.urls),

path('api/auth/', include('users.urls')),

]

Protección de Vistas y Manejo de Permisos

Paso 8: Crear una vista protegida de ejemplo

Vamos a crear una vista sencilla accesible solo con token válido.

Edita users/views.py e importa:

from rest_framework.views import APIView
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response

class ProfileView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        user = request.user
        data = {
            'username': user.username,
            'email': user.email,
            'id': user.id,
        }
        return Response(data)

from rest_framework.views import APIView

from rest_framework.permissions import IsAuthenticated

from rest_framework.response import Response

class ProfileView(APIView):

permission_classes = [IsAuthenticated]

def get(self, request):

user = request.user

data = {

'username': user.username,

'email': user.email,

'id': user.id,

}

return Response(data)

Agrega esta ruta para la vista protegida en users/urls.py:

# Importa la vista
from .views import ProfileView

urlpatterns += [
    path('profile/', ProfileView.as_view(), name='profile'),
]

# Importa la vista

from .views import ProfileView

urlpatterns += [

path('profile/', ProfileView.as_view(), name='profile'),

]

Conceptos clave:

Solo usuarios autenticados con un token JWT válido podrán acceder a /api/auth/profile/.
En las demás vistas también puedes usar decoradores o permisos personalizados para controlar acceso.

Pruebas con Postman

Paso 9: Verifica los endpoints

Registro:

URL: POST http://localhost:8000/api/auth/register/
Body (JSON):

{
    "username": "usuario1",
    "email": "usuario1@example.com",
    "password": "contrasena123",
    "password2": "contrasena123"
}

{

"username": "usuario1",

"email": "usuario1@example.com",

"password": "contrasena123",

"password2": "contrasena123"

}

Debería responder con un mensaje de éxito.

Login:

URL: POST http://localhost:8000/api/auth/login/
Body (JSON):

{
    "username": "usuario1",
    "password": "contrasena123"
}

{

"username": "usuario1",

"password": "contrasena123"

}

Respuesta:

{
    "refresh": "token_refresh",
    "access": "token_access"
}

{

"refresh": "token_refresh",

"access": "token_access"

}

Acceso a ruta protegida:

URL: GET http://localhost:8000/api/auth/profile/
Headers:

Authorization: Bearer token_access

1 2	Authorization: Bearer token_access

Deberías recibir los datos del usuario autenticado.

Renovación del token:

URL: POST http://localhost:8000/api/auth/token/refresh/
Body (JSON):

{
    "refresh": "token_refresh"
}

{

"refresh": "token_refresh"

}

Obtendrás un nuevo token de acceso.

Paso 10: Ejecutar servidor

No olvides levantar el servidor Django:

python manage.py migrate
python manage.py runserver

python manage.py migrate

python manage.py runserver

Conclusión y Buenas Prácticas

En este tutorial autenticación Django JWT has aprendido a crear un sistema login Django seguro y sencillo, ideal para APIs. Usar JSON Web Tokens ayuda a distribuir la autenticación sin mantener sesiones en el servidor, mejorando la escalabilidad.

Buenas prácticas para autenticación segura Django:

Siempre usar HTTPS para proteger tokens en tránsito.
Limitar la duración de los tokens de acceso para minimizar riesgos.
Usar tokens de renovación para mejorar experiencia de usuario.
Validar datos en el registro para evitar usuarios inválidos.
Mantener las dependencias actualizadas para evitar vulnerabilidades.
Proteger endpoints sensibles con permisos estrictos.

Si te ha sido útil este tutorial, te invitamos a:

Implementarlo en tus proyectos y mejorarlo.
Compartirlo con otros desarrolladores.
Experimentar con permisos y roles avanzados.

¡Empieza hoy mismo a crear APIs Django con autenticación segura y profesional!