Blog

WebSockets in Python: Echtzeit in Django und Flask

· Andrij Tkachenko · 8 Min. Lesezeit

Eine wie eine Schlange geringelte Linie führt von einer Reihe Worker-Server zu einer Cloud, die offene Linien zu vier Browserfenstern hält

Mit Python läuft ein WebSocket-Server in etwa fünfzehn Zeilen, als asyncio-Prozess, der jede Verbindung offen hält. Django und Flask können diese Verbindungen auf WSGI nicht selbst halten, also betreiben Sie entweder einen dauerhaft laufenden Server neben Ihrer App, oder ein gehosteter Dienst hält sie, während Ihre Views jedes Event in einer kurzen HTTP-Anfrage senden.

Dieser Beitrag zeigt den einfachen Python-Server, warum ein WSGI-Worker das nicht ebenso kann, was Django und Flask jeweils brauchen, um es auf Ihren eigenen Servern zu tun, und den gehosteten Weg mit funktionierendem Code für beide.

Ein WebSocket-Server in reinem Python

Ein WebSocket ist eine Verbindung in beide Richtungen zwischen einem Browser und einem Server, die offen bleibt, sodass jede Seite jederzeit senden kann. Die Bibliothek websockets liefert Ihnen die Serverseite auf asyncio. Dieser Server gibt jede Nachricht, die er bekommt, an alle weiter, die verbunden sind:

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

Eine Seite verbindet sich über die WebSocket-API, die jeder Browser hat:

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

Öffnen Sie das in zwei Tabs, und jeder gibt aus, was der andere sendet. Läuft es auf einer öffentlichen Adresse, verbindet sich unser WebSocket-Test aus einem Browser damit und erklärt jeden Close-Code. Meldet der Browser nur, dass die Verbindung fehlgeschlagen ist, zeigt unser Beitrag zum WebSocket-Fehler 1006, wie Sie die Ursache finden. Wenn sich Ihr Python-Code selbst mit dem Server eines anderen verbindet, hat dieselbe Bibliothek auch einen Client: connect() in websockets.asyncio.client.

Zwei Dinge im Server oben bestimmen alles, was folgt. Der Handler läuft so lange weiter, wie die Seite offen bleibt, oft stundenlang. Und connections lebt im Speicher dieses einen Prozesses.

Warum Django und Flask auf WSGI keinen WebSocket halten können

Die meisten Django- und Flask-Apps laufen auf WSGI, dem Standard zwischen Python-Webservern und Apps. Er besteht aus einem Funktionsaufruf pro Anfrage: Der Server ruft Ihre App auf, und Ihre App gibt eine Antwort zurück. Danach gibt es keinen Weg, weiter mit dem Browser zu sprechen.

Auf Gunicorn, einem üblichen Server für diese Apps, zeigt sich das in der Praxis:

  • Ein Sync-Worker bearbeitet eine Anfrage nach der anderen. Ein WebSocket darin würde ihn beschäftigt halten, solange die Seite offen ist, sodass eine Website mit vier Workern schon bei vier offenen Seiten niemandem sonst mehr antworten könnte.
  • Ein Worker, der an einer Anfrage hängt, wird neu gestartet. Schweigt ein Sync-Worker länger als das Timeout, standardmäßig 30 Sekunden, wird er beendet und neu gestartet.
  • async def ändert daran nichts. Die Flask-Dokumentation sagt es deutlich: Auch mit asynchronen Views bleibt pro Anfrage ein Worker belegt. Die Django-Dokumentation sagt, dass eine asynchrone View unter WSGI in einem eigenen, einmaligen Event Loop läuft, ohne die Vorteile eines asynchronen Stacks.

Was es auf Ihren eigenen Servern braucht

In Django reicht der Wechsel zu ASGI allein nicht, denn der ASGI-Handler, den Django mitbringt, nimmt nur HTTP an. Das Django-Projekt pflegt ein offizielles Add-on für WebSockets. Sie fügen asgi.py hinzu, schreiben neben Ihren Views Consumer für die Verbindungen, betreiben einen ASGI-Server und stellen einen Proxy davor, der den WebSocket-Traffic dorthin schickt. Ihre normalen Views können auf WSGI bleiben.

In Flask liefert eine Erweiterung eine WebSocket-Route, und jede offene Verbindung belegt einen Thread oder ein Greenlet eines Workers. Mit Threads bedeutet --threads 100 bei Gunicorn höchstens 100 offene Seiten pro Worker, normale Anfragen eingeschlossen. Worker auf gevent halten mehr, indem sie die blockierenden Funktionen von Python selbst patchen.

So oder so begleitet Sie dieselbe Liste:

  • Jedes Event teilen. Ein broadcast() über Verbindungen im Speicher erreicht nur die Browser an diesem einen Prozess. Ab dem zweiten Prozess muss jedes Event durch einen Kanal laufen, den sich alle teilen, meist Redis.
  • Wissen, wer sich verbindet. Der WebSocket des Browsers nimmt eine Adresse und Subprotokolle an, und ein Header lässt sich nicht setzen. Also liest Ihr Server das Session-Cookie oder ein Token in der Adresse und entscheidet, was dieser Nutzer hören darf.
  • Deploys. Ein Neustart trennt jede Verbindung, alle Browser verbinden sich gleichzeitig neu, und eine Seite, die weg war, verpasst, was in der Zwischenzeit gesendet wurde, es sei denn, etwas hebt es auf.
  • Proxys. Sie schließen Verbindungen, die inaktiv wirken, also brauchen Sie einen Heartbeat, und jeder Proxy auf dem Weg muss so eingerichtet sein, dass er WebSockets durchlässt.

FastAPI-WebSockets mit mehr als einem Worker geht diese Liste mit Code durch, und WebSockets in Laravel begegnet ihr von der PHP-Seite aus. Nichts davon ist exotisch, und viele Teams machen das gut. Aber es bleibt ein zweites System neben Ihrer App, solange die App Live-Funktionen hat.

Oder Ihre App bleibt, wie sie ist

Ein gehosteter Echtzeit-Dienst nimmt die Verbindungen aus Ihren Workern heraus. Die Browser verbinden sich mit dem Dienst. Ihre View sendet jedes Event in einer kurzen HTTPS-Anfrage, und der Dienst stellt es jeder Seite zu, die es bekommen soll. Kurze Anfragen sind genau das, was WSGI gut kann, also bleiben Gunicorn, Ihre Worker und Ihr Host, wie sie sind.

Aufbau Was jede Verbindung hält Was Sie hinzufügen
Nur WSGI Nichts, also keine WebSockets Nichts
WSGI mit Threads oder gevent Ein Thread oder Greenlet eines Workers Einen gemeinsamen Kanal ab dem zweiten Worker
ASGI Ein Task in einem Event Loop Einen ASGI-Server, eine Proxy-Regel, einen gemeinsamen Kanal
Ein gehosteter Dienst Die Server des Dienstes Eine Anfrage für jedes Event

Django auf WordPlus Cloud

WordPlus Cloud kommt als ein einziges Paket zu Django, ohne dass Sie Node installieren müssen:

Shell
pip install 'wordplus-realtime[django]'

Fügen Sie "wordplus_realtime.django" zu INSTALLED_APPS hinzu, setzen Sie WORDPLUS_SITE, WORDPLUS_SECRET und WORDPLUS_LOCAL_KEY in der Umgebung Ihres Servers und legen Sie Ihre Räume einmal fest, jeweils mit einer Regel dafür, wer beitreten darf:

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)

Importieren Sie diese Datei in Ihrem AppConfig.ready(), damit die Räume vor der ersten Anfrage bestehen. Eine Zeile in urls.py fügt die Routen hinzu, die den Seiten antworten, die einem Raum beitreten wollen, und die Browserdateien des SDK ausliefern:

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

Der Nutzer kommt aus der Session, und die CSRF-Prüfung von Django bleibt für diese Routen aktiv. {% wordplus_realtime %} im Head eines Templates schreibt die Einstellungen der Seite für ihren angemeldeten Nutzer, sodass sich die Seite ohne vorherige Anfrage verbindet.

Jede View auf jedem beliebigen Worker sendet dann, sobald ihre Transaktion committet ist, sodass niemand eine Änderung sieht, die zurückgerollt wurde:

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

Dieses emit ist eine HTTPS-Anfrage, die in der View stattfindet. Eine asynchrone View tut dasselbe mit await realtime.to(…).aemit(…). Für viele Events auf einmal, oder wo eine Anfrage nicht auf sie warten soll, senden Sie sie aus Celery oder einer anderen Task-Queue.

Flask auf WordPlus Cloud

In Flask ist es dasselbe Paket, ein einziger Aufruf und dieselbe Art von 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}

Der Nutzer ist current_user aus Flask-Login, wenn Ihre App es verwendet, sonst session["user_id"]. {{ wordplus_realtime() }} im Head eines Templates schreibt die Einstellungen der Seite.

Die Seite ist in beiden gleich

Ihr JavaScript tritt dem Raum direkt bei, ohne Bundler, denn diese Einstellungen nennen den Client, den Ihre Routen ausliefern:

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

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

Das läuft mit einem Worker genauso wie mit vierzig. Darüber hinaus:

  • Nichts geht bei einer Neuverbindung verloren. Ein Raum bewahrt seine letzten Events auf, sodass eine Seite, die zurückkommt, bekommt, was sie verpasst hat, in der richtigen Reihenfolge.
  • Jede Seite eines Nutzers. realtime.to_user(42).emit("notice", {"text": "Your order shipped"}) erreicht alle Tabs und Geräte, die dieser Nutzer offen hat, wo immer er in Ihrer App gerade ist. Ein Nutzer, der nichts offen hat, bekommt nichts, also senden Sie für das, was ihn unbedingt erreichen muss, eine E-Mail.
  • Eine Verbindung für alle Tabs. Die Tabs eines Browsers teilen sich eine Verbindung, sodass eine Person mit drei offenen Tabs einmal zählt.
  • Unterwegs versiegelt. Was Ihr Server an einen Raum mit einer Regel sendet, wird verschlüsselt übertragen, mit Schlüsseln, die nur Ihr Server und Ihre Nutzer haben.
  • Mehr als Events. Online-Status, Anrufe, die in jedem Tab klingeln, Gruppenanrufe und Livestreams laufen über dieselbe Verbindung, mit fertigem Anrufbildschirm, Chat und Player aus Better Messages oder mit Ihrer eigenen Oberfläche auf derselben API.

Wann ein eigener Server besser passt

Ein gehosteter Dienst passt nicht für jede Aufgabe. Ihr Python-Code erfährt über einen Webhook, was Seiten senden, also über eine HTTP-Anfrage, die mehr als einmal ankommen kann, und nicht über eine Live-Schleife mit jeder Verbindung. Ein Spiel oder ein Steuerungssystem, bei dem Python jede Nachricht innerhalb von Millisekunden beantworten muss, gehört auf einen eigenen asyncio-Server wie den am Anfang dieses Beitrags.

Beginnen Sie mit Ihrem Framework

Die Django-Anleitung und die Flask-Anleitung enthalten die ganze Einrichtung. Die Django-Demo und die Flask-Demo sind jeweils ein kleiner Shop, der darauf aufbaut und in dem eine Bestellung in einem anderen Fenster auf „versendet“ wechselt, während Sie klicken.

Für WordPlus Cloud for Apps gelten Preise nach gleichzeitigen Verbindungen, ab 1.000, monatlich oder jährlich abgerechnet, und unser Beitrag zu Echtzeit-Preisen erklärt, wie das Zählen nach Verbindungen funktioniert. Sehen Sie, was sie für Apps leistet, oder werfen Sie einen Blick auf die Preise für Apps. Unsere Seite zur WebSocket-API zeigt Räume, Präsenz und Ereignisse in jedem Stack. Fragen zu Ihrer Integration? Schreiben Sie uns.