Blog

Websockets en Python: tiempo real en Django y Flask

· Andrij Tkachenko · 9 min de lectura

Una línea enroscada como una serpiente va desde una fila de servidores worker hasta una nube, que mantiene líneas abiertas con cuatro ventanas de navegador

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:

Python
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:

JavaScript
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 def no 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 WebSocket del 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:

Shell
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:

shop/realtime.py
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:

Python
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:

Python
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:

Shell
pip install 'wordplus-realtime[flask]'
Python
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:

JavaScript
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.