Blog

Websockety w Pythonie: czas rzeczywisty w Django i Flasku

· Andrij Tkachenko · 8 min czytania

Linia zwinięta jak wąż biegnie od rzędu serwerów z workerami do chmury, która utrzymuje otwarte linie z czterema oknami przeglądarki

Python uruchomi serwer websocket w mniej więcej piętnastu linijkach, jako proces asyncio, który utrzymuje każde połączenie otwarte. Django i Flask na WSGI same tych połączeń nie utrzymają, więc albo uruchamiasz stale działający serwer obok aplikacji, albo oddajesz je hostowanej usłudze, a Twoje widoki wysyłają każde zdarzenie jednym krótkim żądaniem HTTP.

Ten wpis pokazuje serwer w czystym Pythonie, wyjaśnia, dlaczego worker WSGI nie zrobi tego samego i czego wymagają Django oraz Flask na własnych serwerach, a potem przechodzi do sposobu hostowanego, z działającym kodem dla obu.

Serwer websocket w czystym Pythonie

Websocket to dwukierunkowe połączenie między przeglądarką a serwerem, które pozostaje otwarte, więc każda ze stron może wysyłać w dowolnej chwili. Biblioteka websockets daje Ci stronę serwerową na asyncio. Ten serwer przekazuje każdą otrzymaną wiadomość wszystkim połączonym:

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

Strona łączy się przez WebSocket API, które ma każda przeglądarka:

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

Otwórz to w dwóch kartach, a każda wypisze to, co wysyła druga. Gdy działa już pod publicznym adresem, nasz Test WebSocket połączy się z nim z przeglądarki i wyjaśni każdy kod zamknięcia. Jeśli przeglądarka zgłasza tylko, że połączenie się nie powiodło, nasz artykuł o błędzie WebSocket 1006 pokazuje, jak znaleźć przyczynę. Jeśli to Twój kod w Pythonie łączy się z cudzym serwerem, ta sama biblioteka ma klienta: connect() w websockets.asyncio.client.

Dwie rzeczy w powyższym serwerze przesądzają o wszystkim, co dalej. Handler działa tak długo, jak strona pozostaje otwarta, często godzinami. A connections żyje w pamięci tego jednego procesu.

Dlaczego Django i Flask na WSGI nie utrzymają websocketu

Większość aplikacji Django i Flask działa na WSGI, standardzie między serwerami WWW w Pythonie a aplikacjami. To jedno wywołanie funkcji na żądanie: serwer wywołuje Twoją aplikację, a ona zwraca odpowiedź. Potem nie ma już jak dalej rozmawiać z przeglądarką.

Na Gunicornie, typowym serwerze dla takich aplikacji, widać to w praktyce:

  • Worker synchroniczny obsługuje jedno żądanie naraz. Websocket utrzymywany w takim workerze zajmowałby go tak długo, jak strona jest otwarta, więc cztery otwarte strony sprawiłyby, że witryna z czterema workerami nie mogłaby odpowiedzieć nikomu innemu.
  • Worker, który utknął na jednym żądaniu, jest restartowany. Worker synchroniczny milczący dłużej niż timeout, domyślnie 30 sekund, zostaje zabity i uruchomiony od nowa.
  • async def tego nie zmienia. Dokumentacja Flaska mówi wprost, że także przy widokach asynchronicznych każde żądanie zajmuje jednego workera. Dokumentacja Django podaje, że pod WSGI widok asynchroniczny działa we własnym, jednorazowym event loopie, bez korzyści, jakie daje asynchroniczny stos.

Czego to wymaga na własnych serwerach

W Django samo przejście na ASGI nie wystarczy, bo handler ASGI dostarczany z Django obsługuje tylko HTTP. Projekt Django utrzymuje oficjalny dodatek do websocketów. Dodajesz asgi.py, piszesz consumery dla połączeń obok swoich widoków, uruchamiasz serwer ASGI i stawiasz przed nim proxy, które kieruje do niego ruch websocket. Zwykłe widoki mogą zostać na WSGI.

We Flasku rozszerzenie daje Ci trasę websocket, a każde otwarte połączenie zajmuje wątek albo greenlet workera. Przy wątkach --threads 100 w Gunicornie oznacza najwyżej 100 otwartych stron na workera, razem ze zwykłymi żądaniami. Workery na gevent utrzymują więcej, łatając blokujące funkcje samego Pythona.

W obu przypadkach czeka Cię ta sama lista:

  • Dzielenie się każdym zdarzeniem. broadcast() po połączeniach w pamięci dociera tylko do przeglądarek na tym jednym procesie. Przy więcej niż jednym procesie każde zdarzenie musi przejść przez kanał wspólny dla nich wszystkich, zwykle Redis.
  • Rozpoznanie, kto się łączy. WebSocket w przeglądarce przyjmuje adres i podprotokoły, bez możliwości ustawienia nagłówka. Twój serwer odczytuje więc plik cookie sesji albo token w adresie i decyduje, czego ten użytkownik może słuchać.
  • Deploye. Restart zrywa każde połączenie, wszystkie przeglądarki łączą się ponownie naraz, a strona, która była w tym czasie rozłączona, traci to, co wysłano w międzyczasie, chyba że coś to dla niej przechowa.
  • Proxy. Zamykają połączenia, które wyglądają na bezczynne, więc potrzebujesz heartbeatu, a każde proxy po drodze musi być skonfigurowane tak, żeby przepuszczało websockety.

Wpis o websocketach w FastAPI na więcej niż jednym workerze omawia tę listę z kodem, a ten o websocketach w Laravel pokazuje ją od strony PHP. Nic z tego nie jest egzotyczne i wiele zespołów robi to dobrze. Ale to drugi system, który trzeba utrzymywać obok aplikacji tak długo, jak ma ona funkcje na żywo.

Albo zostaw aplikację taką, jaka jest

Hostowana usługa czasu rzeczywistego przejmuje połączenia od Twoich workerów. Przeglądarki łączą się z usługą. Twój widok wysyła każde zdarzenie jednym krótkim żądaniem HTTPS, a usługa dostarcza je każdej stronie, która powinna je dostać. Krótkie żądania to właśnie to, w czym WSGI jest dobre, więc Gunicorn, Twoje workery i Twój hosting zostają bez zmian.

Konfiguracja Co utrzymuje każde połączenie Co dodajesz
Samo WSGI Nic, więc nie ma websocketów Nic
WSGI z wątkami albo gevent Wątek albo greenlet workera Wspólny kanał przy kilku workerach
ASGI Zadanie na event loopie Serwer ASGI, regułę proxy, wspólny kanał
Hostowana usługa Serwery tej usługi Jedno żądanie na każde zdarzenie

Django w WordPlus Cloud

WordPlus Cloud trafia do Django jako jeden pakiet, bez instalowania Node:

Shell
pip install 'wordplus-realtime[django]'

Dodaj "wordplus_realtime.django" do INSTALLED_APPS, ustaw WORDPLUS_SITE, WORDPLUS_SECRET i WORDPLUS_LOCAL_KEY w środowisku swojego serwera i raz zadeklaruj swoje pokoje, każdy z regułą określającą, kto może do niego dołączyć:

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)

Zaimportuj ten plik w AppConfig.ready(), żeby pokoje istniały przed pierwszym żądaniem. Jedna linijka w urls.py dodaje trasy, które odpowiadają stronom proszącym o dołączenie do pokoju i serwują pliki SDK dla przeglądarki:

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

Użytkownik pochodzi z sesji, a sprawdzanie CSRF w Django pozostaje włączone dla tych tras. {% wordplus_realtime %} w sekcji head szablonu zapisuje ustawienia strony dla zalogowanego użytkownika, więc strona łączy się bez żadnego wcześniejszego żądania.

A dowolny widok, na dowolnym workerze, wysyła zdarzenie po zatwierdzeniu transakcji, więc nikt nie zobaczy zmiany, która została wycofana:

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

To emit to jedno żądanie HTTPS, wykonywane w widoku. Widok asynchroniczny robi to samo przez await realtime.to(…).aemit(…). Przy wielu zdarzeniach naraz albo gdy żądanie nie powinno na nie czekać, wysyłaj je z Celery albo innej kolejki zadań.

Flask w WordPlus Cloud

We Flasku to ten sam pakiet, jedno wywołanie i ten sam rodzaj reguły:

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}

Użytkownikiem jest current_user z Flask-Login, jeśli Twoja aplikacja go ma, a w przeciwnym razie session["user_id"]. {{ wordplus_realtime() }} w sekcji head szablonu zapisuje ustawienia strony.

Strona jest taka sama w obu przypadkach

Twój JavaScript dołącza do pokoju w takiej postaci, w jakiej go piszesz, bez bundlera, bo te ustawienia wskazują klienta serwowanego przez Twoje trasy:

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

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

Działa to tak samo z jednym workerem, jak i z czterdziestoma. A do tego:

  • Nic nie ginie przy ponownym połączeniu. Pokój przechowuje swoje ostatnie zdarzenia, więc strona, która wraca, dostaje to, co ją ominęło, w odpowiedniej kolejności.
  • Każda strona jednego użytkownika. realtime.to_user(42).emit("notice", {"text": "Your order shipped"}) dociera do wszystkich kart i urządzeń, które ten użytkownik ma otwarte, gdziekolwiek jest w Twojej aplikacji. Użytkownik, który nie ma nic otwartego, nie dostanie nic, więc to, co musi do niego dotrzeć, wyślij e-mailem.
  • Jedno połączenie dla wszystkich kart. Karty jednej przeglądarki dzielą jedno połączenie, więc osoba z trzema otwartymi kartami jest liczona tylko raz.
  • Zapieczętowane w drodze. To, co Twój serwer wysyła do pokoju z regułą, podróżuje zaszyfrowane kluczami, które mają tylko Twój serwer i Twoi użytkownicy.
  • Więcej niż zdarzenia. Informacja, kto jest online, rozmowy, które dzwonią w każdej karcie, rozmowy grupowe i transmisje na żywo działają przez to samo połączenie, z gotowym ekranem rozmowy, czatem i odtwarzaczem z Better Messages albo z Twoim własnym interfejsem na tym samym API.

Kiedy własny serwer sprawdzi się lepiej

Hostowana usługa nie nadaje się do każdego zadania. Twój kod w Pythonie dowiaduje się, co wysyłają strony, przez webhook, czyli żądanie HTTP, które może dotrzeć więcej niż raz, a nie przez pętlę na żywo z każdym połączeniem. Miejsce gry albo systemu sterowania, w którym Python musi odpowiadać na każdą wiadomość w ciągu milisekund, jest na własnym serwerze asyncio, takim jak ten z początku tego wpisu.

Zacznij od swojego frameworka

Przewodnik dla Django i przewodnik dla Flaska zawierają całą konfigurację. Demo Django i demo Flaska to mały sklep zbudowany na każdym z nich, w którym status zamówienia zmienia się na „wysłane” w drugim oknie w chwili, gdy klikasz.

WordPlus Cloud for Apps ma cenę według jednoczesnych połączeń, od 1000 wzwyż, rozliczaną miesięcznie lub rocznie, a nasz wpis o cenach usług czasu rzeczywistego wyjaśnia, jak działa liczenie według połączeń. Zobacz, co daje aplikacjom albo cennik dla aplikacji. Nasza strona o API WebSocket pokazuje pokoje, obecność i zdarzenia w każdym stacku. Chcesz zapytać o swoją integrację? Napisz do nas.