Blog

Websockets in Python: realtime in Django en Flask

· Andrij Tkachenko · 8 min leestijd

Een lijn, opgerold als een slang, loopt van een rij workerservers naar een cloud, die open lijnen houdt naar vier browservensters

In Python draai je een websocketserver in ongeveer vijftien regels, als een asyncio-proces dat elke verbinding openhoudt. Django en Flask op WSGI kunnen die verbindingen zelf niet vasthouden, dus je draait ofwel een langlopende server naast je app, ofwel je laat een gehoste dienst ze vasthouden terwijl je views elk event in één kort HTTP-verzoek versturen.

In dit artikel lees je hoe de kale Python-server eruitziet, waarom een WSGI-worker hetzelfde niet kan, wat Django en Flask elk vragen om het op je eigen servers te doen, en hoe de gehoste weg werkt, met werkende code voor allebei.

Een websocketserver in gewoon Python

Een websocket is een verbinding in twee richtingen tussen een browser en een server die open blijft, zodat beide kanten op elk moment kunnen versturen. De bibliotheek websockets geeft je de serverkant op asyncio. Deze server geeft elk bericht dat hij krijgt door aan iedereen die verbonden is:

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

Een pagina maakt verbinding met de WebSocket API die elke browser heeft:

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

Open dat in twee tabbladen, en elk tabblad print wat het andere verstuurt. Draait het op een openbaar adres, dan maakt onze WebSocket-test er vanuit een browser verbinding mee en legt elke sluitcode uit. Meldt de browser alleen dat de verbinding mislukt is, dan laat ons artikel over WebSocket-fout 1006 zien hoe je de oorzaak vindt. Is het je Python-code die verbinding maakt met de server van iemand anders, dan heeft dezelfde bibliotheek een client: connect() in websockets.asyncio.client.

Twee dingen in de server hierboven bepalen alles wat volgt. De handler blijft draaien zolang de pagina openstaat, vaak urenlang. En connections leeft in het geheugen van dit ene proces.

Waarom Django en Flask er op WSGI geen kunnen vasthouden

De meeste Django- en Flask-apps draaien op WSGI, de standaard tussen Python-webservers en apps. Het is één functieaanroep per verzoek: de server roept je app aan, en je app geeft een antwoord terug. Daarna is er geen manier om met de browser te blijven praten.

Op Gunicorn, een gebruikelijke server voor deze apps, zie je dat in de praktijk:

  • Een sync worker handelt één verzoek tegelijk af. Een websocket erin zou hem bezighouden zolang de pagina openstaat, dus met vier open pagina’s kan een site met vier workers niemand anders meer antwoorden.
  • Een worker die aan één verzoek vastzit, wordt herstart. Een sync worker die langer stil is dan de timeout, standaard 30 seconden, wordt beëindigd en opnieuw gestart.
  • async def verandert dit niet. De Flask-documentatie is daar duidelijk over: ook een async view houdt tijdens een verzoek een hele worker bezet. De Django-documentatie zegt dat een async view onder WSGI in een eigen eenmalige event loop draait, zonder de voordelen van een async stack.

Wat het vraagt op je eigen servers

In Django is overstappen op ASGI alleen niet genoeg, want de ASGI-handler die Django meelevert, neemt alleen HTTP aan. Het Django-project onderhoudt een officiële add-on voor websockets. Je voegt asgi.py toe, schrijft consumers voor verbindingen naast je views, draait een ASGI-server en zet er een proxy voor die het websocketverkeer daarheen stuurt. Je gewone views kunnen op WSGI blijven.

In Flask geeft een extensie je een websocketroute, en elke open verbinding houdt een thread of greenlet van een worker bezet. Met threads betekent --threads 100 van Gunicorn hooguit 100 open pagina’s per worker, gewone verzoeken inbegrepen. Workers op gevent houden er meer vast, door de blokkerende functies van Python zelf te patchen.

In beide gevallen krijg je met dezelfde lijst te maken:

  • Elk event delen. Een broadcast() over verbindingen in het geheugen bereikt alleen de browsers op dat ene proces. Bij meer dan één proces moet elk event door een kanaal dat ze allemaal delen, meestal Redis.
  • Weten wie er verbinding maakt. De WebSocket van de browser neemt een adres en subprotocollen aan, zonder manier om een header mee te geven. Dus leest je server de sessiecookie of een token in het adres uit, en bepaalt hij wat deze gebruiker mag horen.
  • Deploys. Een herstart verbreekt elke verbinding, elke browser maakt tegelijk opnieuw verbinding, en een pagina die even weg was, mist wat er intussen is verstuurd, tenzij iets het bewaart.
  • Proxy’s. Ze sluiten verbindingen die inactief lijken, dus je hebt een heartbeat nodig, en elke proxy onderweg moet zo ingesteld zijn dat hij websockets doorlaat.

FastAPI-websockets met meer dan één worker loopt deze lijst langs met code, en websockets in Laravel komt hem tegen vanaf de PHP-kant. Niets hiervan is exotisch, en genoeg teams doen het goed. Maar het blijft een tweede systeem naast je app, zolang de app live functies heeft.

Of houd je app zoals hij is

Een gehoste realtime dienst haalt de verbindingen weg uit je workers. De browsers maken verbinding met de dienst. Je view verstuurt elk event in één kort HTTPS-verzoek, en de dienst bezorgt het aan elke pagina die het moet krijgen. Korte verzoeken zijn precies waar WSGI goed in is, dus Gunicorn, je workers en je host blijven zoals ze zijn.

Opzet Wat houdt elke verbinding vast Wat je toevoegt
Alleen WSGI Niets, dus geen websockets Niets
WSGI met threads of gevent Een thread of greenlet van een worker Een gedeeld kanaal bij meer workers
ASGI Een taak op een event loop Een ASGI-server, een proxyregel, een gedeeld kanaal
Een gehoste dienst De servers van de dienst Eén verzoek per event

Django op WordPlus Cloud

WordPlus Cloud komt naar Django als één package, en Node hoef je niet te installeren:

Shell
pip install 'wordplus-realtime[django]'

Voeg "wordplus_realtime.django" toe aan INSTALLED_APPS, zet WORDPLUS_SITE, WORDPLUS_SECRET en WORDPLUS_LOCAL_KEY in de omgeving van je server, en leg je ruimtes één keer vast, elk met een regel voor wie erin mag:

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)

Importeer dat bestand vanuit je AppConfig.ready(), zodat de ruimtes bestaan voor het eerste verzoek. Eén regel in urls.py voegt de routes toe die de pagina’s beantwoorden als ze vragen om aan een ruimte deel te nemen, en die de browserbestanden van de SDK serveren:

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

De gebruiker komt uit de sessie, en de CSRF-controle van Django blijft aan voor die routes. {% wordplus_realtime %} in de head van een template schrijft de instellingen van de pagina voor de ingelogde gebruiker, zodat de pagina verbinding maakt zonder eerst een verzoek te doen.

Elke view, op elke worker, verstuurt daarna zodra zijn transactie is gecommit, zodat niemand een wijziging ziet die is teruggedraaid:

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

Die emit is één HTTPS-verzoek, gedaan in de view. Een async view doet hetzelfde met await realtime.to(…).aemit(…). Voor veel events tegelijk, of waar een verzoek er niet op moet wachten, verstuur je ze vanuit Celery of een andere taakwachtrij.

Flask op WordPlus Cloud

In Flask is het hetzelfde package, één aanroep en hetzelfde soort regel:

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}

De gebruiker is current_user uit Flask-Login als je app dat heeft, anders session["user_id"]. {{ wordplus_realtime() }} in de head van een template schrijft de instellingen van de pagina.

De pagina is in beide hetzelfde

Je JavaScript neemt deel aan de ruimte zoals het is, zonder bundler, omdat die instellingen de client noemen die je routes serveren:

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

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

Dat werkt hetzelfde met één worker of met veertig. En daarnaast:

  • Niets kwijt bij opnieuw verbinden. Een ruimte bewaart de laatste events, dus een pagina die terugkomt, krijgt wat ze gemist heeft, in de juiste volgorde.
  • Elke pagina van één gebruiker. realtime.to_user(42).emit("notice", {"text": "Your order shipped"}) bereikt elk tabblad en apparaat dat hij open heeft, waar hij ook is in je app. Een gebruiker met niets open krijgt niets, dus stuur een e-mail voor wat hem moet bereiken.
  • Eén verbinding voor alle tabbladen. De tabbladen van een browser delen één verbinding, zodat iemand met drie tabbladen open maar één keer telt.
  • Verzegeld onderweg. Wat je server verstuurt naar een ruimte met een regel, reist versleuteld met sleutels die alleen je server en je gebruikers hebben.
  • Meer dan events. Wie er online is, gesprekken die in elk tabblad overgaan, groepsgesprekken en livestreams lopen over dezelfde verbinding, met een kant-en-klaar belscherm, chat en speler van Better Messages, of je eigen interface op dezelfde API.

Wanneer je eigen server beter past

Een gehoste dienst past niet bij elke klus. Je Python-code hoort wat pagina’s versturen via een webhook, een HTTP-verzoek dat meer dan eens kan aankomen, en niet via een live loop met elke verbinding. Een game of een regelsysteem waarin Python elk bericht binnen milliseconden moet beantwoorden, hoort op een eigen asyncio-server, zoals die bovenaan dit artikel.

Begin met je framework

De Django-handleiding en de Flask-handleiding beschrijven de hele installatie. De Django-demo en de Flask-demo zijn een kleine webwinkel die op elk van beide is gebouwd, waar een bestelling in een ander venster de status verzonden krijgt terwijl je klikt.

WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, en ons artikel over prijzen voor realtime legt uit hoe tellen per verbinding werkt. Bekijk wat het doet voor apps, of de prijzen voor apps. Onze pagina over de WebSocket-API toont ruimtes, aanwezigheid en events in elke stack. Vragen over je integratie? Schrijf ons.