Skip to content

6. Ámbitos de datos

Una aplicación web atiende a muchos usuarios a la vez, y cada usuario realiza numerosas solicitudes. Por lo tanto, los datos pueden compartirse en varios niveles, denominados su ámbito:

  • ámbito de aplicación: los datos son compartidos por todos los usuarios durante toda la vida de la aplicación (la lista de médicos, por ejemplo);
  • ámbito de solicitud: los datos existen solo durante una solicitud (el modelo de una plantilla, el usuario conectado tal como se identifica en esa solicitud);
  • ámbito de sesión: los datos son propios de un usuario y deben persistir de una solicitud a la siguiente (el idioma seleccionado, un carrito de compras);
  • ámbito de cliente: datos almacenados en el propio navegador, en una cookie.

En [Python], estos ámbitos adoptan una naturaleza distinta de la que conocen quienes siguieron el curso de [Symfony], porque la aplicación permanece en memoria de una solicitud a la siguiente (ejemplo 01). Los datos almacenados en una variable de módulo (ejemplos 06, 20 y 21) tienen naturalmente ámbito de aplicación: es cómodo y muy rápido. Pero este ámbito tiene dos limitaciones. En primer lugar, dura solo lo que dura el proceso: un reinicio del servidor lo borra. En segundo lugar, es propio de cada proceso: en producción, normalmente se lanzan varios procesos de la aplicación (varios “workers” de [gunicorn], por ejemplo), o incluso varios servidores detrás de un balanceador de carga, y cada uno tendría su propia copia de los datos. Por lo tanto, los datos que realmente deben compartirse y persistir en el tiempo se almacenan en una base de datos o en una caché compartida ([Redis], [Memcached], que [Django] sabe utilizar mediante su configuración [CACHES]). A cambio de la velocidad, compartir exige una disciplina estricta: un proceso atiende varias solicitudes a la vez, en varios hilos, y los datos compartidos modificados por un proceso son visibles para todos; deben protegerse mediante un bloqueo (ejemplo 20), y nunca deben almacenarse allí datos que pertenezcan a un usuario específico.

En [Django], cada ámbito tiene su propio contenedor:

Ámbito
Contenedor
Duración
aplicación
una variable de módulo (un solo proceso), la caché de [Django] (configuración [CACHES]) o la base de datos
la del proceso; la duración elegida para la caché; sin límite para la base de datos
solicitud
el objeto [HttpRequest], al que un middleware puede agregar atributos (ejemplo 12); las variables locales de la vista
el procesamiento de una solicitud
sesión
la sesión ([request.session], aplicación [django.contrib.sessions]), mantenida por el servidor y recuperada mediante una cookie
dos semanas de manera predeterminada (configuración [SESSION_COOKIE_AGE])
cliente
una cookie ([set_cookie], ejemplo 22), ya sea en texto plano o firmada ([set_signed_cookie])
la duración especificada de la cookie

La sesión de [Django] es, por defecto, una sesión del lado del servidor, como las de [Java] ([JSESSIONID]) o [PHP] ([PHPSESSID]): sus datos se almacenan en el servidor, y el navegador solo conserva el identificador, un número aleatorio imposible de adivinar, en la cookie [sessionid]. La configuración [SESSION_ENGINE] determina dónde se almacenan los datos: en la base de datos (la opción predeterminada, en una tabla llamada [django_session]), en la caché, en archivos (la opción utilizada en nuestro ejemplo) o incluso, como en el caso de [Flask], íntegramente en una cookie firmada en el dispositivo del cliente.

6.1. Ejemplo 23: ámbitos

23-scopes/
├── config/
│   ├── settings.py
│   └── ...
├── scopes/
│   ├── __init__.py
│   ├── counters.py
│   ├── middleware.py
│   └── views.py
├── templates/
│   └── scopes/
│       └── scopes.html
├── var/
│   └── sessions/
└── manage.py

6.1.1. La configuración: config/settings.py

# config/settings.py: la configuración del ejemplo 23

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-1zxb1%#mksmtg+m&rsp_e6&i7@6sbtm_i=lqjq_+rg#-=i5r-p"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    # las SESIONES
    "django.contrib.sessions",
    "scopes",
]

MIDDLEWARE = [
    # el middleware de sesiones: encuentra la sesión del navegador (gracias a la
    # cookie sessionid) al inicio de la solicitud y la guarda al final de la solicitud
    "django.contrib.sessions.middleware.SessionMiddleware",
    # el ámbito de la SOLICITUD (REQUEST): un objeto por solicitud (véase scopes/middleware.py)
    "scopes.middleware.RequestInfoMiddleware",
]

# los datos de la sesión se almacenan en el servidor, en ARCHIVOS (uno por
# sesión), en la carpeta var/sessions del ejemplo, creada si no existe
SESSION_ENGINE = "django.contrib.sessions.backends.file"
SESSION_FILE_PATH = BASE_DIR / "var" / "sessions"
SESSION_FILE_PATH.mkdir(parents=True, exist_ok=True)

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
        "OPTIONS": {
            "context_processors": [
                # la variable request y, por lo tanto, request.session y request.info
                "django.template.context_processors.request",
            ],
        },
    },
]

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR.parent / "common" / "static",
]
  • Línea 17: gestión de sesiones;
  • líneas 21–27: dos componentes de middleware. [SessionMiddleware] recupera la sesión del navegador al inicio de la solicitud mediante la cookie [sessionid] y la almacena en [request.session]; al final de la solicitud, guarda la sesión si se modificó y envía la cookie. Solo lee realmente los datos en el primer acceso a [request.session]: una vista que no la usa no genera ningún costo. El segundo middleware es el nuestro (véase más adelante);
  • líneas 31–33: los datos de sesión se almacenan en archivos (uno por sesión) en la carpeta [var/sessions] del ejemplo, que podemos examinar. La línea 33 crea esta carpeta si no existe ([parents=True]: incluidas las carpetas padre; [exist_ok=True]: sin error si ya existe): el archivo de configuración es [Python], que puede ejecutar código. La opción predeterminada, la base de datos, requeriría una base de datos (capítulo siguiente);
  • línea 42: el procesador de contexto [request]: las plantillas usarán [request.session] y [request.info].

6.1.2. Los objetos: scopes/counters.py y scopes/middleware.py

# scopes/counters.py: ámbito de APLICACIÓN (APPLICATION), contadores compartidos por todas las
# solicitudes de todos los usuarios

import threading
from collections import Counter

# un Counter: un diccionario {clave: número}, cuyas claves ausentes valen 0. Se
# crea cuando se carga el módulo y vive tanto como el proceso del servidor
_counters = Counter()
_lock = threading.Lock()


# un número más bajo la clave [key]; += no es una operación atómica: dos
# solicitudes simultáneas podrían leer el mismo valor. El candado lo evita
def next_value(key: str) -> int:
    with _lock:
        _counters[key] += 1
        return _counters[key]
  • Línea 5: la clase [Counter] del módulo [collections]: un diccionario cuyos valores son números y cuyas claves ausentes valen 0;
  • Líneas 9–10: los contadores y su bloqueo, creados cuando se carga el módulo; existen mientras el proceso del servidor esté en ejecución. Este es el ámbito de aplicación;
  • líneas 15–18: un número más bajo una clave. La operación [+=] no es atómica: lee el valor, lo incrementa y luego lo escribe, y dos solicitudes simultáneas podrían leer el mismo valor, con lo que se perdería una visita. El bloqueo (ejemplo 20) lo evita.
# scopes/middleware.py: ámbito de SOLICITUD (REQUEST), la información de una solicitud

from dataclasses import dataclass

from django.utils import timezone

from . import counters


@dataclass(frozen=True)
class RequestInfo:
    number: int
    start: str


# el middleware crea UN objeto RequestInfo por solicitud y lo almacena en la solicitud:
# la vista y la plantilla lo encuentran mediante request.info. Desaparece con ella
class RequestInfoMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        request.info = RequestInfo(
            # un número por OBJETO creado, tomado de un contador común a todas las solicitudes
            number=counters.next_value("instances"),
            # la hora, con sus milisegundos
            start=timezone.localtime().strftime("%H:%M:%S.%f")[:-3])
        return self.get_response(request)
  • líneas 10–13: información del ámbito de solicitud: un número y la hora de la solicitud;
  • líneas 18–28: el middleware crea un objeto [RequestInfo] por cada solicitud y lo almacena en la solicitud (ejemplo 12). El número se toma de un contador compartido por todas las solicitudes (el módulo anterior, con otra clave); por lo tanto, cada objeto tiene un número distinto. La hora se escribe con milisegundos: [%f] representa los microsegundos (seis dígitos), de los cuales [[:-3]] elimina los últimos tres (un segmento de cadena: todos los caracteres excepto los tres últimos). El objeto se elimina junto con la solicitud.

[Django] no tiene contenedor de servicios y, por lo tanto, tampoco “servicio de ámbito de solicitud”: es la propia solicitud la que transporta los objetos de este ámbito. Los lectores del curso de [Symfony] recordarán que ocurría lo contrario: en [PHP], todo servicio tenía ámbito de solicitud y se requería una caché para obtener el ámbito de aplicación.

6.1.3. Cookies firmadas

Una cookie es un dato confiado al cliente, que puede leerlo y modificarlo. Para que una cookie sea confiable, basta con firmarla: su valor viaja en texto plano, pero va seguido de una firma que solo el servidor sabe calcular, porque depende de una clave secreta. Un valor modificado por el cliente ya no tiene la firma correcta y el servidor lo rechaza. [Django] se encarga de esto por nosotros: [response.set_signed_cookie(name, value)] establece una cookie firmada, y [request.get_signed_cookie(name, default=...)] devuelve su valor si la firma es correcta; de lo contrario, devuelve el valor predeterminado. La firma es un HMAC (Hash-based Message Authentication Code): un hash del valor (SHA-256), calculado con la clave secreta de la aplicación ([SECRET_KEY], ejemplo 01), y un “salt” propio del nombre de la cookie. [Django] añade la fecha de la firma, lo que permite rechazar una cookie caducada ([get_signed_cookie(..., max_age=3600)]). La verificación compara las firmas en un tiempo que no depende del número de caracteres idénticos: una comparación estándar se detendría en el primer carácter distinto y un atacante podría, midiendo el tiempo de respuesta, adivinar la firma carácter por carácter. El módulo [django.core.signing] ofrece las mismas funciones para firmar cualquier dato ([signing.dumps], [signing.loads]): es este módulo el que firma los mensajes flash del ejemplo 20.

Este es el principio del token JWT, que el próximo capítulo usará para la autenticación.

6.1.4. La vista: scopes/views.py

# scopes/views.py: los cuatro ámbitos de datos

from django.shortcuts import render
from django.views.decorators.http import require_GET

from . import counters


@require_GET
def scopes(request):
    # APLICACIÓN: el contador compartido
    total = counters.next_value("visits")
    # SESIÓN: datos propios de ESTE navegador, conservados por el SERVIDOR (un
    # archivo de var/sessions), encontrados gracias a la cookie de sesión; la sesión
    # se usa como un diccionario
    request.session["visits"] = request.session.get("visits", 0) + 1
    # CLIENTE: datos conservados por el NAVEGADOR en cookies, devueltas al
    # servidor con cada solicitud; una en texto plano, la otra firmada
    my_visits = int(request.COOKIES.get("myVisits", 0)) + 1
    # get_signed_cookie: el valor si la firma es la correcta; default en caso contrario
    my_visits_signed = int(request.get_signed_cookie("myVisitsSigned", default=0)) + 1
    response = render(request, "scopes/scopes.html", {
        "total": total,
        "instance": request.info.number,
        "session_visits": request.session["visits"],
        "my_visits": my_visits,
        "my_visits_signed": my_visits_signed,
    })
    response.set_cookie("myVisits", str(my_visits))
    # set_signed_cookie: el valor, seguido de una firma calculada con SECRET_KEY
    response.set_signed_cookie("myVisitsSigned", str(my_visits_signed))
    return response
  • línea 12: el ámbito de aplicación;
  • línea 16: el ámbito de sesión. [request.session] se usa como un diccionario: [get(key, default)] lee un valor y la asignación lo escribe. [Django] guarda la sesión al final de la solicitud. Los valores deben poder convertirse a JSON (cadenas, números, listas, diccionarios): así es como se almacenan;
  • líneas 19–21: el ámbito de cliente, con dos cookies. [request.COOKIES] es el diccionario de cookies enviadas por el navegador. Sus valores son cadenas proporcionadas por el navegador y, por lo tanto, pueden faltar o ser inválidas: [int] las convierte (una cookie llamada [myVisits=abc] lanzaría aquí una excepción [ValueError] y produciría un error 500; una aplicación real verificaría el valor; véase el ejemplo 07). El valor de la cookie firmada solo se acepta si su firma es correcta;
  • líneas 22–28: el contexto de la plantilla;
  • líneas 29–31: para establecer una cookie se necesita el objeto de respuesta: [render] lo construye (ejemplo 13), y luego [set_cookie] y [set_signed_cookie] le añaden las cookies. Sin tiempo de expiración ([max_age]), una cookie dura hasta que se cierra el navegador (es una cookie “de sesión”, según la definición de los navegadores).

6.1.5. La plantilla: templates/scopes/scopes.html

<!doctype html>
{% load static %}
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Scopes</title>
  <link rel="stylesheet" href="{% static 'bootstrap/css/bootstrap.min.css' %}">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
    {# request.info: el objeto almacenado en la solicitud por el middleware; es el mismo que el de la vista #}
    <ul>
      <li>application: {{ total }} visit(s) to the site, all browsers combined</li>
      <li>request: object no. {{ instance }} (no. {{ request.info.number }} in the template),
        request received at {{ request.info.start }}</li>
      {# request.session: la sesión, también accesible en las plantillas #}
      <li>session: {{ session_visits }} visit(s) from this browser ({{ request.session.visits }} in the template)</li>
      <li>client: {{ my_visits }} visit(s) from this browser (plain cookie),
        {{ my_visits_signed }} (signed cookie)</li>
    </ul>
  </div>
</body>
</html>
  • línea 16: [request.info], el objeto almacenado en la solicitud por el middleware: es el mismo objeto [RequestInfo] que el de la vista; la plantilla muestra su número, que debe ser el recibido de la vista;
  • línea 19: la sesión también es accesible en las plantillas, mediante [request.session].

6.1.6. Ejecución

Después de tres visitas en un navegador:

Image

El número del objeto de solicitud es mayor que el número de visitas: en la primera visita, el navegador también solicitó el ícono del sitio ([/favicon.ico]), que no existe. Esta solicitud, que dio como resultado un error 404, pasó por el middleware y, por lo tanto, tuvo su propio objeto [RequestInfo].

Sigamos las solicitudes con [curl], que actúa como un primer navegador almacenando sus cookies en el archivo [a.txt] (el servidor acaba de iniciarse):

curl -i -c a.txt -b a.txt http://localhost:8000/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Vary: Cookie
Set-Cookie: myVisits=1; Path=/
Set-Cookie: myVisitsSigned=1:1xAspT:iu2OlkhoUcBt0QBGkt_Gkjm2PoYfUeS6WSsO5KEHt0k; Path=/
Set-Cookie: sessionid=ij72qd9hyuhwoqlplawuxycwg6ggccsq; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
      <li>application: 1 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 1 (no. 1 in the template),
        request received at 19:38:23.123</li>
      <li>session: 1 visit(s) from this browser (1 in the template)</li>
      <li>client: 1 visit(s) from this browser (plain cookie),
        1 (signed cookie)</li>
...

La respuesta establece tres cookies. La primera, [myVisits], contiene el valor en texto plano. La segunda, [myVisitsSigned], contiene el mismo valor, seguido de dos puntos, la fecha de la firma (en base 62) y la firma misma. La tercera, [sessionid], es el identificador de sesión, válido por dos semanas ([Max-Age=1209600] segundos), [HttpOnly], y [SameSite=Lax] (ejemplo 20). Los datos de la sesión se almacenan en un archivo del servidor, [var/sessions/sessionidij72qd9hyuhwoqlplawuxycwg6ggccsq], cuyo nombre se deriva del identificador:

eyJ2aXNpdHMiOjF9:1xAspT:mYytMt_81vJlDI_gaKudIqPgoxAvrGUZbnk578MZr3I

Aquí reconocemos el formato de los datos firmados de [Django]: los datos, la fecha y la firma. Los datos son JSON codificado en Base64: [eyJ2aXNpdHMiOjF9] se decodifica como [{"visits":1}]. El servidor incluso firma sus propios archivos de sesión: un archivo modificado por un tercero sería rechazado. Una segunda visita, con las mismas cookies:

curl -i -c a.txt -b a.txt http://localhost:8000/
...
Set-Cookie: myVisits=2; Path=/
Set-Cookie: myVisitsSigned=2:1xAspT:E9lE-GK-yE7WfT5Ak58h2tufzXQ5vLWcWz5UBAS-dLA; Path=/
Set-Cookie: sessionid=ij72qd9hyuhwoqlplawuxycwg6ggccsq; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
      <li>application: 2 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 2 (no. 2 in the template),
        request received at 19:38:23.150</li>
      <li>session: 2 visit(s) from this browser (2 in the template)</li>
      <li>client: 2 visit(s) from this browser (plain cookie),
        2 (signed cookie)</li>
...

La sesión es la misma (mismo identificador); su cookie se envía de nuevo porque la sesión se modificó, lo que extiende su duración. Un segundo “navegador”, con su propio archivo de cookies, inicialmente vacío:

curl -c b.txt -b b.txt http://localhost:8000/
1
2
3
4
5
6
      <li>application: 3 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 3 (no. 3 in the template),
        request received at 19:38:23.167</li>
      <li>session: 1 visit(s) from this browser (1 in the template)</li>
      <li>client: 1 visit(s) from this browser (plain cookie),
        1 (signed cookie)</li>

El contador de la aplicación ha continuado; la sesión y las cookies del segundo navegador comienzan de nuevo en 1. Cada solicitud tuvo su propio objeto [RequestInfo], y en cada una, la vista y la plantilla fueron las mismas. Por último, un usuario malintencionado falsifica sus propias cookies: 1000 visitas en [myVisits], 999 en [myVisitsSigned] (con una firma inventada) y un identificador de sesión de su propia invención:

curl -i -b "myVisits=1000;myVisitsSigned=999:abc;sessionid=abc" http://localhost:8000/
1
2
3
4
5
6
7
8
9
...
Set-Cookie: myVisits=1001; Path=/
Set-Cookie: myVisitsSigned=1:1xAspT:iu2OlkhoUcBt0QBGkt_Gkjm2PoYfUeS6WSsO5KEHt0k; Path=/
Set-Cookie: sessionid=l4316xnwacgz81f7yemjar89cfe05jm3; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
      <li>session: 1 visit(s) from this browser (1 in the template)</li>
      <li>client: 1001 visit(s) from this browser (plain cookie),
        1 (signed cookie)</li>
...

La cookie en texto plano se aceptó tal cual: 1001 visitas. La cookie [myVisitsSigned], en cambio, no tenía la firma correcta: se ignoró, como si faltara. Copiar la firma de otro valor (la de [1], por ejemplo, junto al valor [999]) tampoco funciona: la firma depende del valor. En cuanto al identificador de sesión inventado, no corresponde a ninguna sesión existente: [Django] lo ignora y crea una nueva sesión con un nuevo identificador que él mismo elige. Por lo tanto, el usuario no puede seleccionar la sesión de otro usuario.

Recordemos la regla: los datos provenientes del cliente solo son confiables si están protegidos por el servidor (firmados, como aquí o como con el token del capítulo sobre autenticación, o cifrados); los datos que no tienen nada que ocultar y cuyo valor verifica el servidor (el idioma del ejemplo 22) pueden permanecer en texto plano. Una firma garantiza que un valor no ha sido alterado, pero no lo oculta: nunca se debe confiar un secreto al cliente, aunque esté firmado.