آموزش WebSocket با پایتون — ارتباط real-time

فهرست مطالب

• WebSocket چیست و چرا به آن نیاز داریم؟
• تفاوت با HTTP: انقلابی در ارتباطات وبی
• شروع کار: پیش‌نیازها و نصب کتابخانه‌ها
• ساخت سرور WebSocket با پایتون
• گام اول: کدنویسی سرور ساده
• مدیریت همزمان چند کلاینت
• ساخت کلاینت WebSocket با پایتون
• گام اول: کدنویسی کلاینت ساده
• کاربردهای عملی WebSocket در دنیای واقعی
• امنیت و عملکرد در WebSocket
• عیب‌یابی سریع (Troubleshooting)
• پرسش‌های متداول (FAQ)

WebSocket چیست و چرا به آن نیاز داریم؟

WebSocket یک پروتکل ارتباطی استاندارد است که امکان ایجاد یک کانال ارتباطی دوطرفه (Full-Duplex) و پایدار را از طریق یک اتصال TCP واحد فراهم می‌کند. برخلاف HTTP که یک پروتکل درخواست-پاسخ (Request-Response) است و هر درخواست نیاز به باز کردن یک اتصال جدید یا نگهداری موقت آن دارد، WebSocket یک اتصال مداوم بین کلاینت (مثلاً مرورگر وب یا اپلیکیشن موبایل) و سرور برقرار می‌کند.

این اتصال پایدار به کلاینت و سرور اجازه می‌دهد تا در هر زمان که نیاز باشد، داده‌ها را به صورت مستقل به یکدیگر ارسال کنند، بدون اینکه نیازی به درخواست مکرر از سمت کلاینت باشد. این قابلییت برای برنامه‌های بی‌درنگ حیاتی است و مزایای بسیاری از جمله کاهش سربار شبکه، تأخیر کمتر و تجربه کاربری روان‌تر را به ارمغان می‌آورد.

تفاوت با HTTP: انقلابی در ارتباطات وبی

برای درک بهتر اهمیت WebSocket، لازم است که تفاوت‌های اصلی آن را با HTTP بشناسیم:

شروع کار: پیش‌نیازها و نصب کتابخانه‌ها

برای پیاده‌سازی WebSocket با پایتون، به موارد زیر نیاز دارید:

1. **پایتون:** نسخه 3.7 به بالا. (توصیه می‌شود از آخرین نسخه پایدار استفاده کنید).
2. **کتابخانه websockets:** این کتابخانه یک پیاده‌سازی آسان و کارآمد از پروتکل WebSocket برای پایتون فراهم می‌کند.

برای نصب کتابخانه websockets، کافی است دستور زیر را در ترمینال خود اجرا کنید:

pip install websockets

همچنین، اطمینان حاصل کنید که pip روی سیستم شما نصب و به‌روز است.

ساخت سرور WebSocket با پایتون

ساخت یک سرور WebSocket با پایتون با استفاده از کتابخانه websockets بسیار ساده است. این کتابخانه از سینتکس async/await پایتون استفاده می‌کند که برای مدیریت اتصالات همزمان و رویدادمحور بسیار مناسب است.

گام اول: کدنویسی سرور ساده

بیایید با یک مثال ساده شروع کنیم که سرور پیامی را از کلاینت دریافت کرده و سپس به آن پاسخ می‌دهد.

import asyncio
import websockets

# تابع handler برای مدیریت هر اتصال WebSocket
async def echo(websocket, path):
    print(f"کلاینت جدید متصل شد: {websocket.remote_address}")
    try:
        async for message in websocket:
            print(f"پیام دریافتی از کلاینت: {message}")
            await websocket.send(f"سرور دریافت کرد: {message}") # ارسال پاسخ به کلاینت
            print(f"پاسخ به کلاینت ارسال شد: 'سرور دریافت کرد: {message}'")
    except websockets.exceptions.ConnectionClosedOK:
        print(f"اتصال با کلاینت {websocket.remote_address} به خوبی بسته شد.")
    except websockets.exceptions.ConnectionClosedError as e:
        print(f"اتصال با کلاینت {websocket.remote_address} با خطا بسته شد: {e}")
    finally:
        print(f"کلاینت {websocket.remote_address} قطع شد.")

# راه‌اندازی سرور WebSocket
async def main():
    # سرور را روی هاست لوکال و پورت 8765 راه‌اندازی می‌کنیم
    async with websockets.serve(echo, "localhost", 8765):
        print("سرور WebSocket روی ws://localhost:8765 در حال گوش دادن است...")
        await asyncio.Future() # سرور را تا ابد فعال نگه می‌دارد

if __name__ == "__main__":
    asyncio.run(main())

توضیح کد:

• **asyncio:** این ماژول برای برنامه‌نویسی غیرهمزمان (asynchronous) در پایتون استفاده می‌شود.
• **websockets:** کتابخانه اصلی ما برای WebSocket.
• **echo(websocket, path):** این یک تابع غیرهمزمان است که هر بار یک کلاینت جدید به سرور متصل می‌شود، فراخوانی می‌گردد. websocket شیء اصلی برای تعامل با کلاینت است و path مسیر URL متصل شده را نشان می‌دهد (در این مثال، اهمیتی ندارد).
• **async for message in websocket::** سرور به صورت غیرهمزمان منتظر پیام‌های دریافتی از کلاینت می‌ماند.
• **await websocket.send(...):** برای ارسال پیام از سرور به کلاینت استفاده می‌شود.
• **websockets.serve(echo, "localhost", 8765):** این خط سرور را روی آدرس IP و پورت مشخص شده راه‌اندازی می‌کند و تابع echo را به عنوان Handler برای اتصالات جدید تعیین می‌کند.
• **asyncio.Future():** این خط باعث می‌شود سرور به طور نامحدود در حال اجرا بماند تا اتصالات را مدیریت کند.

مدیریت همزمان چند کلاینت

سرور بالا به صورت خودکار قادر به مدیریت چند کلاینت به طور همزمان است، زیرا asyncio و websockets به گونه‌ای طراحی شده‌اند که با رویدادها کار کنند. با این حال، اگر بخواهیم یک پیام را به چندین کلاینت متصل ارسال کنیم (مثلاً در یک چت‌روم)، نیاز داریم لیست کلاینت‌های متصل را نگهداری کنیم.

import asyncio
import websockets
import json

CONNECTED_CLIENTS = set() # مجموعه ای برای نگهداری تمام کلاینت های متصل

async def register(websocket):
    CONNECTED_CLIENTS.add(websocket)
    print(f"کلاینت جدید ثبت شد. تعداد کلاینت ها: {len(CONNECTED_CLIENTS)}")

async def unregister(websocket):
    CONNECTED_CLIENTS.remove(websocket)
    print(f"کلاینت قطع شد. تعداد کلاینت ها: {len(CONNECTED_CLIENTS)}")

async def server_handler(websocket, path):
    await register(websocket) # کلاینت را ثبت می کنیم
    try:
        async for message in websocket:
            print(f"پیام دریافتی از {websocket.remote_address}: {message}")
            # مثال: فرض می کنیم پیام ها در فرمت JSON هستند
            try:
                data = json.loads(message)
                if data["type"] == "chat_message":
                    # ارسال پیام چت به همه کلاینت های متصل
                    await broadcast(f"کاربر {websocket.remote_address} می گوید: {data['content']}")
                else:
                    await websocket.send(f"نوع پیام نامعتبر: {data['type']}")
            except json.JSONDecodeError:
                await websocket.send("فرمت پیام باید JSON باشد.")
            except KeyError:
                await websocket.send("پیام JSON باید شامل 'type' و 'content' باشد.")

    finally:
        await unregister(websocket) # کلاینت را از لیست حذف می کنیم

async def broadcast(message):
    if CONNECTED_CLIENTS: # اطمینان از وجود کلاینت های متصل
        await asyncio.wait([client.send(message) for client in CONNECTED_CLIENTS])
        print(f"پیام '{message}' به همه کلاینت ها ارسال شد.")

async def main():
    async with websockets.serve(server_handler, "localhost", 8765):
        print("سرور چت WebSocket روی ws://localhost:8765 در حال گوش دادن است...")
        await asyncio.Future()

if __name__ == "__main__":
    asyncio.run(main())

در این مثال، از یک مجموعه (set) به نام CONNECTED_CLIENTS برای ردیابی تمام اتصالات فعال استفاده کرده‌ایم. توابع register و unregister مسئول اضافه و حذف کردن کلاینت‌ها هستند. تابع broadcast نیز به همه کلاینت‌های متصل پیام ارسال می‌کند. این ساختار پایه یک سرور چت را فراهم می‌کند.

ساخت کلاینت WebSocket با پایتون

برای تست سرور WebSocket، به یک کلاینت نیاز داریم. این کلاینت می‌تواند یک مرورگر وب (با JavaScript) یا یک اسکریپت پایتون باشد. در اینجا، یک کلاینت پایتون را پیاده‌سازی می‌کنیم.

گام اول: کدنویسی کلاینت ساده

این کلاینت به سرور ما متصل شده، پیامی ارسال می‌کند و منتظر پاسخ می‌ماند.

import asyncio
import websockets
import json

async def client():
    uri = "ws://localhost:8765" # آدرس سرور WebSocket

    async with websockets.connect(uri) as websocket:
        print(f"متصل شد به: {uri}")

        # ارسال پیام به سرور
        message = input("لطفا پیام خود را وارد کنید: ")
        chat_message = {
            "type": "chat_message",
            "content": message
        }
        await websocket.send(json.dumps(chat_message))
        print(f"پیام به سرور ارسال شد: {chat_message['content']}")

        # دریافت پاسخ از سرور (یا پیام Broadcast)
        response = await websocket.recv()
        print(f"پیام دریافتی از سرور: {response}")

        # در یک محیط واقعی، کلاینت باید به گوش دادن برای پیام ها ادامه دهد
        # برای مثال، می توان از یک حلقه while True استفاده کرد
        # while True:
        #     try:
        #         message_from_server = await websocket.recv()
        #         print(f"پیام جدید: {message_from_server}")
        #     except websockets.exceptions.ConnectionClosedOK:
        #         print("اتصال به سرور قطع شد.")
        #         break
        #     except Exception as e:
        #         print(f"خطا در دریافت پیام: {e}")
        #         break

if __name__ == "__main__":
    asyncio.run(client())

توضیح کد کلاینت:

• **websockets.connect(uri):** این تابع یک اتصال به سرور WebSocket در آدرس uri ایجاد می‌کند.
• **await websocket.send(...):** برای ارسال پیام به سرور.
• **await websocket.recv():** برای دریافت پیام از سرور. این تابع تا زمانی که پیامی دریافت شود، متوقف می‌ماند.
• **حلقه while True (کامنت شده):** در یک سناریوی واقعی، کلاینت باید در یک حلقه منتظر پیام‌های ورودی از سرور باشد تا بتواند به طور پیوسته با سرور ارتباط برقرار کند.

کاربردهای عملی WebSocket در دنیای واقعی

WebSocket به دلیل قابلییت‌های بی‌درنگ خود، در طیف گسترده‌ای از برنامه‌های کاربردی مورد استفاده قرار می‌گیرد:

• **اپلیکیشن‌های چت آنلاین:** شاید رایج‌ترین و شناخته‌شده‌ترین کاربرد WebSocket باشد. هر پیام ارسالی بلافاصله به سایر کاربران نمایش داده می‌شود.
• **داشبوردهای زنده و مانیتورینگ:** نمایش لحظه‌ای داده‌ها از سنسورها، سرورها، یا بازارهای مالی بدون نیاز به رفرش صفحه.
• **بازی‌های آنلاین چندنفره:** به‌روزرسانی لحظه‌ای وضعیت بازی، حرکت بازیکنان و رویدادها بین همه شرکت‌کنندگان.
• **اینترنت اشیاء (IoT):** ارتباط بی‌درنگ با دستگاه‌های IoT برای ارسال دستورات یا دریافت داده‌های سنسورها.
• **نوتیفیکیشن‌های لحظه‌ای:** ارسال اعلان‌های فوری به کاربران هنگام وقوع رویدادهای خاص.
• **ویرایشگرهای متنی همکارانه:** امکان ویرایش همزمان یک سند توسط چند کاربر (مانند Google Docs).

امنیت و عملکرد در WebSocket

همانند هر پروتکل ارتباطی دیگر، امنیت و عملکرد WebSocket نیز از اهمیت بالایی برخوردار است:

• **امنیت (WSS):**
  • **رمزنگاری:** همیشه از wss:// (WebSocket Secure) به جای ws:// استفاده کنید. wss از TLS/SSL برای رمزنگاری داده‌ها استفاده می‌کند و از شنود غیرمجاز جلوگیری می‌کند.
  • **احراز هویت و مجوزدهی:** قبل از اجازه دادن به کلاینت برای ارسال یا دریافت داده‌های حساس، هویت آن را تأیید (Authentication) و مجوزهای دسترسی (Authorization) آن را بررسی کنید. می‌توانید از توکن‌های JWT یا سیستم‌های احراز هویت دیگر استفاده کنید.
  • **اعتبارسنجی ورودی:** تمام داده‌های دریافتی از کلاینت‌ها را به دقت اعتبارسنجی و پاک‌سازی کنید تا از حملاتی مانند Injection (SQL, XSS) جلوگیری شود.
  • **محدودیت نرخ (Rate Limiting):** برای جلوگیری از حملات DDoS یا سوءاستفاده از منابع، تعداد پیام‌هایی که یک کلاینت می‌تواند در یک بازه زمانی ارسال کند را محدود کنید.
• **عملکرد (Performance):**
  • **مدیریت اتصالات:** سرورهای WebSocket می‌توانند هزاران یا میلیون‌ها اتصال همزمان را مدیریت کنند. از الگوهای برنامه‌نویسی غیرهمزمان (مانند asyncio در پایتون) برای جلوگیری از مسدود شدن عملیات (blocking operations) استفاده کنید.
  • **بهینه‌سازی پیام‌ها:** اندازه پیام‌ها را کوچک نگه دارید و از فرمت‌های کارآمد مانند JSON (برای داده‌های ساختاریافته) یا Protobuf/MessagePack برای داده‌های باینری استفاده کنید.
  • **مقیاس‌پذیری:** برای برنامه‌های با ترافیک بالا، سرور WebSocket شما باید قابلیت مقیاس‌پذیری داشته باشد. این می‌تواند شامل استفاده از load balancers و توزیع اتصالات بین چندین نمونه سرور باشد. ابزارهایی مانند Redis Pub/Sub می‌توانند برای همگام‌سازی پیام‌ها بین سرورهای مختلف استفاده شوند.
  • **فریم‌بندی کارآمد:** پروتکل WebSocket خودش فریم‌بندی کارآمدی دارد، اما انتخاب درست بین ارسال پیام‌های متنی یا باینری می‌تواند در عملکرد تأثیرگذار باشد.

عیب‌یابی سریع (Troubleshooting)

در هنگام توسعه با WebSocket، ممکن است با مشکلاتی مواجه شوید. در اینجا به برخی از رایج‌ترین مشکلات و راه‌حل‌های آن‌ها اشاره می‌کنیم:

پرسش‌های متداول (FAQ)