Creación de una API REST con Django Rest Framework

Django Rest Framework (DRF) es un potente framework basado en Django para crear APIs RESTful de manera sencilla y escalable. Facilita la serialización de datos, la gestión de autenticación y permisos, y la implementación de buenas prácticas REST. Es clave en el desarrollo moderno, permitiendo la integración eficiente con frontend y otros servicios. 🚀

Requisitos Previos

  • Python 3.8 o superior
  • pip (gestor de paquetes de Python)
  • virtualenv (para gestión de entornos virtuales) Crear entorno

Instalación de Herramientas

bash
# Verificar versión de Python
python3 --version

# Instalar virtualenv
pip install virtualenv

Configuración del Entorno Virtual

bash
# Crear directorio para el proyecto
mkdir mi_proyecto_api
cd mi_proyecto_api

# Crear entorno virtual
python3 -m venv venv

# Activar entorno virtual
# En sistemas Unix/macOS
source venv/bin/activate

# En Windows
venvScriptsactivate

Instalar Django y Django Rest Framework

bash
# Instalar Django y DRF
pip install django djangorestframework

# Crear archivo de requirements
pip freeze > requirements.txt

Verifica la instalación de Django

bash
django-admin --version

Deberías ver la versión de Django instalada.

Crear Proyecto Django


bash
# Crear nuevo proyecto Django
django-admin startproject config .

# Crear aplicación para la API
python manage.py startapp api

1. Configuración de Settings

En config/settings.py, añadir las aplicaciones:

python
INSTALLED_APPS = [
  'django.contrib.admin',
  'django.contrib.auth',
  'django.contrib.contenttypes',
  'django.contrib.sessions',
  'django.contrib.messages',
  'django.contrib.staticfiles',
  
  # Aplicaciones de terceros
  'rest_framework',
  
  # Aplicaciones propias
  'api',
]

2. Diseño de Modelos

Crea un modelo en la aplicación api que quieres exponer como parte de la API. Abre api/models.py y define el siguiente modelo de ejemplo:

python
from django.db import models

class Libro(models.Model):
  titulo = models.CharField(max_length=200)
  autor = models.CharField(max_length=100)
  publicacion = models.DateField()
  isbn = models.CharField(max_length=13, unique=True)
  
  def __str__(self):
      return self.titulo

3. Crear Migraciones

Crea las migraciones y aplica los cambios a la base de datos:

bash
# Crear migraciones
python manage.py makemigrations

# Aplicar migraciones
python manage.py migrate

4. Serializers

En DRF, los serializadores convierten los datos de los modelos en formatos como JSON para enviarlos a través de la API.

Crea un archivo llamado serializers.py dentro de la carpeta api y define el serializador para el modelo Libro:

python
# importar DRF serializers
from rest_framework import serializers
# importar el modelo
from .models import Libro

# Definir el serializador de Libro
class LibroSerializer(serializers.ModelSerializer):
  class Meta:
      model = Libro
      fields = ['id', 'titulo', 'autor', 'publicacion', 'isbn']

      # Tambien puedes  usar fields = '__all__' para serializar todos los campos

5. Registrar el Modelo en Django Admin

Registra el modelo Libro en el panel de administración:

python
from django.contrib import admin
from .models import Libro

admin.site.register(Libro)

5. Vistas (Views)

En Django Rest Framework (DRF), existen dos enfoques para definir vistas: vistas basadas en funciones (FBV) y vistas basadas en clases (CBV). Ambos permiten manejar solicitudes HTTP (GET, POST, PUT, DELETE), pero ofrecen distintos niveles de abstracción y flexibilidad.

Vistas basadas en clases (CBV)


Las vistas basadas en clases proporcionan una estructura más organizada y reutilizable. DRF ofrece ViewSets, que simplifican la creación de APIs RESTful.

Ejemplo: api/views.py

python
from rest_framework import viewsets
from .models import Libro
from .serializers import LibroSerializer

class LibroViewSet(viewsets.ModelViewSet):
  queryset = Libro.objects.all()
  serializer_class = LibroSerializer

Vistas Basadas en Funciones (FBV)**


Las vistas basadas en funciones son más directas y fáciles de entender, lo que las hace ideales para proyectos pequeños o para quienes buscan mayor flexibilidad en el manejo de solicitudes. Su simplicidad facilita la depuración y personalización del flujo de datos.

Ejemplo: api/views.py

bash
from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Libro
from .serializers import LibroSerializer

@api_view(['GET', 'POST'])
def libro_list(request):
  if request.method == 'GET':
      libros = Libro.objects.all()
      serializer = LibroSerializer(libros, many=True)
      return Response(serializer.data)

  elif request.method == 'POST':
      serializer = LibroSerializer(data=request.data)
      if serializer.is_valid():
          serializer.save()
          return Response(serializer.data, status=201)
      return Response(serializer.errors, status=400)

@api_view(['GET', 'PUT', 'DELETE'])
def libro_detail(request, pk):
  try:
      libro = Libro.objects.get(pk=pk)
  except Libro.DoesNotExist:
      return Response({'detail': 'Not found'}, status=404)

  if request.method == 'GET':
      serializer = LibroSerializer(libro)
      return Response(serializer.data)

  elif request.method == 'PUT':
      serializer = LibroSerializer(libro, data=request.data)
      if serializer.is_valid():
          serializer.save()
          return Response(serializer.data)
      return Response(serializer.errors, status=400)

  elif request.method == 'DELETE':
      libro.delete()
      return Response(status=204)
  Explicación

  • libro_list maneja las solicitudes GET para obtener todos los libros y POST para crear un nuevo libro.
  • libro_detail maneja las solicitudes GET para obtener un libro por su pk, PUT para actualizar un libro y DELETE para eliminar un libro.
  • viewsets.ModelViewSet: Proporciona métodos predefinidos para manejar operaciones CRUD (Create, Read, Update, Delete).

Recuerda: En las vistas basadas en función, debes manejar manualmente las respuestas para cada tipo de solicitud HTTP.

6. Configuración de URLs

Para definir los endpoints de la API con vistas basadas en funciones, primero debemos configurar el archivo api/urls.py y luego registrarlo en config/urls.py.

1. Definir las rutas en api/urls.py

Abre api/urls.py y agrega lo siguiente:

python
from django.urls import path
from .views import libro_list, libro_detail

urlpatterns = [
  path('libros/', libro_list, name='libro-list'),  # Endpoint para listar y crear libros
  path('libros/<int:pk>/', libro_detail, name='libro-detail'),  # Endpoint para obtener, actualizar y eliminar un libro específico
]

2. Registrar las rutas en config/urls.py

Ahora, abre config/urls.py y agrega la referencia a api.urls:

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

urlpatterns = [
  path('admin/', admin.site.urls),
  path('api/', include('api.urls')),  # Incluye las rutas de la aplicación `api`
]
  Resumen

Con esta configuración, los endpoints estarán disponibles en:
GET /api/libros/ → Listar libros
POST /api/libros/ → Crear un nuevo libro
GET /api/libros/<id>/ → Obtener detalles de un libro
PUT /api/libros/<id>/ → Actualizar un libro
DELETE /api/libros/<id>/ → Eliminar un libro

7. Configuración de Permisos y Autenticación

Para agregar autenticación básica, abre config/settings.py y configura el sistema de autenticación:

python
REST_FRAMEWORK = {
  'DEFAULT_PERMISSION_CLASSES': [
      'rest_framework.permissions.IsAuthenticated',
  ],
  'DEFAULT_AUTHENTICATION_CLASSES': [
      'rest_framework.authentication.SessionAuthentication',
      'rest_framework.authentication.BasicAuthentication',
  ]
}

8. Ejecutar Servidor de Desarrollo

bash
python manage.py runserver

9. Endpoints Disponibles

Ahora puedes acceder a tu API en http://127.0.0.1:8000/api/libros/. Esta ruta permitirá:

  Formularios y Manejo de Datos

  • GET /api/libros/: Listar libros
  • POST /api/libros/: Crear libro
  • GET /api/libros/{id}/: Detalle de libro
  • PUT /api/libros/{id}/: Actualizar libro
  • DELETE /api/libros/{id}/: Eliminar libro

10. Crear un Superusuario

Si no tienes un superusuario para acceder al panel de administración de Django, crea uno:

bash
python manage.py createsuperuser

Sigue las instrucciones para configurar un nombre de usuario, correo electrónico y contraseña. Accede al panel de administración en http://127.0.0.1:8000/admin/ con las credenciales creadas.