Blog

Des websockets en Python : le temps réel dans Django et Flask

· Andrij Tkachenko · 9 min de lecture

Une ligne enroulée comme un serpent part d’une rangée de serveurs de workers vers un nuage, qui garde des lignes ouvertes avec quatre fenêtres de navigateur

Python peut faire tourner un serveur websocket en une quinzaine de lignes, sous la forme d’un processus asyncio qui garde chaque connexion ouverte. Django et Flask sur WSGI ne peuvent pas tenir ces connexions eux-mêmes : soit vous faites tourner un serveur en continu à côté de votre application, soit un service hébergé les tient pendant que vos vues envoient chaque événement par une seule courte requête HTTP.

Cet article montre le serveur en Python pur, explique pourquoi un worker WSGI ne peut pas en faire autant et ce qu’il faut à Django et à Flask pour y parvenir sur vos propres serveurs, puis présente la voie hébergée, avec du code qui fonctionne pour les deux.

Un serveur websocket en Python pur

Un websocket est une connexion bidirectionnelle entre un navigateur et un serveur qui reste ouverte, si bien que chaque côté peut envoyer à tout moment. La bibliothèque websockets vous donne le côté serveur sur asyncio. Le serveur que voici transmet chaque message reçu à tous ceux qui sont connectés :

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

Une page se connecte avec l’API WebSocket que possède chaque navigateur :

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

Ouvrez cela dans deux onglets, et chacun affiche ce que l’autre envoie. Une fois qu’il tourne sur une adresse publique, notre test WebSocket s’y connecte depuis un navigateur et explique tout code de fermeture. Si le navigateur indique seulement que la connexion a échoué, notre article sur l’erreur WebSocket 1006 montre comment en trouver la cause. Si c’est votre code Python qui se connecte au serveur de quelqu’un d’autre, la même bibliothèque a un client, connect() dans websockets.asyncio.client.

Dans le serveur ci-dessus, deux choses décident de tout ce qui suit. Le handler continue de tourner tant que la page reste ouverte, souvent pendant des heures. Et connections vit dans la mémoire de ce seul processus.

Pourquoi Django et Flask ne peuvent pas en tenir un sur WSGI

La plupart des applications Django et Flask tournent sur WSGI, le standard entre les serveurs web Python et les applications. C’est un appel de fonction par requête : le serveur appelle votre application, et votre application renvoie une réponse. Rien ne lui permet de continuer à parler au navigateur après cela.

Sur Gunicorn, un serveur courant pour ces applications, cela se voit en pratique :

  • Un worker synchrone traite une requête à la fois. Un websocket tenu par l’un d’eux l’occuperait tant que la page reste ouverte, si bien que quatre pages ouvertes empêcheraient un site à quatre workers de répondre à qui que ce soit d’autre.
  • Un worker bloqué sur une requête est redémarré. Un worker synchrone silencieux au-delà du timeout, 30 secondes par défaut, est tué puis relancé.
  • async def n’y change rien. La documentation de Flask le dit clairement : même avec une vue asynchrone, chaque requête continue d’occuper un worker. La documentation de Django explique que, sous WSGI, une vue asynchrone s’exécute dans sa propre boucle d’événements à usage unique, sans les avantages d’une pile asynchrone.

Ce qu’il faut sur vos propres serveurs

Dans Django, passer à ASGI ne suffit pas, car le handler ASGI fourni avec Django ne prend que le HTTP. Le projet Django maintient une extension officielle pour les websockets. Vous ajoutez asgi.py, vous écrivez des consumers pour les connexions à côté de vos vues, vous faites tourner un serveur ASGI, et vous placez devant lui un proxy qui lui envoie le trafic websocket. Vos vues ordinaires peuvent rester sur WSGI.

Dans Flask, une extension vous donne une route websocket, et chaque connexion ouverte occupe un thread ou un greenlet d’un worker. Avec des threads, le --threads 100 de Gunicorn signifie au plus 100 pages ouvertes par worker, requêtes ordinaires comprises. Des workers sur gevent en tiennent davantage, en patchant les fonctions bloquantes de Python lui-même.

Dans les deux cas, la même liste vous suit :

  • Partager chaque événement. Un broadcast() sur des connexions en mémoire n’atteint que les navigateurs de ce seul processus. Au-delà d’un processus, chaque événement doit passer par un canal que tous partagent, en général Redis.
  • Savoir qui se connecte. Le WebSocket du navigateur prend une adresse et des sous-protocoles, sans aucun moyen de définir un en-tête. Votre serveur lit donc le cookie de session ou un token placé dans l’adresse, et décide de ce que cet utilisateur peut écouter.
  • Déploiements. Un redémarrage coupe toutes les connexions, tous les navigateurs se reconnectent en même temps, et une page qui était absente manque ce qui a été envoyé entre-temps, à moins que quelque chose ne le garde.
  • Proxys. Ils ferment les connexions qui semblent inactives, si bien qu’il vous faut un heartbeat, et chaque proxy sur le chemin doit être configuré pour laisser passer les websockets.

L’article Des websockets FastAPI au-delà d’un seul worker parcourt cette liste avec du code, et celui sur les websockets dans Laravel la retrouve côté PHP. Rien de tout cela n’est exotique, et beaucoup d’équipes le font bien. Mais cela reste un second système à côté de votre application, tant qu’elle a des fonctions en direct.

Ou gardez votre application telle quelle

Un service temps réel hébergé retire les connexions de vos workers. Les navigateurs se connectent au service. Votre vue envoie chaque événement par une seule courte requête HTTPS, et le service le distribue à chaque page qui doit le recevoir. Les requêtes courtes sont justement le point fort de WSGI, si bien que Gunicorn, vos workers et votre hébergement restent tels quels.

Mise en place Ce qui tient chaque connexion Ce que vous ajoutez
WSGI seul Rien, donc pas de websockets Rien
WSGI avec threads ou gevent Un thread ou un greenlet d’un worker Un canal partagé au-delà d’un worker
ASGI Une tâche sur une boucle d’événements Un serveur ASGI, une règle de proxy, un canal partagé
Un service hébergé Les serveurs du service Une requête par événement

Django sur WordPlus Cloud

WordPlus Cloud arrive dans Django sous la forme d’un seul paquet, sans Node à installer :

Shell
pip install 'wordplus-realtime[django]'

Ajoutez "wordplus_realtime.django" à INSTALLED_APPS, définissez WORDPLUS_SITE, WORDPLUS_SECRET et WORDPLUS_LOCAL_KEY dans l’environnement de votre serveur, et déclarez vos salons une fois pour toutes, avec pour chacun une règle qui dit qui peut le rejoindre :

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)

Importez ce fichier depuis votre AppConfig.ready(), pour que les salons existent avant la première requête. Une ligne dans urls.py ajoute les routes qui répondent aux pages quand elles demandent à rejoindre un salon et qui servent les fichiers du SDK destinés au navigateur :

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

L’utilisateur vient de la session, et la vérification CSRF de Django reste active pour ces routes. {% wordplus_realtime %} dans le head d’un template écrit la configuration de la page pour son utilisateur connecté, si bien que la page se connecte sans requête préalable.

N’importe quelle vue, sur n’importe quel worker, envoie ensuite une fois sa transaction validée, si bien que personne ne voit un changement qui a été annulé :

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

Cet emit est une seule requête HTTPS, faite dans la vue. Une vue asynchrone fait de même avec await realtime.to(…).aemit(…). Pour beaucoup d’événements à la fois, ou quand une requête ne doit pas les attendre, envoyez-les depuis Celery ou une autre file de tâches.

Flask sur WordPlus Cloud

Dans Flask, c’est le même paquet, un seul appel et le même genre de règle :

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’utilisateur est le current_user de Flask-Login quand votre application l’utilise, sinon session["user_id"]. {{ wordplus_realtime() }} dans le head d’un template écrit la configuration de la page.

La page est la même dans les deux cas

Votre JavaScript rejoint le salon tel quel, sans bundler, car cette configuration désigne le client que servent vos routes :

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

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

Cela tourne de la même façon avec un worker ou avec quarante. Au-delà :

  • Rien de perdu à la reconnexion. Un salon garde ses derniers événements, si bien qu’une page qui revient reçoit ce qu’elle a manqué, dans l’ordre.
  • Toutes les pages d’un même utilisateur. realtime.to_user(42).emit("notice", {"text": "Your order shipped"}) atteint chaque onglet et chaque appareil qu’il a ouverts, où qu’il soit dans votre application. Un utilisateur qui n’a rien d’ouvert ne reçoit rien, alors envoyez un e-mail pour ce qui doit lui parvenir.
  • Une seule connexion pour tous les onglets. Les onglets d’un même navigateur partagent une seule connexion, si bien qu’une personne avec trois onglets ouverts ne compte qu’une fois.
  • Scellé en chemin. Ce que votre serveur envoie à un salon doté d’une règle voyage chiffré, avec des clés que seuls votre serveur et vos utilisateurs détiennent.
  • Plus que des événements. La liste des personnes en ligne, les appels qui sonnent dans chaque onglet, les appels de groupe et les diffusions en direct passent par la même connexion, avec un écran d’appel, un chat et un lecteur prêts à l’emploi venus de Better Messages, ou votre propre interface sur la même API.

Quand votre propre serveur convient mieux

Un service hébergé ne convient pas à tous les usages. Votre code Python reçoit ce que les pages envoient par un webhook, une requête HTTP qui peut arriver plus d’une fois, et non par une boucle en direct sur chaque connexion. Un jeu ou un système de contrôle où Python doit répondre à chaque message en quelques millisecondes a sa place sur son propre serveur asyncio, comme celui du début de cet article.

Commencez par votre framework

Le guide Django et le guide Flask détaillent toute la mise en place. La démo Django et la démo Flask sont chacune une petite boutique construite sur ce framework, où une commande passe à « expédiée » dans une autre fenêtre au moment où vous cliquez.

WordPlus Cloud for Apps a un prix selon les connexions simultanées, à partir de 1 000, facturé au mois ou à l’année, et notre article sur les tarifs du temps réel explique comment fonctionne le décompte à la connexion. Découvrez ce qu’il apporte aux applications, ou consultez les tarifs pour les applications. Notre page sur l’API WebSocket montre les salles, la présence et les événements dans chaque stack. Des questions sur votre intégration ? Écrivez-nous.