Blog

Websocket in Python: il tempo reale in Django e Flask

· Andrij Tkachenko · 9 min di lettura

Una linea avvolta come un serpente va da una fila di server worker a un cloud, che tiene linee aperte verso quattro finestre del browser

Python può far girare un server websocket in circa quindici righe, come processo asyncio che tiene aperta ogni connessione. Django e Flask su WSGI non possono tenere da soli quelle connessioni, quindi o fai girare un server sempre attivo accanto alla tua app, o lasci che le tenga un servizio gestito mentre le tue view inviano ogni evento con una breve richiesta HTTP.

Questo articolo mostra il server in Python puro, perché un worker WSGI non può fare lo stesso, cosa richiedono Django e Flask per farlo sui tuoi server, e la strada del servizio gestito, con codice funzionante per entrambi.

Un server websocket in Python puro

Un websocket è una connessione bidirezionale tra un browser e un server che resta aperta, così ciascuna delle due parti può inviare in qualsiasi momento. La libreria websockets ti dà il lato server su asyncio. Questo server passa ogni messaggio che riceve a tutti i collegati:

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 pagina si collega con l’API WebSocket che ogni browser ha:

JavaScript
const socket = new WebSocket( 'ws://localhost:8001' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );

Aprila in due schede, e ognuna stampa ciò che invia l’altra. Quando gira su un indirizzo pubblico, il nostro test WebSocket si collega al server da un browser e spiega qualsiasi codice di chiusura. Se il browser segnala soltanto che la connessione non è riuscita, il nostro articolo sull’errore WebSocket 1006 mostra come trovarne la causa. Se è il tuo codice Python a collegarsi al server di qualcun altro, la stessa libreria ha un client, connect() in websockets.asyncio.client.

Due cose nel server qui sopra decidono tutto ciò che segue. L’handler resta in esecuzione finché la pagina rimane aperta, spesso per ore. E connections vive nella memoria di questo solo processo.

Perché Django e Flask non possono tenerne uno su WSGI

La maggior parte delle app Django e Flask gira su WSGI, lo standard tra i server web Python e le app. È una chiamata di funzione per ogni richiesta: il server chiama la tua app, e la tua app restituisce una risposta. Dopo non ha modo di continuare a parlare con il browser.

Su Gunicorn, un server molto usato per queste app, in pratica si vede così:

  • Un worker sync gestisce una richiesta alla volta. Un websocket tenuto in un worker lo terrebbe occupato finché la pagina resta aperta, quindi con quattro pagine aperte un sito con quattro worker non potrebbe più rispondere a nessun altro.
  • Un worker bloccato su una richiesta viene riavviato. Un worker sync che resta in silenzio oltre il timeout, 30 secondi di default, viene terminato e avviato di nuovo.
  • async def non cambia le cose. La documentazione di Flask è chiara: anche con una view asincrona, ogni richiesta occupa comunque un worker. La documentazione di Django spiega che sotto WSGI una view asincrona gira in un proprio event loop usa e getta, senza i vantaggi di uno stack asincrono.

Cosa serve sui tuoi server

In Django, passare ad ASGI non basta, perché l’handler ASGI incluso in Django accetta solo HTTP. Il progetto Django mantiene un componente aggiuntivo ufficiale per i websocket. Aggiungi asgi.py, scrivi dei consumer per le connessioni accanto alle tue view, fai girare un server ASGI e metti davanti un proxy che gli manda il traffico websocket. Le tue view normali possono restare su WSGI.

In Flask, un’estensione ti dà una route websocket, e ogni connessione aperta occupa un thread o un greenlet di un worker. Con i thread, --threads 100 di Gunicorn significa al massimo 100 pagine aperte per worker, richieste normali comprese. I worker su gevent ne reggono di più, applicando patch alle funzioni bloccanti di Python stesso.

In entrambi i casi, ti segue lo stesso elenco:

  • Condividere ogni evento. Un broadcast() sulle connessioni in memoria raggiunge solo i browser di quel singolo processo. Oltre un processo, ogni evento deve passare per un canale condiviso da tutti, di solito Redis.
  • Sapere chi si sta collegando. Il WebSocket del browser accetta un indirizzo e dei sottoprotocolli, senza alcun modo di impostare un header. Quindi il tuo server legge il cookie di sessione o un token nell’indirizzo, e decide cosa può ascoltare questo utente.
  • Deploy. Un riavvio fa cadere ogni connessione, ogni browser si riconnette nello stesso momento, e una pagina rimasta scollegata perde ciò che è stato inviato nel frattempo, a meno che qualcosa non lo conservi.
  • Proxy. Chiudono le connessioni che sembrano inattive, quindi serve un heartbeat, e ogni proxy lungo il percorso va configurato per lasciar passare i websocket.

L’articolo sui websocket in FastAPI oltre un solo worker ripercorre questo elenco con il codice, e quello sui websocket in Laravel lo affronta dal lato PHP. Niente di tutto questo è esotico, e molti team lo fanno bene. Resta comunque un secondo sistema accanto alla tua app, finché l’app ha funzioni in tempo reale.

Oppure lascia la tua app com’è

Un servizio in tempo reale gestito toglie le connessioni ai tuoi worker. I browser si collegano al servizio. La tua view invia ogni evento con una breve richiesta HTTPS, e il servizio lo consegna a ogni pagina che deve riceverlo. Le richieste brevi sono esattamente ciò che WSGI sa fare bene, quindi Gunicorn, i tuoi worker e il tuo hosting restano come sono.

Configurazione Cosa tiene ogni connessione Cosa aggiungi
Solo WSGI Niente, quindi niente websocket Niente
WSGI con thread o gevent Un thread o greenlet di un worker Un canale condiviso oltre un worker
ASGI Un task su un event loop Un server ASGI, una regola nel proxy, un canale condiviso
Un servizio gestito I server del servizio Una richiesta per ogni evento

Django su WordPlus Cloud

WordPlus Cloud arriva su Django come un unico pacchetto, senza Node da installare:

Shell
pip install 'wordplus-realtime[django]'

Aggiungi "wordplus_realtime.django" a INSTALLED_APPS, imposta WORDPLUS_SITE, WORDPLUS_SECRET e WORDPLUS_LOCAL_KEY nell’ambiente del tuo server, e dichiara le tue stanze una volta sola, ciascuna con una regola su chi può entrare:

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 quel file dal tuo AppConfig.ready(), così le stanze esistono prima della prima richiesta. Una riga in urls.py aggiunge le route che rispondono alle pagine quando chiedono di entrare in una stanza e servono i file dell’SDK per il browser:

Python
path("api/realtime/", include("wordplus_realtime.django.routes")),

L’utente viene dalla sessione, e il controllo CSRF di Django resta attivo per quelle route. {% wordplus_realtime %} nell’head di un template scrive le impostazioni della pagina per il suo utente autenticato, così la pagina si collega senza fare prima nessuna richiesta.

A quel punto qualsiasi view, su qualsiasi worker, invia appena la sua transazione va in commit, così nessuno vede una modifica annullata da un rollback:

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}))

Quella chiamata a emit è una sola richiesta HTTPS, fatta nella view. Una view asincrona fa lo stesso con await realtime.to(…).aemit(…). Per molti eventi insieme, o quando una richiesta non deve aspettarli, inviali da Celery o da un’altra coda di task.

Flask su WordPlus Cloud

In Flask è lo stesso pacchetto, una sola chiamata e lo stesso tipo di regola:

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}

L’utente è current_user di Flask-Login quando la tua app lo usa, altrimenti session["user_id"]. {{ wordplus_realtime() }} nell’head di un template scrive le impostazioni della pagina.

La pagina è la stessa in entrambi

Il tuo JavaScript entra nella stanza così com’è, senza bundler, perché quelle impostazioni indicano il client servito dalle tue route:

JavaScript
import { connect } from '@wordplus/realtime';

const rt = await connect( window.wordplusRealtimeConfig );
rt.join( 'order:1042' ).on( 'updated', ( data ) => showStatus( data.status ) );

Funziona allo stesso modo con un worker o con quaranta. In più:

  • Nulla si perde alla riconnessione. Una stanza conserva i suoi ultimi eventi, così una pagina che torna riceve ciò che si è persa, in ordine.
  • Ogni pagina di un utente. realtime.to_user(42).emit("notice", {"text": "Your order shipped"}) raggiunge ogni scheda e ogni dispositivo che ha aperti, ovunque si trovi nella tua app. Un utente che non ha nulla aperto non riceve nulla, quindi invia un’email per ciò che deve raggiungerlo.
  • Una sola connessione per tutte le schede. Le schede di un browser condividono un’unica connessione, così una persona con tre schede aperte conta una volta sola.
  • Sigillato lungo il tragitto. Ciò che il tuo server invia a una stanza con una regola viaggia cifrato con chiavi che hanno solo il tuo server e i tuoi utenti.
  • Non solo eventi. Chi è online, chiamate che squillano in ogni scheda, chiamate di gruppo e live streaming arrivano sulla stessa connessione, con la schermata di chiamata, la chat e il player pronti all’uso di Better Messages, oppure con la tua interfaccia sulla stessa API.

Quando è meglio un server tutto tuo

Un servizio gestito non va bene per ogni lavoro. Il tuo codice Python riceve ciò che inviano le pagine tramite un webhook, una richiesta HTTP che può arrivare più di una volta, e non tramite un loop attivo su ogni connessione. Un gioco o un sistema di controllo in cui Python deve rispondere a ogni messaggio entro pochi millisecondi va su un proprio server asyncio, come quello all’inizio di questo articolo.

Parti dal tuo framework

La guida per Django e la guida per Flask contengono tutta la configurazione. La demo per Django e la demo per Flask sono un piccolo negozio costruito su ciascuno, dove un ordine passa a spedito in un’altra finestra mentre fai clic.

WordPlus Cloud for Apps ha un prezzo in base alle connessioni simultanee, a partire da 1.000, con fatturazione mensile o annuale, e il nostro articolo sui prezzi dei servizi in tempo reale spiega come funziona il conteggio a connessione. Scopri cosa fa per le app, o i prezzi per le app. La nostra pagina sull’API WebSocket mostra stanze, presenza ed eventi in ogni stack. Domande sulla tua integrazione? Scrivici.