בלוג

חיבורי websocket ב-Python: זמן אמת ב-Django וב-Flask

· Andrij Tkachenko · 7 דקות קריאה

קו מפותל כמו נחש יוצא משורה של שרתי worker אל ענן, שמחזיק קווים פתוחים לארבעה חלונות דפדפן

ב-Python אפשר להריץ שרת websocket בכחמש עשרה שורות, כתהליך asyncio שמחזיק כל חיבור פתוח. Django ו-Flask על WSGI לא יכולים להחזיק את החיבורים האלה בעצמם, ולכן או שאתם מריצים שרת שפועל ברציפות לצד האפליקציה, או שאתם נותנים לשירות מנוהל להחזיק אותם בזמן שה-views שלכם שולחים כל event בבקשת HTTP קצרה אחת.

הפוסט הזה מציג את השרת ב-Python רגיל, מסביר למה worker של WSGI לא יכול לעשות את אותו הדבר, מה נדרש ב-Django וב-Flask כדי לעשות את זה על השרתים שלכם, ומראה את הדרך המנוהלת עם קוד עובד לשניהם.

שרת websocket ב-Python רגיל

websocket הוא חיבור דו-כיווני בין דפדפן לשרת שנשאר פתוח, כך שכל צד יכול לשלוח בכל רגע. הספרייה websockets נותנת לכם את צד השרת על asyncio. השרת הזה מעביר כל הודעה שהוא מקבל לכל מי שמחובר:

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

דף מתחבר דרך ה-API של WebSocket שיש בכל דפדפן:

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

פתחו את זה בשתי לשוניות, וכל אחת מדפיסה את מה שהשנייה שולחת. אחרי שהוא רץ בכתובת ציבורית, בדיקת WebSocket שלנו מתחברת אליו מדפדפן ומסבירה כל קוד סגירה. אם הדפדפן מדווח רק שהחיבור נכשל, הפוסט שלנו על שגיאת WebSocket 1006 מראה איך למצוא את הסיבה. אם הקוד שלכם ב-Python הוא זה שמתחבר לשרת של מישהו אחר, לאותה ספרייה יש גם לקוח, connect() ב-websockets.asyncio.client.

שני דברים בשרת הזה קובעים את כל מה שבא אחר כך. ה-handler ממשיך לרוץ כל עוד הדף פתוח, ולעיתים קרובות מדובר בשעות. ו-connections חי בזיכרון של התהליך הזה בלבד.

למה Django ו-Flask לא יכולים להחזיק websocket על WSGI

רוב האפליקציות ב-Django וב-Flask רצות על WSGI, התקן שבין שרתי ווב ב-Python לאפליקציות. זו קריאה אחת לפונקציה לכל בקשה: השרת קורא לאפליקציה שלכם, והאפליקציה מחזירה תשובה. אין בו דרך להמשיך לדבר עם הדפדפן אחרי זה.

ב-Gunicorn, שרת נפוץ לאפליקציות כאלה, רואים את זה בפועל:

  • sync worker מטפל בבקשה אחת בכל פעם. websocket שמוחזק בתוכו יעסיק אותו כל עוד הדף פתוח, כך שארבעה דפים פתוחים ישאירו אתר עם ארבעה workers בלי יכולת לענות לאף אחד אחר.
  • worker שתקוע על בקשה אחת מופעל מחדש. sync worker ששותק מעבר ל-timeout, 30 שניות כברירת מחדל, נהרג ומופעל מחדש.
  • async def לא משנה את זה. התיעוד של Flask ברור בעניין: גם view אסינכרוני תופס worker אחד למשך כל הבקשה. התיעוד של Django אומר שתחת WSGI, view אסינכרוני רץ ב-event loop חד-פעמי משלו, בלי היתרונות של stack אסינכרוני.

מה נדרש על השרתים שלכם

ב-Django, מעבר ל-ASGI לבדו לא מספיק, כי ה-handler של ASGI ש-Django כולל מטפל רק ב-HTTP. פרויקט Django מתחזק תוסף רשמי ל-websocket. אתם מוסיפים asgi.py, כותבים consumers לחיבורים לצד ה-views שלכם, מריצים שרת ASGI, ומציבים לפניו proxy שמעביר אליו תעבורת websocket. ה-views הרגילים שלכם יכולים להישאר על WSGI.

ב-Flask, הרחבה נותנת לכם route ל-websocket, וכל חיבור פתוח תופס thread או greenlet של worker. עם threads, הדגל --threads 100 של Gunicorn אומר לכל היותר 100 דפים פתוחים ל-worker, כולל הבקשות הרגילות. workers על gevent מחזיקים יותר, כי הם עושים patch לפונקציות החוסמות של Python עצמו.

בכל מקרה, אותה רשימה הולכת איתכם:

  • שיתוף של כל event. broadcast() על חיבורים בזיכרון מגיע רק לדפדפנים שעל אותו תהליך. מעבר לתהליך אחד, כל event צריך לעבור בערוץ שכולם חולקים, בדרך כלל Redis.
  • לדעת מי מתחבר. ה-WebSocket של הדפדפן מקבל כתובת ו-subprotocols, בלי דרך להגדיר header. לכן השרת שלכם קורא את ה-cookie של ה-session או token שבכתובת, ומחליט למה המשתמש הזה רשאי להאזין.
  • deploys. הפעלה מחדש מנתקת כל חיבור, כל הדפדפנים מתחברים מחדש בבת אחת, ודף שלא היה מחובר מפספס את מה שנשלח בינתיים, אלא אם משהו שומר את זה בשבילו.
  • proxies. הם סוגרים חיבורים שנראים לא פעילים, ולכן צריך heartbeat, וכל proxy בדרך צריך להיות מוגדר כך שיעביר websocket.

הפוסט על חיבורי websocket ב-FastAPI עם יותר מ-worker אחד עובר על הרשימה הזו עם קוד, והפוסט על חיבורי websocket ב-Laravel פוגש אותה מהצד של PHP. שום דבר מזה אינו אקזוטי, והרבה צוותים עושים את זה היטב. אבל זו עדיין מערכת שנייה לצד האפליקציה שלכם, כל עוד יש בה תכונות חיות.

או להשאיר את האפליקציה כמו שהיא

שירות מנוהל לזמן אמת מוציא את החיבורים מה-workers שלכם. הדפדפנים מתחברים לשירות. ה-view שלכם שולח כל event בבקשת HTTPS קצרה אחת, והשירות מוסר אותו לכל דף שצריך לקבל אותו. בקשות קצרות הן בדיוק מה ש-WSGI טוב בו, ולכן Gunicorn, ה-workers והאחסון שלכם נשארים כמו שהם.

הגדרה מה מחזיק כל חיבור מה מוסיפים
WSGI בלבד שום דבר, ולכן אין websocket שום דבר
WSGI עם threads או gevent thread או greenlet של worker ערוץ משותף מעבר ל-worker אחד
ASGI משימה על event loop שרת ASGI, כלל ב-proxy, ערוץ משותף
שירות מנוהל השרתים של השירות בקשה אחת לכל event

Django על WordPlus Cloud

WordPlus Cloud מגיע ל-Django כחבילה אחת, בלי צורך להתקין Node:

Shell
pip install 'wordplus-realtime[django]'

הוסיפו את "wordplus_realtime.django" ל-INSTALLED_APPS, קבעו את WORDPLUS_SITE, WORDPLUS_SECRET ו-WORDPLUS_LOCAL_KEY בסביבה של השרת שלכם, והגדירו את החדרים שלכם פעם אחת, כל אחד עם כלל שקובע מי רשאי להצטרף:

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)

ייבאו את הקובץ הזה מתוך AppConfig.ready() שלכם, כדי שהחדרים יהיו קיימים לפני הבקשה הראשונה. שורה אחת ב-urls.py מוסיפה את ה-routes שעונים לדפים שמבקשים להצטרף לחדר ומגישים את קובצי הדפדפן של ה-SDK:

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

המשתמש מגיע מה-session, ובדיקת ה-CSRF של Django נשארת פעילה ב-routes האלה. {% wordplus_realtime %} ב-head של template כותב את ההגדרות של הדף עבור המשתמש המחובר שלו, כך שהדף מתחבר בלי בקשה קודמת.

מכאן, כל view, בכל worker, שולח ברגע שהטרנזקציה שלו עוברת commit, כך שאף אחד לא רואה שינוי שעבר 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}))

ה-emit הזה הוא בקשת HTTPS אחת, שנעשית בתוך ה-view. view אסינכרוני עושה את אותו הדבר עם await realtime.to(…).aemit(…). כשיש הרבה events בבת אחת, או כשבקשה לא צריכה לחכות להם, שלחו אותם מ-Celery או מתור משימות אחר.

Flask על WordPlus Cloud

ב-Flask זו אותה חבילה, קריאה אחת ואותו סוג של כלל:

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}

המשתמש הוא current_user מ-Flask-Login כשהוא קיים באפליקציה שלכם, ואחרת session["user_id"]. {{ wordplus_realtime() }} ב-head של template כותב את ההגדרות של הדף.

הדף זהה בשניהם

ה-JavaScript שלכם מצטרף לחדר כמו שהוא, בלי bundler, כי ההגדרות האלה מצביעות על הלקוח שה-routes שלכם מגישים:

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

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

זה רץ אותו דבר עם worker אחד או עם ארבעים. ומעבר לזה:

  • שום דבר לא הולך לאיבוד בהתחברות מחדש. חדר שומר את ה-events האחרונים שלו, כך שדף שחוזר מקבל את מה שפספס, לפי הסדר.
  • כל הדפים של משתמש אחד. realtime.to_user(42).emit("notice", {"text": "Your order shipped"}) מגיע לכל לשונית ולכל מכשיר שפתוחים אצלו, בכל מקום שבו הוא נמצא באפליקציה שלכם. משתמש שאין אצלו שום דבר פתוח לא מקבל כלום, ולכן שלחו אימייל על מה שחייב להגיע אליו.
  • חיבור אחד לכל הלשוניות. הלשוניות של דפדפן חולקות חיבור אחד, כך שאדם עם שלוש לשוניות פתוחות נספר פעם אחת.
  • סגור לאורך הדרך. מה שהשרת שלכם שולח לחדר עם כלל עובר מוצפן, במפתחות שרק השרת שלכם והמשתמשים שלכם מחזיקים.
  • יותר מ-events. מי מחובר כרגע, שיחות שמצלצלות בכל לשונית, שיחות קבוצתיות ושידורים חיים מגיעים על אותו חיבור, עם מסך שיחה, צ׳אט ונגן מוכנים מ-Better Messages, או עם ממשק משלכם על אותו API.

מתי שרת משלכם מתאים יותר

שירות מנוהל לא מתאים לכל משימה. הקוד שלכם ב-Python שומע את מה שדפים שולחים דרך webhook, בקשת HTTP שיכולה להגיע יותר מפעם אחת, ולא דרך לולאה חיה מול כל חיבור. משחק או מערכת בקרה, שבהם Python צריך לענות על כל הודעה תוך אלפיות שנייה, מקומם על שרת asyncio משלהם, כמו זה שבתחילת הפוסט.

התחילו מה-framework שלכם

המדריך ל-Django ו-המדריך ל-Flask כוללים את כל ההגדרה. ההדגמה של Django ו-ההדגמה של Flask הן חנות קטנה שבנויה על כל אחד מהם, שבה הזמנה עוברת ל"נשלחה" בחלון אחר ברגע שאתם לוחצים.

WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי, ו-הפוסט שלנו על תמחור של זמן אמת מסביר איך עובדת ספירה לפי חיבור. ראו מה הוא עושה לאפליקציות, או את המחירים לאפליקציות. העמוד שלנו על ה-API של WebSocket מציג חדרים, נוכחות ואירועים בכל סטאק. שאלות על האינטגרציה שלכם? כתבו לנו.