Actividad 2. API REST de productos en Django

1. Preparamos el proyecto

Levantamos el proyecto anterior de productos

• Docker con MySQL
• Entrono virtual
• Lanzamos el servidor

1.1. MySQL + Docker

Lo lanzamos con Docker desktop

1.2. Proyecto + venv

Abrimos el proyecto y activamos el entorno virtual

Windows

 .\venv\Scripts\Activate.ps1

Mac

source venv/bin/activate

1.3. Lanzamos el servidor

Entramos en la carpeta del proyecto

cd TiendaVirtual

Lanzamos el servidor

python manage.py runserver

Y nos sale ya el servidor levantado por el puerto 8000

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
December 04, 2025 - 04:51:07
Django version 5.2, using settings 'TiendaVirtual.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

WARNING: This is a development server. Do not use it in a production setting. Use a production WSGI or ASGI server instead.
For more information on production servers see: https://docs.djangoproject.com/en/5.2/howto/deployment/

2. Django REST Framework

Instalamos en el entorno virtual las dependencias 

pip install djangorestframework

Añadimos Django REST Framework en TiendaVirtual/settings.py

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
     # nuestra app, ya estaba
    'productos', 
     # añadir esto
    'rest_framework',  
]

3. Serializar los modelos

Vamos a serializar solo productos (categorías no lo pide), convierte objetos Producto en JSON y viceversa.

En la app productos, creamos un archivo nuevo: productos/serializers.py:

from rest_framework import serializers
from .models import Producto

class ProductoSerializer(serializers.ModelSerializer):
    """
    Serializador del modelo Producto.
    Convierte objetos Producto en JSON y viceversa.
    """
    class Meta:
        model = Producto
        fields = [
            'id',
            'nombre',
            'descripcion',
            'precio',
            'stock',
            'disponible',
            'fecha_creacion',
            'categoria',
        ]

4. ViewSet de la API

Creamos la API REST para gestionar productos, 

productos/api.py

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

class ProductoViewSet(viewsets.ModelViewSet):
    """
    API REST para gestionar productos.
    
    Permite realizar las operaciones CRUD:
    - Crear
    - Consultar
    - Actualizar
    - Eliminar
    """
    queryset = Producto.objects.all()
    serializer_class = ProductoSerializer

5. Rutas de la API

Actualizamos el archivo urls para indicar dónde se harían las peticiones de la API

TiendaVirtual/urls.py

El fichero original: 

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

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

El nuevo fichero con las modificaciones:

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

from rest_framework.routers import DefaultRouter
from productos.api import ProductoViewSet

# Enrutador automático de Django REST Framework
router = DefaultRouter()
router.register('productos', ProductoViewSet, basename='producto')

urlpatterns = [
    path('admin/', admin.site.urls),
    # Rutas de la parte web (plantillas/templates)
    path('productos/',include('productos.urls')),

    # Rutas de la API REST
    path('api/', include(router.urls)),
]

6. Probando la API

Para probar la API, utilizamos su interfaz web, DRF (Django REST Framework)

• http://localhost:8000/api/
• http://localhost:8000/api/productos/

Lo que tendremos es una página HTML con:

• La lista de productos en JSON.

• Un formulario para crear productos (si eliges POST en el desplegable).

• Cada producto tendrá un enlace a su detalle:

  http://127.0.0.1:8000/api/productos/1/, .../2/, etc.

En esa interfaz puedes:

• Hacer GET (listar/ver uno)

• Hacer POST (crear)

• Hacer PUT/PATCH (editar)

• Hacer DELETE (borrar)

Todo desde el navegador, sin Postman.

6.1. Acceso a la API desde el navegador

Ejemplos de uso de la API desde el navegador

6.2. Acceso a la API por Postman

Ejemplos para Postman

7. Recuerda que todo esto está en la base de datos

Cuando utilizas la API en el navegador o en Postman, no estás trabajando con archivos ni datos temporales, sino con una base de datos real (MySQL, en este caso).

Cada vez que haces una petición a la API (GET, POST, PUT, PATCH o DELETE), estás modificando directamente la base de datos MySQL.

Lo que ves en el navegador o en Postman refleja exactamente lo que hay dentro de la tabla productos_producto.

La API es simplemente la “puerta de entrada” para leer, crear o modificar datos en la base de datos.

Cada vez que creas un producto (POST)

Cuando envías datos como:

{
  "nombre": "Teclado Mecánico RGB",
  "precio": 49.99,
  "stock": 20
}

• Django REST Framework recibe el JSON
• Lo valida con el serializador
• Crea un nuevo objeto Producto
• Lo guarda en la tabla productos_producto de MySQL

En SQL sería algo como:

INSERT INTO productos_producto (nombre, descripcion, precio, stock, disponible, categoria_id)
VALUES ("Teclado Mecánico RGB", "Teclado gaming con luces", 49.99, 20, 1, 1);

Cuando listas todos los productos (GET)

Al entrar en:

/api/productos/

Django hace una consulta SQL:

SELECT * FROM productos_producto;

Y convierte cada fila de la tabla en un objeto JSON.

Cuando ves un producto concreto (GET /id/)

Al entrar en

/api/productos/3/

Django ejecuta:

SELECT * FROM productos_producto WHERE id = 3 LIMIT 1;

Y te devuelve ese producto en formato JSON.

Cuando actualizas un producto (PUT o PATCH)

Ejemplo

{
  "precio": 39.99
}

Django localiza ese registro por ID

Modifica solo los valores enviados (PATCH)

Y ejecuta:

UPDATE productos_producto
SET precio = 39.99
WHERE id = 3;

Cuando borras un producto (DELETE

Al hacer:

DELETE /api/productos/4/

Django ejecuta:

DELETE FROM productos_producto WHERE id = 4;

Ese producto desaparece totalmente de la base de datos.