Question

aiohttp内置了对websockets的支持。它很简单，效果很好。

文档中示例的简化版本为：

async def handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)

    # Async iterate the messages the client sends
    async for message in ws:
        ws.send_str('You sent: %s' % (message.data,))

    print('websocket connection closed')

在示例中，ws是对客户端的websocket连接的引用。我可以轻松地将此引用放入request.app，如@Crandel does here（即全局状态），但不能放在生产应用中，因为每个应用服务器（甚至每个工作者）都有自己的{{1实例。

这是否有可接受的模式？还有另一种方式吗？

注意：我不是指会话。我指的是联系。我想在服务器B中的应用程序代码中发生事件时向连接到服务器A的客户端发送消息

Answer 1

所以我只熟悉Node中的Socket.IO，但使用Socket.IO水平缩放websockets相当容易。

套接字可以带有Sessions，因此每个会话都由特定服务器管理。这样可以轻松保存每个打开的套接字的状态，并在所有服务器之间实现负载平衡。

这是用于Python的SocketIO：

https://pypi.python.org/pypi/socketIO-client

以下是关于如何将会话连接到redis-store以使其更快，并且跨服务器的负载平衡更易于管理的非常好的阅读。

How to share sessions with Socket.IO 1.x and Express 4.x?

我知道这不会回答你关于aiohttp的问题，但希望这会让你更好地了解套接字如何工作。

编辑：写在节点 -

在Socket.IO中，这非常简单，它有很多功能以各种不同的方式广播消息。

对于您的示例，如果您想向每个聊天室中的每个人发送消息。打开套接字的每个人都可以轻松编写。

socket.broadcast.emit('WARNING', "this is a test");

假设您打开了房间，您只能通过名为.to()的简单功能向该房间内的人广播消息。示例我有一个名为'BBQ'的房间：

socket.broadcast.to('BBQ').emit('invitation', 'Come get some food!');

这将在频道烧烤中向每个人发出消息 - 来获取一些食物！

编辑：编辑：

这是关于Socket.IO如何工作的精彩写作，请确保您阅读了函数更新版本的第二个答案。它比他们的文档更容易阅读。

Send response to all clients except sender (Socket.io)

据我所知，这也是python实现中的一切。为了便于使用，我肯定会将它用于websockets。 aiohttp似乎非常强大，但要么没有这个功能，要么埋没在文档中，要么只在代码中编写而没有任何文档。

Answer 2

如果我理解正确，您希望拥有多个websocket服务器，每个服务器都连接了多个客户端，但您希望能够与所有连接的客户端进行潜在通信。

这是一个创建三个简单服务器的示例 - 大写回显，随机引用和一天中的时间 - 然后向所有连接的客户端发送广播消息。也许这里有一些有用的想法。

Pastebin：https://pastebin.com/xDSACmdV

#!/usr/bin/env python3
"""
Illustrates how to have multiple websocket servers running and send
messages to all their various clients at once.

In response to stackoverflow question:
https://stackoverflow.com/questions/35820782/how-to-manage-websockets-across-multiple-servers-workers

Pastebin: https://pastebin.com/xDSACmdV
"""
import asyncio
import datetime
import random
import time
import webbrowser

import aiohttp
from aiohttp import web

__author__ = "Robert Harder"
__email__ = "rob@iharder.net"
__license__ = "Public Domain"


def main():
    # Create servers
    cap_srv = CapitalizeEchoServer(port=9990)
    rnd_srv = RandomQuoteServer(port=9991)
    tim_srv = TimeOfDayServer(port=9992)

    # Queue their start operation
    loop = asyncio.get_event_loop()
    loop.create_task(cap_srv.start())
    loop.create_task(rnd_srv.start())
    loop.create_task(tim_srv.start())

    # Open web pages to test them
    webtests = [9990, 9991, 9991, 9992, 9992]
    for port in webtests:
        url = "http://www.websocket.org/echo.html?location=ws://localhost:{}".format(port)
        webbrowser.open(url)
    print("Be sure to click 'Connect' on the webpages that just opened.")

    # Queue a simulated broadcast-to-all message
    def _alert_all(msg):
        print("Sending alert:", msg)
        msg_dict = {"alert": msg}
        cap_srv.broadcast_message(msg_dict)
        rnd_srv.broadcast_message(msg_dict)
        tim_srv.broadcast_message(msg_dict)

    loop.call_later(17, _alert_all, "ALL YOUR BASE ARE BELONG TO US")

    # Run event loop
    loop.run_forever()


class MyServer:
    def __init__(self, port):
        self.port = port  # type: int
        self.loop = None  # type: asyncio.AbstractEventLoop
        self.app = None  # type: web.Application
        self.srv = None  # type: asyncio.base_events.Server

    async def start(self):
        self.loop = asyncio.get_event_loop()
        self.app = web.Application()
        self.app["websockets"] = []  # type: [web.WebSocketResponse]
        self.app.router.add_get("/", self._websocket_handler)
        await self.app.startup()
        handler = self.app.make_handler()
        self.srv = await asyncio.get_event_loop().create_server(handler, port=self.port)
        print("{} listening on port {}".format(self.__class__.__name__, self.port))

    async def close(self):
        assert self.loop is asyncio.get_event_loop()
        self.srv.close()
        await self.srv.wait_closed()

        for ws in self.app["websockets"]:  # type: web.WebSocketResponse
            await ws.close(code=aiohttp.WSCloseCode.GOING_AWAY, message='Server shutdown')

        await self.app.shutdown()
        await self.app.cleanup()

    async def _websocket_handler(self, request):
        assert self.loop is asyncio.get_event_loop()
        ws = web.WebSocketResponse()
        await ws.prepare(request)
        self.app["websockets"].append(ws)

        await self.do_websocket(ws)

        self.app["websockets"].remove(ws)
        return ws

    async def do_websocket(self, ws: web.WebSocketResponse):
        async for ws_msg in ws:  # type: aiohttp.WSMessage
            pass

    def broadcast_message(self, msg: dict):
        for ws in self.app["websockets"]:  # type: web.WebSocketResponse
            ws.send_json(msg)


class CapitalizeEchoServer(MyServer):
    """ Echoes back to client whatever they sent, but capitalized. """

    async def do_websocket(self, ws: web.WebSocketResponse):
        async for ws_msg in ws:  # type: aiohttp.WSMessage
            cap = ws_msg.data.upper()
            ws.send_str(cap)


class RandomQuoteServer(MyServer):
    """ Sends a random quote to the client every so many seconds. """
    QUOTES = ["Wherever you go, there you are.",
              "80% of all statistics are made up.",
              "If a tree falls in the woods, and no one is around to hear it, does it make a noise?"]

    def __init__(self, interval: float = 10, *kargs, **kwargs):
        super().__init__(*kargs, **kwargs)
        self.interval = interval

    async def do_websocket(self, ws: web.WebSocketResponse):
        async def _regular_interval():
            while self.srv.sockets is not None:
                quote = random.choice(RandomQuoteServer.QUOTES)
                ws.send_json({"quote": quote})
                await asyncio.sleep(self.interval)

        self.loop.create_task(_regular_interval())

        await super().do_websocket(ws)  # leave client connected here indefinitely


class TimeOfDayServer(MyServer):
    """ Sends a message to all clients simultaneously about time of day. """

    async def start(self):
        await super().start()

        async def _regular_interval():
            while self.srv.sockets is not None:
                if int(time.time()) % 10 == 0:  # Only on the 10 second mark
                    timestamp = "{:%Y-%m-%d %H:%M:%S}".format(datetime.datetime.now())
                    self.broadcast_message({"timestamp": timestamp})
                await asyncio.sleep(1)

        self.loop.create_task(_regular_interval())


if __name__ == "__main__":
    main()

Answer 3

更新（2017年2月）

频道（幸运的是）没有合并到Django中。它可能仍然是一个伟大的项目，但它并不属于Django本身。

此外，我强烈建议您查看Postgres对pub / sub的相对较新的内置支持。它将probably outperform anything else，并使用Postgres作为支持服务在aiohttp上构建自定义解决方案，可能是您最好的选择。

原始

虽然不是aiohttp，Django Channels，可能会合并到Django 1.10，但却以非常直观的方式解决了这个问题，并由Andrew Godwin撰写， Django的作者migrations。

Django Channels抽象了许多服务器上的许多进程的概念＆＃34;通过在Django应用程序前创建路由图层。此路由层与后端（例如，Redis）通信以在进程之间维护可共享状态，并使用新的ASGI协议来促进处理HTTP请求和WebSockets，同时将每个请求委派给各自的＆＃34; { {3}}＆＃34; （例如，有HTTP请求的内置处理程序的船只，您可以为WebSockets编写自己的处理程序。）

Django Channels有一个名为consumers的概念，用于处理＆＃34;广播＆＃34;问题的本质;也就是说，它允许服务器上发生的事件向该组中的客户端触发消息，无论它们是否连接到相同或不同的进程或服务器。

恕我直言，Django频道很可能被抽象成一个更通用的Python库。有Groups couple other达到Python libraries但是，在撰写本文时，没有什么值得注意的提供网络透明度;通道在进程和服务器之间进行通信的能力。

如何跨多个服务器/工作人员管理websockets

3 个答案:

更新（2017年2月）

原始