连接到两台 RabbitMQ 服务器

Question

我将 python 与pika一起使用，并且有以下两个类似的用例：

1. 连接到 RabbitMQ 服务器 A 和服务器 B（在具有不同凭据的不同 IP 地址），监听服务器 A 上的交换 A1； 当消息到达时，对其进行处理并发送到服务器 B 上的交换器
2. 打开一个HTTP监听器并连接到RabbitMQ服务器B； 当特定的 HTTP 请求到达时，处理它并发送到服务器 B 上的交换

唉，在这两种情况下，使用我常用的技术，当我发送到服务器 B 时，连接会抛出ConnectionClosed或ChannelClosed 。

我认为这是原因：在等待传入消息时，与服务器 B（其“驱动程序”）的连接缺乏 CPU 周期，并且它永远没有机会服务连接套接字，因此它无法响应来自服务器 B 的心跳，因此服务器关闭了连接。

但我无法解决这个问题。 我目前的工作很糟糕：我抓住了ConnectionClosed ，重新打开与服务器 B 的连接，然后重试发送我的消息。

但是这样做的“正确”方法是什么？ 我已经考虑过这些，但真的不觉得我有解决这个问题的所有部分：

• 不要只是永远坐在服务器 A 的basic_consume （我通常的模式）中，而是使用超时，当我以某种方式捕获超时时，服务器 B 的驱动程序上的“服务”心跳，然后返回到“超时消费”。 .但我该怎么做呢？ 如何“让服务 B 的连接驱动程序为其心跳服务”？
• 我知道套接字库的select()调用可以等待几个 sockets 上的消息，然后为等待数据包的套接字提供服务。 所以也许这就是 pika 的SelectConnection的用途？ a) 我不确定，这只是一种预感。 b）即使是对的，虽然我可以找到如何创建此连接的示例，但我找不到如何使用它来解决我的多连接案例的示例。
• 在不同的进程中设置两个服务器连接......并使用 Python 进程间队列将处理后的消息从一个进程获取到下一个进程。 这个概念是“两个不同的进程中的两个不同的 RabbitMQ 连接因此应该能够独立地为它们的心跳提供服务”。 除了...我认为这有一个致命的缺陷：相反，带有“服务器 B”的进程将“卡住”在进程间队列上等待，并且会发生同样的“饥饿”。

昨晚我检查了 StackOverflow 并在 Google 上搜索了一个小时：我一生都找不到博客文章或示例代码。

有输入吗？ 太感谢了

Answer 1

我设法解决了这个问题，我的解决方案基于文档和pika-python Google group 中的答案。

首先，您的假设是正确的——连接到服务器 B 的客户端进程负责发布，如果它已经阻塞其他事情，例如等待来自服务器 A 的消息或阻塞内部通信队列，则无法回复心跳。

解决方案的关键是发布者应该作为一个单独的线程运行，并使用BlockingConnection.process_data_events来服务心跳等。 看起来该方法应该在一个循环中调用，以检查发布者是否仍需要运行：

def run(self):
    while self.is_running:
        # Block at most 1 second before returning and re-checking
        self.connection.process_data_events(time_limit=1)

概念证明

由于证明完整的解决方案需要运行两个单独的 RabbitMQ 实例，因此我将 Git 存储库与适当的docker-compose.yml 、应用程序代码和注释放在一起以测试此解决方案。

https://github.com/karls/rabbitmq-two-connections

解决方案大纲

下面是解决方案的草图，减去进口等。 一些值得注意的事情：

1. Publisher作为单独的线程运行
2. 发布者所做的唯一“工作”是通过Connection.process_data_events为心跳等服务
3. 每当消费者想要发布消息时，发布者都会使用Connection.add_callback_threadsafe注册回调
4. 消费者将发布者作为构造函数参数，因此它可以发布它收到的消息，但只要您有对Publisher实例的引用，它就可以通过任何其他机制工作
5. 该代码取自链接的 Git 存储库，这就是为什么某些细节被硬编码的原因，例如队列名称等。它将适用于所需的任何 RabbitMQ 设置（直接到队列、主题交换、扇出等）。

class Publisher(threading.Thread):
    def __init__(
        self,
        connection_params: ConnectionParameters,
        *args,
        **kwargs,
    ):
        super().__init__(*args, **kwargs)
        self.daemon = True
        self.is_running = True
        self.name = "Publisher"
        self.queue = "downstream_queue"
        self.connection = BlockingConnection(connection_params)
        self.channel = self.connection.channel()
        self.channel.queue_declare(queue=self.queue, auto_delete=True)
        self.channel.confirm_delivery()

    def run(self):
        while self.is_running:
            self.connection.process_data_events(time_limit=1)

    def _publish(self, message):
        logger.info("Calling '_publish'")
        self.channel.basic_publish("", self.queue, body=message.encode())

    def publish(self, message):
        logger.info("Calling 'publish'")
        self.connection.add_callback_threadsafe(lambda: self._publish(message))

    def stop(self):
        logger.info("Stopping...")
        self.is_running = False

        # Wait ~2s before continuing with shutdown because
        # we need to wait for `self.connection.process_data_events`
        # to finish processing and return cleanly.
        #
        self.connection.sleep(2)

        if self.connection.is_open:
            self.connection.close()
            logger.info("Connection closed")
        logger.info("Stopped")


class Consumer:
    def __init__(
        self,
        connection_params: ConnectionParameters,
        publisher: Optional["Publisher"] = None,
    ):
        self.publisher = publisher
        self.queue = "upstream_queue"
        self.connection = BlockingConnection(connection_params)
        self.channel = self.connection.channel()
        self.channel.queue_declare(queue=self.queue, auto_delete=True)
        self.channel.basic_qos(prefetch_count=1)

    def start(self):
        self.channel.basic_consume(
            queue=self.queue, on_message_callback=self.on_message
        )
        try:
            self.channel.start_consuming()
        except KeyboardInterrupt:
            logger.info("Warm shutdown requested...")
        except Exception:
            traceback.print_exception(*sys.exc_info())
        finally:
            self.stop()

    def on_message(self, _channel: Channel, m, _properties, body):
        try:
            message = body.decode()
            logger.info(f"Got: {message!r}")
            if self.publisher:
                self.publisher.publish(message)
            else:
                logger.info(f"No publisher provided, printing message: {message!r}")
            self.channel.basic_ack(delivery_tag=m.delivery_tag)
        except Exception:
            traceback.print_exception(*sys.exc_info())
            self.channel.basic_nack(delivery_tag=m.delivery_tag, requeue=False)

    def stop(self):
        logger.info("Stopping consuming...")
        if self.connection.is_open:
            logger.info("Closing connection...")
            self.connection.close()

        if self.publisher:
            self.publisher.stop()

        logger.info("Stopped")