Django Rest Framework

Django Rest Framework más que una librearía es un framework que nos permite crear APIs REST de forma rápida y sencilla.

¿Qué es una API REST?

Una API REST (Representational State Transfer) es una interfaz de programación de aplicaciones que utiliza los métodos HTTP para realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) en recursos.

Instalación

Para instalar Django Rest Framework, ejecutamos el siguiente comando:

pip install djangorestframework

Una vez instalado, añadimos ‘rest_framework’ a la lista de aplicaciones instaladas en el archivo settings.py:

INSTALLED_APPS = [
    ...
    'rest_framework',
]

Actualizar el archivo requirements.txt

Es necesario eliminar el archivo requirements.txt y volver a crearlo con el siguiente comando:

pip freeze > requirements.txt

Serializers

Los serializadores nos permiten convertir los datos de nuestro modelo en un formato que pueda ser fácilmente consumido por una API REST.

Para crear un serializador, creamos un archivo serializers.py en la carpeta de nuestra aplicación y añadimos el siguiente código:

1from rest_framework import serializers
from .models import Producto

2class ProductoSerializer(serializers.ModelSerializer):
3    class Meta:
4        model = Producto
5        fields = '__all__'

1

Importamos el módulo serializers de Django Rest Framework.

2

Creamos un serializador ProductoSerializer que hereda de serializers.ModelSerializer.

3

Definimos la clase Meta para configurar el serializador.

4

Especificamos el modelo Producto que queremos serializar.

5

Indicamos que queremos serializar todos los campos del modelo Producto.

Views

Las vistas en Django Rest Framework son similares a las vistas en Django. En lugar de devolver una respuesta HTML, devuelven una respuesta JSON que puede ser consumida por una API REST.

Para crear una vista, creamos un archivo views.py en la carpeta de nuestra aplicación y añadimos el siguiente código:

1from rest_framework import viewsets
2from .serializers import ProductoSerializer
from .models import Producto

3class ProductoViewSet(viewsets.ModelViewSet):
    queryset = Producto.objects.all()
    serializer_class = ProductoSerializer

1

Importamos el módulo viewsets de Django Rest Framework.

2

Importamos el serializador ProductoSerializer que creamos anteriormente.

3

Creamos una vista ProductoViewSet que hereda de viewsets.ModelViewSet.

URLs de la Aplicación

Para conectar nuestras vistas con las URLs de nuestra aplicación, creamos un archivo urls.py en la carpeta de nuestra aplicación y añadimos el siguiente código:

from django.urls import path
1from .views import ProductoViewSet

urlpatterns = [
2    path('api/productos/', ProductoViewSet.as_view({'get': 'list', 'post': 'create'}), name='api-productos'),
3    path('api/productos/<int:pk>/', ProductoViewSet.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'}), name='api-producto-detail'),
]

1

Importamos la vista ProductoViewSet que creamos anteriormente.

2

Configuramos la URL ‘/api/productos/’ para listar y crear productos.

3

Configuramos la URL ‘/api/productos/<int:pk>/’ para ver, actualizar y eliminar un producto específico.

Configuración URLs del Proyecto

Para configurar nuestra API REST, añadimos las URLs de nuestra aplicación a las URLs del proyecto en el archivo urls.py de la carpeta del proyecto:

from django.contrib import admin
from django.urls import path, include
from rest_framework import routers
from productos.views import ProductoViewSet

# Creamos un enrutador para las vistas de Django REST Framework
router = routers.DefaultRouter()
router.register(r'productos', ProductoViewSet)

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

Migraciones

Antes de utilizar nuestra API REST, debemos aplicar las migraciones necesarias para crear las tablas en la base de datos:

python manage.py makemigrations
python manage.py migrate

Instalación de setuptools

Para instalar setuptools, ejecutamos el siguiente comando:

pip install setuptools

Es necesario la instalación de setuptools para poder instalar las dependencias necesarias para el proyecto.

Ejecución

Una vez configurada nuestra API REST, podemos ejecutar el servidor de desarrollo de Django y acceder a la API a través de un navegador o una herramienta como Postman:

python manage.py runserver

En este caso, la API estará disponible en la ruta ‘http://127.0.0.1:8000/api/productos/’.

Documentación de la API con drf-yasg

Primero instalamos el paquete de documentación de la API:

pip install drf-yasg

Luego, añadimos ‘drf_yasg’ a la lista de aplicaciones instaladas en el archivo settings.py:

INSTALLED_APPS = [
    ...
    'drf_yasg',
]

Añadimos las URLs de la documentación de la API a las URLs del proyecto en el archivo urls.py de la carpeta del proyecto:

from django.urls import path, include
from rest_framework import routers
from productos.views import ProductoViewSet
from rest_framework.permissions import AllowAny
from drf_yasg.views import get_schema_view
from drf_yasg import openapi

router = routers.DefaultRouter()
router.register(r'productos', ProductoViewSet)

schema_view = get_schema_view(
   openapi.Info(
      title="API de Productos",
      default_version='v1',
      description="Documentación de la API de Productos",
      terms_of_service="https://www.google.com/policies/terms/",
      contact=openapi.Contact(email="contact@example.com"),
      license=openapi.License(name="BSD License"),
   ),
   public=True,
   permission_classes=(AllowAny,),
)

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('productos.urls')),
    path('api/', include(router.urls)),
    path('swagger/', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'),
    path('redoc/', schema_view.with_ui('redoc', cache_timeout=0), name='schema-redoc'),
]

Una vez configurada la documentación de la API, podemos ejecutar el servidor de desarrollo de Django y acceder a la documentación de la API a través de un navegador:

python manage.py runserver

Documentación de la API con CoreAPI

CoreAPI es una biblioteca que facilita la creación y el consumo de APIs.

Primero instalamos CoreAPI:

pip install coreapi

Para generar la documentación automáticamente, agregamos la configuración en settings.py:

REST_FRAMEWORK = {
    'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.coreapi.AutoSchema'
}

Luego, añadimos la vista de esquema en el archivo urls.py de la carpeta del proyecto:

from rest_framework.schemas import get_schema_view

schema_view = get_schema_view(title='API de Productos')

urlpatterns += [
    path('docs/', schema_view, name='api-docs'),
]

Ahora podemos ejecutar el servidor de desarrollo y acceder a la documentación generada por CoreAPI en la ruta ‘/docs/’:

python manage.py runserver

Con estos pasos, hemos integrado Django Rest Framework, documentado nuestra API con drf-yasg y CoreAPI.

Corsheaders

Para permitir que nuestra API REST sea accesible desde un dominio diferente al de la aplicación, necesitamos instalar el paquete django-cors-headers.

Primero instalamos el paquete:

pip install django-cors-headers

Luego, añadimos ‘corsheaders’ a la lista de aplicaciones instaladas en el archivo settings.py:

INSTALLED_APPS = [
    ...
    'corsheaders',
]

Añadimos el middleware de corsheaders en el archivo settings.py:

MIDDLEWARE = [
    ...
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    ...
]

Configuramos las opciones de corsheaders en el archivo settings.py:

CORS_ALLOW_ALL_ORIGINS = True

CORS_ALLOWED_ORIGINS = [
    'http://localhost:5173',  # Origen del frontend
]

Con estas configuraciones, nuestra API REST estará disponible para ser consumida desde el origen especificado.

Conclusiones

Django Rest Framework es una herramienta poderosa para crear APIs REST en Django de forma rápida y sencilla. Con la documentación de la API, podemos facilitar el uso y la comprensión de nuestra API por parte de los desarrolladores. La integración de CoreAPI y drf-yasg nos permite generar documentación automáticamente y visualizarla en un navegador de forma interactiva. Con corsheaders, podemos permitir que nuestra API sea accesible desde un dominio diferente al de la aplicación. En resumen, Django Rest Framework nos proporciona las herramientas necesarias para crear APIs REST robustas y bien documentadas en Django.

Referencias

• Django Rest Framework
• Django Rest Framework - Documentación
• drf-yasg
• CoreAPI