Websockets en Python: tiempo real en Django y Flask

Python puede ejecutar un servidor websocket en unas quince líneas, como un proceso de asyncio que mantiene abierta cada conexión. Django y Flask en WSGI no pueden mantener esas conexiones por sí mismos, así que o ejecutas un servidor de larga duración junto a tu app, o dejas que un servicio alojado las mantenga mientras tus vistas envían cada evento en una petición HTTP corta.
Este artículo muestra el servidor en Python puro, por qué un worker de WSGI no puede hacer lo mismo, qué exigen Django y Flask para hacerlo en tus propios servidores y la vía alojada, con código que funciona para los dos.
Un servidor websocket en Python puro
Un websocket es una conexión en los dos sentidos entre un navegador y un servidor que se queda abierta, así que cualquiera de los dos lados puede enviar en cualquier momento. La biblioteca websockets te da el lado del servidor sobre asyncio. Este pasa cada mensaje que recibe a todos los conectados:
import asyncio
from websockets.asyncio.server import broadcast, serve
connections = set()
async def handler(websocket):
connections.add(websocket)
try:
async for message in websocket:
broadcast(connections, message)
finally:
connections.discard(websocket)
async def main():
server = await serve(handler, "", 8001)
await server.serve_forever()
asyncio.run(main())Una página se conecta con la API WebSocket que tienen todos los navegadores:
const socket = new WebSocket( 'ws://localhost:8001' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Ábrela en dos pestañas y cada una imprime lo que envía la otra. Cuando funcione en una dirección pública, nuestro test de WebSocket se conecta a él desde un navegador y explica cualquier código de cierre. Si el navegador solo indica que la conexión falló, nuestro artículo sobre el error 1006 de WebSocket explica cómo encontrar la causa. Si es tu código Python el que se conecta al servidor de otra persona, la misma biblioteca tiene un cliente, connect() en websockets.asyncio.client.
Dos cosas del servidor de arriba deciden todo lo que viene después. El handler sigue ejecutándose mientras la página esté abierta, a menudo durante horas. Y connections vive en la memoria de este único proceso.
Por qué Django y Flask no pueden mantener uno en WSGI
La mayoría de las apps de Django y Flask se ejecutan sobre WSGI, el estándar entre los servidores web de Python y las apps. Es una llamada a una función por petición: el servidor llama a tu app y tu app devuelve una respuesta. Después de eso no tiene forma de seguir hablando con el navegador.
En Gunicorn, un servidor habitual para estas apps, eso se nota en la práctica:
- Un worker síncrono atiende una petición cada vez. Un websocket abierto en uno lo tendría ocupado mientras la página siga abierta, así que cuatro páginas abiertas dejarían a un sitio con cuatro workers sin poder responder a nadie más.
- Un worker atascado en una petición se reinicia. Un worker síncrono que pasa en silencio más tiempo que el timeout, 30 segundos por defecto, se mata y se vuelve a arrancar.
async defno cambia esto. La documentación de Flask lo deja claro: cada petición sigue ocupando un worker, incluso en las vistas asíncronas. La documentación de Django explica que, bajo WSGI, una vista asíncrona se ejecuta en su propio event loop de un solo uso, sin las ventajas de un stack asíncrono.
Qué hace falta en tus propios servidores
En Django, pasar a ASGI no basta por sí solo, ya que el handler de ASGI que trae Django solo acepta HTTP. El proyecto Django mantiene un complemento oficial para websockets. Añades asgi.py, escribes consumers para las conexiones junto a tus vistas, ejecutas un servidor ASGI y pones delante un proxy que le envíe el tráfico websocket. Tus vistas normales pueden seguir en WSGI.
En Flask, una extensión te da una ruta websocket, y cada conexión abierta ocupa un thread o un greenlet de un worker. Con threads, --threads 100 de Gunicorn significa como mucho 100 páginas abiertas por worker, peticiones normales incluidas. Los workers con gevent mantienen más, a base de parchear las funciones bloqueantes del propio Python.
En los dos casos, te sigue la misma lista:
- Compartir cada evento. Un
broadcast()sobre conexiones en memoria solo llega a los navegadores de ese único proceso. Con más de un proceso, cada evento tiene que pasar por un canal que compartan todos, normalmente Redis. - Saber quién se conecta. El
WebSocketdel navegador acepta una dirección y subprotocolos, sin forma de poner una cabecera. Por eso tu servidor lee la cookie de sesión o un token en la dirección, y decide qué puede escuchar este usuario. - Deploys. Un reinicio corta todas las conexiones, todos los navegadores se reconectan a la vez y una página que estaba desconectada se pierde lo que se envió mientras tanto, a menos que algo lo guarde.
- Proxies. Cierran las conexiones que parecen inactivas, así que necesitas un heartbeat, y cada proxy del camino tiene que estar configurado para dejar pasar los websockets.
Websockets en FastAPI con más de un worker recorre esta lista con código, y websockets en Laravel se encuentra con ella desde el lado de PHP. Nada de esto es exótico, y muchos equipos lo hacen bien. Aun así, es un segundo sistema que hay que mantener junto a tu app mientras tenga funciones en directo.
O deja tu app como está
Un servicio de tiempo real alojado saca las conexiones de tus workers. Los navegadores se conectan al servicio. Tu vista envía cada evento en una petición HTTPS corta, y el servicio lo entrega a cada página que deba recibirlo. Las peticiones cortas son justo aquello en lo que WSGI destaca, así que Gunicorn, tus workers y tu hosting se quedan como están.
| Configuración | Qué mantiene cada conexión | Qué añades |
|---|---|---|
| Solo WSGI | Nada, así que no hay websockets | Nada |
| WSGI con threads o gevent | Un thread o greenlet de un worker | Un canal compartido si hay más de un worker |
| ASGI | Una tarea en un event loop | Un servidor ASGI, una regla de proxy, un canal compartido |
| Un servicio alojado | Los servidores del servicio | Una petición por cada evento |
Django en WordPlus Cloud
WordPlus Cloud llega a Django como un solo paquete, sin Node que instalar:
pip install 'wordplus-realtime[django]'Añade "wordplus_realtime.django" a INSTALLED_APPS, define WORDPLUS_SITE, WORDPLUS_SECRET y WORDPLUS_LOCAL_KEY en el entorno de tu servidor y declara tus salas una sola vez, cada una con una regla para quién puede unirse:
from wordplus_realtime.django import realtime
from .models import Order
# The room of an order, order:1042: its customer may join, and the last 20 updates are kept.
def may_follow_order(user, p):
return user is not None and Order.objects.filter(pk=p["id"], customer_id=user).exists()
realtime.room("order:{id}", may_follow_order, history=20)Importa ese archivo desde tu AppConfig.ready(), para que las salas existan antes de la primera petición. Una línea en urls.py añade las rutas que responden a las páginas cuando piden unirse a una sala y sirven los archivos del SDK para el navegador:
path("api/realtime/", include("wordplus_realtime.django.routes")),El usuario sale de la sesión, y la comprobación CSRF de Django sigue activa en esas rutas. {% wordplus_realtime %} en el head de una plantilla escribe la configuración de la página para el usuario que ha iniciado sesión, así que la página se conecta sin ninguna petición previa.
Después, cualquier vista, en cualquier worker, envía una vez confirmada su transacción, para que nadie vea un cambio que se ha revertido:
from django.db import transaction
order.status = "shipped"
order.save()
transaction.on_commit(lambda: realtime.to(f"order:{order.pk}").emit("updated", {"status": order.status}))Ese emit es una petición HTTPS, hecha en la vista. Una vista asíncrona hace lo mismo con await realtime.to(…).aemit(…). Para muchos eventos a la vez, o cuando una petición no debería esperarlos, envíalos desde Celery u otra cola de tareas.
Flask en WordPlus Cloud
En Flask es el mismo paquete, una llamada y el mismo tipo de regla:
pip install 'wordplus-realtime[flask]'from flask import Flask
import wordplus_realtime.flask
from wordplus_realtime import Realtime
realtime = Realtime.from_environment() # WORDPLUS_SITE, WORDPLUS_SECRET, WORDPLUS_LOCAL_KEY
# The room of an order, order:1042: its customer may join, and the last 20 updates are kept.
realtime.room("order:{id}", lambda user, p: user is not None and owner_of(p["id"]) == user, history=20)
app = Flask(__name__)
wordplus_realtime.flask.init_app(app, realtime)
@app.post("/orders/<int:pk>/ship")
def ship(pk):
order = mark_shipped(pk)
realtime.to(f"order:{pk}").emit("updated", {"status": order.status})
return {"ok": True}El usuario es current_user de Flask-Login si tu app lo tiene, y si no, session["user_id"]. {{ wordplus_realtime() }} en el head de una plantilla escribe la configuración de la página.
La página es la misma en los dos
Tu JavaScript se une a la sala tal cual, sin bundler, porque esa configuración indica el cliente que sirven tus rutas:
import { connect } from '@wordplus/realtime';
const rt = await connect( window.wordplusRealtimeConfig );
rt.join( 'order:1042' ).on( 'updated', ( data ) => showStatus( data.status ) );Eso funciona igual con un worker que con cuarenta. Más allá de eso:
- Nada se pierde al reconectar. Una sala guarda sus últimos eventos, así que una página que vuelve recibe lo que se perdió, en orden.
- Todas las páginas de un usuario.
realtime.to_user(42).emit("notice", {"text": "Your order shipped"})llega a todas las pestañas y dispositivos que tenga abiertos, esté donde esté en tu app. Un usuario sin nada abierto no recibe nada, así que envía un correo para lo que tenga que llegarle sí o sí. - Una conexión para todas las pestañas. Las pestañas de un navegador comparten una conexión, así que una persona con tres pestañas abiertas cuenta una sola vez.
- Sellado en tránsito. Lo que tu servidor envía a una sala con regla viaja cifrado con claves que solo tienen tu servidor y tus usuarios.
- Más que eventos. Quién está en línea, llamadas que suenan en todas las pestañas, llamadas en grupo y transmisiones en directo llegan por la misma conexión, con una pantalla de llamada, un chat y un reproductor listos para usar de Better Messages, o tu propia interfaz sobre la misma API.
Cuándo te conviene más tu propio servidor
Un servicio alojado no sirve para todo. Tu código Python se entera de lo que envían las páginas a través de un webhook, una petición HTTP que puede llegar más de una vez, y no a través de un bucle en directo con cada conexión. Un juego o un sistema de control en el que Python tenga que responder a cada mensaje en milisegundos debe ir en su propio servidor asyncio, como el del principio de este artículo.
Empieza por tu framework
La guía de Django y la guía de Flask tienen toda la configuración. La demo de Django y la demo de Flask son una pequeña tienda construida sobre cada uno, en la que un pedido pasa a enviado en otra ventana en cuanto haces clic.
WordPlus Cloud for Apps tiene un precio según las conexiones simultáneas, a partir de 1.000, con facturación mensual o anual, y nuestro artículo sobre los precios de tiempo real explica cómo funciona contar por conexión. Descubre lo que hace para apps, o consulta los precios para apps. Nuestra página de la API de WebSocket muestra salas, presencia y eventos en cada stack. ¿Preguntas sobre tu integración? Escríbenos.