Django

Introducción

Django es un framework de desarrollo web de alto nivel para Python que fomenta un desarrollo rápido y limpio, siguiendo el patrón MTV (Model-Template-View). Está diseñado para facilitar la creación de aplicaciones web seguras, escalables y mantenibles.

  • Backend
  • python
  • REST Assured
  • Home - Django REST framework
  • Django documentation | Django documentation | Django

    Fundamentos de Django

  • MTV (Model-Template-View): Variante del patrón MVC.
    • Model: Define la estructura de la base de datos y maneja la lógica de los datos.
    • Template: Plantillas HTML que representan la vista que se entrega al usuario.
    • View: Controla la lógica que responde a las solicitudes del usuario y renderiza las respuestas.
  • ORM (Object-Relational Mapping): Permite interactuar con la base de datos usando objetos de Python en lugar de SQL directo.
  • Routing y URLs: Sistema de rutas que conecta URLs con funciones o clases de las vistas.
  • Administración automática: Panel de administración listo para usar con personalización mínima.
  • Seguridad integrada: Protege contra ataques comunes como XSS, CSRF, SQL Injection y clickjacking.

Instalación y configuración básica

# Crear un entorno virtual
python -m venv venv
source venv/bin/activate  # Linux/macOS
venv\Scripts\activate     # Windows

# Instalar Django
pip install django

# Crear un proyecto
django-admin startproject mi_proyecto

# Ejecutar servidor de desarrollo
python manage.py runserver

`

Estructura de un proyecto Django

  • manage.py: Script de gestión del proyecto.
  • Carpeta del proyecto (ej. mi_proyecto/):
  • settings.py: Configuraciones del proyecto.
  • urls.py: Configuración de rutas globales.
  • wsgi.py / asgi.py: Entrada del servidor web.
  • Aplicaciones (apps): Componentes modulares que encapsulan funcionalidades específicas.

Modelos y Base de Datos

  • Definición de modelos:
from django.db import models

class Autor(models.Model):
	nombre = models.CharField(max_length=100)
	email = models.EmailField(unique=True)
  • Migraciones:
python manage.py makemigrations
python manage.py migrate
  • Consultas ORM:
# Crear
autor = Autor.objects.create(nombre="Eduardo", email="eduardo@example.com")

# Leer
autores = Autor.objects.all()

# Filtrar
autor = Autor.objects.get(nombre="Eduardo")

# Actualizar
autor.email = "nuevo_email@example.com"
autor.save()

# Eliminar
autor.delete()

Vistas

  • Funciones basadas en vistas (FBV):
from django.http import HttpResponse

def inicio(request):
	return HttpResponse("Bienvenido a Django")
  • Clases basadas en vistas (CBV):
from django.views import View
from django.http import HttpResponse

class InicioView(View):
	def get(self, request):
		return HttpResponse("Bienvenido a Django desde CBV")

URLs

from django.urls import path
from .views import inicio, InicioView

urlpatterns = [
	path('', inicio, name='inicio'),
	path('inicio-cbv/', InicioView.as_view(), name='inicio-cbv'),
]

Templates

  • Ejemplo de template HTML (inicio.html):
<!DOCTYPE html>
<html>
<head>
	<title>Inicio</title>
</head>
<body>
	<h1>Bienvenido, {{ usuario }}</h1>
</body>
</html>
  • Renderizando desde vista:
from django.shortcuts import render

def inicio(request):
	contexto = {"usuario": "Eduardo"}
	return render(request, "inicio.html", contexto)

Formularios

  • Definición de formularios:
from django import forms

class ContactoForm(forms.Form):
	nombre = forms.CharField(max_length=100)
	email = forms.EmailField()
	mensaje = forms.CharField(widget=forms.Textarea)
  • Manejo en vistas:
def contacto(request):
	if request.method == "POST":
		form = ContactoForm(request.POST)
		if form.is_valid():
			# Procesar datos
			pass
	else:
		form = ContactoForm()
	return render(request, "contacto.html", {"form": form})

Django REST Framework (DRF)

  • Extiende Django para construir APIs REST de forma rápida y segura.

  • Conceptos clave:

    • Serializers: Convierte modelos a JSON y viceversa.
    • ViewSets: Combina lógica CRUD en una sola clase.
    • Routers: Simplifica la definición de rutas para APIs.
  • Ejemplo de serializer:
from rest_framework import serializers
from .models import Autor

class AutorSerializer(serializers.ModelSerializer):
	class Meta:
		model = Autor
		fields = '__all__'
  • Ejemplo de ViewSet:
from rest_framework import viewsets
from .models import Autor
from .serializers import AutorSerializer

class AutorViewSet(viewsets.ModelViewSet):
	queryset = Autor.objects.all()
	serializer_class = AutorSerializer
  • Registro de rutas en urls.py:
from rest_framework import routers
from .views import AutorViewSet

router = routers.DefaultRouter()
router.register(r'autores', AutorViewSet)

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

Seguridad y buenas prácticas

  • Mantener SECRET_KEY segura y no subirla a repositorios.
  • Usar DEBUG=False en producción.
  • Validar y sanear todos los inputs de usuario.
  • Implementar autenticación y permisos en DRF.

Django Avanzado

Autenticación y Autorización

  • Usuarios y Grupos:
    • Django proporciona un modelo de usuario incorporado (User) y soporte para grupos y permisos.
    • Permite asignar permisos específicos a usuarios o grupos de usuarios.
from django.contrib.auth.models import User, Group, Permission

# Crear un usuario
usuario = User.objects.create_user(username='eduardo', password='mi_password')

# Crear un grupo
grupo = Group.objects.create(name='editores')

# Asignar usuario al grupo
usuario.groups.add(grupo)

# Asignar permisos al grupo
permiso = Permission.objects.get(codename='add_autor')
grupo.permissions.add(permiso)

`

  • Autenticación basada en tokens y JWT (DRF):
    • Permite que clientes externos se autentiquen mediante tokens.
    • Uso común con APIs REST.
from rest_framework_simplejwt.tokens import RefreshToken

refresh = RefreshToken.for_user(usuario)
access_token = str(refresh.access_token)
  • Integración OAuth2 / social login:
    • Se puede integrar con django-allauth o social-auth-app-django para login con Google, GitHub, etc.

Middlewares

  • Los middlewares son clases que procesan solicitudes antes o después de la vista.
  • Se usan para logging, autenticación, manejo de sesiones, etc.
class MiMiddleware:
	def __init__(self, get_response):
		self.get_response = get_response

	def __call__(self, request):
		print("Antes de la vista")
		response = self.get_response(request)
		print("Después de la vista")
		return response
  • Se agregan en settings.py bajo MIDDLEWARE.

Señales (Signals)

  • Permiten ejecutar código automáticamente ante ciertos eventos de modelos.
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Autor

@receiver(post_save, sender=Autor)
def alerta_nuevo_autor(sender, instance, created, **kwargs):
	if created:
		print(f"Se ha creado un nuevo autor: {instance.nombre}")

Testing en Django

  • Unit tests y integration tests usando TestCase.
from django.test import TestCase
from .models import Autor

class AutorTestCase(TestCase):
	def setUp(self):
		Autor.objects.create(nombre="Eduardo", email="edu@example.com")

	def test_autor_creado(self):
		autor = Autor.objects.get(nombre="Eduardo")
		self.assertEqual(autor.email, "edu@example.com")
  • Pruebas de APIs con DRF:
from rest_framework.test import APIClient
from django.test import TestCase

class AutorAPITestCase(TestCase):
	def setUp(self):
		self.client = APIClient()
	def test_listar_autores(self):
		response = self.client.get('/api/autores/')
		self.assertEqual(response.status_code, 200)

Optimización y Performance

  • Querysets eficientes:
    • select_related para relaciones ForeignKey y OneToOne
    • prefetch_related para relaciones ManyToMany
autores = Autor.objects.select_related('perfil').all()
  • Caché con Redis:
    • Django soporta backend de cache redis para mejorar rendimiento.
CACHES = {
	'default': {
		'BACKEND': 'django_redis.cache.RedisCache',
		'LOCATION': 'redis://127.0.0.1:6379/1',
	}
}
  • Paginación y throttling en APIs:
    • Evita sobrecargar la API y mejora la experiencia del cliente.

Internacionalización y Localización

  • Traducciones con gettext y gettext_lazy.
from django.utils.translation import gettext_lazy as _

class Autor(models.Model):
	nombre = models.CharField(_("Nombre"), max_length=100)
  • Configuración de idiomas y zonas horarias en settings.py.

Tareas en Segundo Plano

  • Uso de Celery para jobs asíncronos.
# tasks.py
from celery import shared_task

@shared_task
def enviar_email(usuario_id):
	# Lógica para enviar email
	pass
  • Integración con Django y broker como Redis o RabbitMQ.

Deployment y DevOps

  • Producción segura:

    • DEBUG=False
    • ALLOWED_HOSTS correctamente configurado
    • Uso de Gunicorn como servidor WSGI y Nginx como proxy inverso

  • Dockerización:

FROM python:3.12
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "mi_proyecto.wsgi:application", "--bind", "0.0.0.0:8000"]
  • CI/CD: Integrar tests, migraciones y despliegues automáticos.

Seguridad y Buenas Prácticas Avanzadas

  • Protección CSRF y XSS habilitada por defecto.
  • Sanitizar inputs de usuario antes de guardarlos o renderizarlos.
  • Configuración de headers de seguridad: HSTS, Content Security Policy.
  • Implementación de autenticación fuerte y revisión de permisos en APIs.
  • Revisar vulnerabilidades con django-secure o análisis de dependencias.

Fundamentos y Arquitectura de Django

Arquitectura General

  • Django sigue el patrón MTV (Model-Template-View), similar a MVC pero con diferencias en la nomenclatura:
    • Model: Representa la estructura de datos y la lógica de acceso a la base de datos.
    • Template: Plantillas HTML que definen la presentación.
    • View: Lógica que procesa solicitudes, consulta modelos y devuelve respuestas renderizadas.
  • Flujo de una solicitud:
    1. El usuario realiza una petición HTTP.
    2. Django encuentra la vista correspondiente a través del URL dispatcher (urls.py).
    3. La vista procesa la solicitud: consulta modelos, aplica lógica de negocio y selecciona un template.
    4. Se renderiza el template y se devuelve una respuesta HTTP al cliente.

Componentes Clave

  • Proyecto Django: Conjunto de configuraciones generales (settings.py, urls.py, wsgi.py/asgi.py).
  • Aplicaciones (Apps): Módulos que encapsulan funcionalidades específicas. Un proyecto puede contener múltiples apps.
  • URLs y Routing: Sistema que mapea URLs a vistas.
  • ORM (Object-Relational Mapping): Permite trabajar con bases de datos mediante objetos Python, evitando escribir SQL directamente.
  • Middleware: Capas que procesan solicitudes/respuestas antes o después de las vistas.
  • Templates: Sistema de renderizado de HTML con variables y lógica de presentación.

Organización de un Proyecto Django


mi_proyecto/
│
├─ manage.py           # Script de gestión
├─ mi_proyecto/        # Configuración global del proyecto
│   ├─ settings.py     # Configuración principal
│   ├─ urls.py         # URLs globales
│   ├─ wsgi.py         # Entrada para servidores WSGI
│   └─ asgi.py         # Entrada para servidores ASGI
└─ apps/               # Carpeta opcional para apps del proyecto
├─ app1/
│   ├─ models.py
│   ├─ views.py
│   ├─ urls.py
│   └─ templates/
└─ app2/

Flujo de Datos Interno

  1. Solicitud HTTP llega al servidor Django.
  2. Pasa por la cadena de middlewares (autenticación, seguridad, sesiones).
  3. Se dirige al URL dispatcher para identificar la vista correspondiente.
  4. La vista procesa la solicitud:
    • Interactúa con modelos y la base de datos.
    • Prepara datos para la presentación.
  5. Se renderiza un template (o se devuelve JSON en APIs).
  6. La respuesta HTTP retorna al cliente.

Fundamentos Esenciales

  • Reactividad de datos: Los cambios en los modelos se reflejan mediante consultas y templates dinámicos.
  • Seguridad integrada: Django protege contra CSRF, XSS, SQL Injection y clickjacking por defecto.
  • Modularidad: Cada app es independiente y reutilizable.
  • Escalabilidad: Posibilidad de añadir apps, middleware y servicios externos (caché, colas de tareas) sin romper la arquitectura.
  • DRY (Don’t Repeat Yourself): Filosofía de minimizar duplicación de código mediante templates, herencia de vistas y apps reutilizables.

Integración con Django REST Framework (DRF)

  • DRF extiende Django para construir APIs siguiendo la misma arquitectura:
    • Serializers transforman modelos a JSON.
    • ViewSets gestionan CRUD en una sola clase.
    • Routers simplifican el enrutamiento de APIs.

Buenas Prácticas de Arquitectura

  • Mantener apps modulares y cohesivas.
  • Separar lógica de negocio (views, services) de presentación (templates).
  • Utilizar signals para lógica reactiva a eventos de modelos.
  • Aprovechar middleware para responsabilidades transversales (logging, seguridad, caching).
  • Diseñar URLs limpias y consistentes, evitando acoplar la estructura de la base de datos a las rutas.

Django — estado 2025: arquitectura, fundamentos y novedades recientes

Contexto general y versiones recientes 📦

  • La versión más reciente es Django 6.0 (candidata a lanzamiento, diciembre de 2025). (djangoproject.com)
  • La versión estable anterior, Django 5.2 (LTS), fue lanzada en abril de 2025. (gahd.net)
  • Django 5.2 recibirá soporte de seguridad hasta abril de 2028. (gahd.net)
  • En producción se recomienda usar versiones estables (o LTS) compatibles con la versión de Python, idealmente Python ≥ 3.12. (docs.djangoproject.com)

Arquitectura, fundamentos y flujo en Django (2025)

Principios estructurales

  • Django mantiene su filosofía de “batteries‑included”: ofrece su propio ORM, sistema de URL/routing, sistema de plantillas (templates), configuración central, gestión de usuarios, administración (admin), etc.
  • Sigue usando el patrón MTV (Model–Template–View), equivalente adaptado de MVC:
    • Model: definición de datos y lógica de acceso a base de datos.
    • Template: presentación (HTML, etc.).
    • View: lógica que procesa peticiones, consulta modelos y renderiza respuestas.
  • Una aplicación (app) representa un módulo funcional independiente; un proyecto puede contener múltiples apps.

Flujo de petición clásico (sincrónico)

  1. Llega una petición HTTP.
  2. Pasa por los middlewares configurados.
  3. El URL dispatcher (urls.py) selecciona la vista adecuada.
  4. La vista procesa la lógica: consulta modelos, aplica lógica de negocio, prepara datos.
  5. Se renderiza un template o se devuelve otro tipo de respuesta (JSON, etc).
  6. Se envía la respuesta al cliente.

Novedades 2024–2025: modernización, async y más

Soporte asíncrono y concurrencia mejorada

  • Con Django 5.x se amplió el soporte a vistas asíncronas, middlewares asíncronos y a ORM con queries async. Facilita construir aplicaciones en tiempo real (chat, websockets, notificaciones, etc.). (docs.djangoproject.com)
  • La compatibilidad con Python ≥ 3.12 permite aprovechar mejoras de rendimiento y type‑hints más sólidos. (buildwebproject.com)

Mejoras en productividad y experiencia de desarrollo

  • En Django 5.2 los modelos de todas las apps se importan automáticamente al abrir la shell (manage.py shell), simplificando pruebas rápidas o debug. (gahd.net)
  • Soporte para llaves primarias compuestas (composite primary keys) en modelos. (gahd.net)
  • Nuevos widgets de formulario: ColorInput, SearchInput, TelInput, alineándose con HTML5 y mejorando UX en formularios. (bastakiss.com)

Admin, interfaz y API design moderno

  • El panel de administración (admin) continúa mejorándose para ser más usable, flexible y moderno. (ecosistemastartup.com)
  • Creciente tendencia hacia diseño API‑first / headless: muchos proyectos usan Django solo como backend + API (REST o GraphQL) y manejan el frontend con frameworks modernos (React, Vue, etc.). (seye.dev)
  • Integraciones más maduras con GraphQL mediante librerías del ecosistema (por ejemplo Graphene-Django), facilitando APIs flexibles y optimizadas. (bastakiss.com)

Seguridad, mantenimiento y soporte a 2025

  • Django sigue siendo uno de los frameworks más seguros: incluye protección contra XSS, CSRF, SQL injection, etc. (seye.dev)
  • A finales de 2025 el equipo lanzó parches de seguridad para varias ramas soportadas, incluyendo la serie 5.2. (djangoproject.com)
  • Se recomienda mantenerse actualizado ante vulnerabilidades recientes. (unaaldia.hispasec.com)

Tendencias recientes en el ecosistema Django

  • Uso creciente de Django como backend + API (REST/GraphQL) + frontend desacoplado (SPAs). (seye.dev)
  • Ecosistema de paquetes activo: autenticación, APIs, CMS, deploy, async, etc. (blog.jetbrains.com)
  • Mayor integración con WebSockets, workflows asíncronos, contenedores, CI/CD, microservicios, AI/ML. (bastakiss.com)

Qué revisar hoy si empiezas un proyecto Django

  • Usa al menos Django 5.2 (LTS) o prepárate para migrar pronto a 6.0.
  • Usa Python 3.12+ para aprovechar mejoras de rendimiento y compatibilidad.
  • Para real‑time o I/O intensivo, adopta vistas, ORM y middlewares asíncronos.
  • Si el backend servirá APIs (REST o GraphQL), considera un frontend desacoplado.
  • Mantén dependencias actualizadas y revisa vulnerabilidades periódicamente.

Recursos útiles 2025