RabbitMQ tutorial

一、安装RabbitMQ

RabbitMQ是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang 写成。

所以我们要先安装Erlang

Erlang：http://www.erlang.org/downloads

RabbitMQ：https://www.rabbitmq.com/download.html

还可以启动一个后台插件，运行命令

rabbitmq-plugins enable rabbitmq_management

可以通过浏览器访问后台管理页面，默认账户密码: guest/guest

二、简单队列

我们只需要创建一个队列 往里面送一个消息  然后在取出他  多么简单的需求。let`s do it !!!

import pika

# 建立连接
conn = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1',port=5672))
# 建立管道
channel = conn.channel()

# 创建hello消息队列
channel.queue_declare(queue='hello')

# 在RabbitMQ中信息不能直接被发送到队列,它需要通过一个 exchange
# 现在我们只需要知道如何使用由默认的exchange
# routing_key 指定要通信的队列
channel.basic_publish(exchange='',routing_key='hello',body='Hello World!')
print("---- Sent 'Hello World!' -----")

# 在退出程序之前,我们需要确保网络缓冲区已被刷新.
# 并且我们的消息实际上已传递到RabbitMQ,我们可以轻轻地关闭连接.
conn.close()

output

---- Sent 'Hello World!' -----

如果你没看到这条信息，可能的原因之一是你的磁盘空间剩余不多了，最少需要200mb你才能正常运行它。

好了现在可以让我们来取回消息队列中的信息了。

import pika

# 建立连接
conn = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1',port=5672))
# 建立管道
channel = conn.channel()
# 你可能疑惑为什么再建立一次队列，因为通常这么做可以保证队列一定被创建了
# 通常是多个程序访问一个队列，我们不知道他们哪个可能先跑起来
channel.queue_declare(queue='hello')

# 定义一个回调函数，从队列中收到信息后调用它
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

channel.basic_consume(queue='hello',auto_ack=True,on_message_callback=callback)

while True:
    print(' [*] Waiting for messages. To exit press CTRL+C')
    channel.start_consuming()

output

[*] Waiting for messages. To exit press CTRL+C
[x] Received b'Hello World!'

此时再看消息队列的状况，这回用命令行来看

rabbit list_queues

output

Timeout: 60.0 seconds ...
Listing queues for vhost / ...
name    messages
hello   0

消息从队列中被取出，就是pop出来了，所以消息队列里的messages已经空了。

三、work模式

上面的简单队列是简单的 一个生产者，一个消费者的模型。而通常我们可能有很多个消费者，就考虑了竞争的元素，一个进程向队列发布消息，多个进程从队列获取消息，而消息是唯一的。

简单的改变一下前面的代码

producer.py

import pika
import time
conn = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', port=5672))
channel = conn.channel()
channel.queue_declare(queue='hello')
print("---- Sent 'Hello World!' -----")

for i in range(100):
    message = str(i) + ' msg is sent'
    channel.basic_publish(exchange='',routing_key='hello', body=message)
    print(" [x] Sent %r" % message)
    time.sleep(1)

worker.py

import pika

conn = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1', port=5672))
channel = conn.channel()
channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

channel.basic_consume(queue='hello',auto_ack=True,on_message_callback=callback)

while True:
    print(' [*] Waiting for messages. To exit press CTRL+C')
    channel.start_consuming()

再shell 1里面启动一个worker， shell 2里面再启动一个worker，   shell 3 启动producer来观察一下

# shell 3
 [x] Sent '0msg is sent'　　　　　　　　　　　　　　　　　　
 [x] Sent '1msg is sent'
 [x] Sent '2msg is sent'
 [x] Sent '3msg is sent'
 [x] Sent '4msg is sent'
 [x] Sent '5msg is sent'
 [x] Sent '6msg is sent'
 [x] Sent '7msg is sent'
 [x] Sent '8msg is sent'
 [x] Sent '9msg is sent'
 [x] Sent '10msg is sent'
....

# shell 1
 [*] Waiting for messages. To exit press CTRL+C
 [x] Received b'0msg is sent'
 [x] Received b'2msg is sent'
 [x] Received b'4msg is sent'
 [x] Received b'6msg is sent'
 [x] Received b'8msg is sent'
 [x] Received b'10msg is sent'

# shell 2
 [*] Waiting for messages. To exit press CTRL+C
 [x] Received b'1msg is sent'
 [x] Received b'3msg is sent'
 [x] Received b'5msg is sent'
 [x] Received b'7msg is sent'
 [x] Received b'9msg is sent'

默认情况下，RabbitMQ将按顺序将每个消息发送给下一个使用者。平均每个消费者将得到相同数量的消息。这种分发消息的方式称为round-robin。可以自行尝试让三个或更多的员工来工作。

消息确认

通常情况下，进程处理完一个消息可能需要一些时间。您可能想知道，如果其中一个消费者启动了一个很长的任务，但只完成了一部分就挂掉了，会发生什么情况。使用我们当前的代码，一旦RabbitMQ将消息传递给消费者，它立即将其标记为删除。在这种情况下，如果您杀死一个工作中的进程，我们将丢失它正在处理的消息。我们还将丢失发送给这个特定工作人员但尚未处理的所有消息。但我们不想失去任何任务。如果一个进程崩溃了，我们希望把任务交给另一个进程。

为了确保消息永远不会丢失，RabbitMQ支持消息确认。使用者返回一个ack(nowledgement)，告诉RabbitMQ已经接收、处理了一条特定的消息，并且RabbitMQ可以自由地删除它。如果使用者在不发送ack的情况下死亡(其通道关闭、连接关闭或TCP连接丢失)，RabbitMQ将理解消息没有被完全处理，并将重新排队。如果同时有其他消费者在线，它会很快将其重新发送给另一个消费者。这样你可以确保没有信息丢失，即使工人偶尔死亡。没有任何消息超时;当使用者死亡时，RabbitMQ将重新传递消息。即使处理一条消息需要非常、非常长的时间，也没关系。默认情况下，将打开手动消息确认。在前面的示例中，我们通过 auto_ack=True 标志显式地关闭了它们。一旦我们完成了一个任务，就应该删除这个标志并从worker那里发送一个适当的确认。

稍微改变一下worker.py的代码

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    time.sleep(5)
    print(" [x] Done")
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_consume(queue='hello', on_message_callback=callback)

发布一串消息后再运行worker.py

 [*] Waiting for messages. To exit press CTRL+C
 [x] Received b'0msg is sent'
 [x] Done
 [x] Received b'1msg is sent'

此时 1msg is sent已经收到但没完成处理，来看一下队列里它还在不在

成功的保留下来了没有处理完的结果。

消息的耐久性

我们已经学会了如何确保即使用户死亡，任务也不会丢失。但是，如果RabbitMQ服务器停止，我们的任务仍然会丢失。当RabbitMQ退出或崩溃时，它将忘记队列和消息，除非您告诉它不要这样做。确保消息不会丢失需要做两件事:我们需要将队列和消息都标记为持久的。首先，我们需要确保RabbitMQ永远不会丢失我们的队列。为了做到这一点，我们需要配置它:

channel.queue_declare(queue='hello', durable=True)

虽然这个命令本身是正确的，但是它在我们的设置中不能工作。这是因为我们已经定义了一个名为hello的队列，它不是持久的。RabbitMQ不允许您使用不同的参数重新定义现有队列，并且将向任何试图这样做的程序返回一个错误。但是有一个快速的解决方案——让我们声明一个不同名称的队列。例如new_queue:

channel.queue_declare(queue='new_queue', durable=True)

同时还需要改变worker.py中的代码，我们需要将消息标记为persistent—通过提供一个值为2的delivery_mode属性。

channel.basic_publish(exchange='',
                      routing_key="new_queue",
                      body=message,
                      properties=pika.BasicProperties(
                         delivery_mode = 2, # make message persistent
                      ))

将消息标记为持久性并不能完全保证消息不会丢失。虽然它告诉RabbitMQ将消息保存到磁盘，但是当RabbitMQ接受了一条消息并且还没有保存它时，仍然有一个短时间窗口。此外，RabbitMQ不会对每条消息执行fsync(2)——它可能只是保存到缓存中，而不是真正写到磁盘上。持久性保证并不强，但对于我们的简单任务队列来说已经足够了。如果需要更强的保证，可以使用publisher confirm

公平分发

您可能已经注意到，分派仍然不能完全按照我们希望的方式工作。例如，在两个工人的情况下，当所有奇数的消息处理很慢，而偶数消息处理很快，一个工人会一直很忙，而另一个工人几乎不做任何工作。好吧，RabbitMQ对此一无所知，仍然会均匀地分发消息。这是因为RabbitMQ只在消息进入队列时发送消息。它不会查看消费者未确认的消息的数量。它只是盲目地将第n条消息发送给第n个消费者。

解决方法很简单，设置为prefetch_count=1的qos方法。这告诉RabbitMQ一次不要向工作人员发送一条以上的消息。或者，换句话说，在工作人员处理并确认前一条消息之前，不要向其发送新消息。相反，它将把它发送给下一个不太忙的工人。

channel.basic_qos(prefetch_count=1)

四、订阅模式

exchange

RabbitMQ消息传递模型的核心思想是，生产者永远不会将任何消息直接发送到队列。实际上，通常生产者甚至不知道消息是否会被传递到任何队列。相反，生产者只能向交换器发送消息。exchange是一件非常简单的事情。一边接收来自生产者的消息，另一边将消息推送到队列。exchange必须确切地知道如何处理它接收到的消息。它应该被附加到一个特定的队列中吗?它应该添加到许多队列中吗?或者它应该被丢弃。这些规则由exchange类型定义。

有几种可用的exchange类型:direct、topic、header和fanout。我们将关注最后一个——fanout。让我们创建一个这种类型的exchange,并命名为radio.

channel.exchange_declare(exchange='radio', exchange_type='fanout')

fanout 非常简单。它是将接收到的所有消息广播给它所知道的所有队列。这正是我们需要的记录器

现在我们需要告诉exchange向队列发送消息。exchange和队列之间的关系称为绑定。

channel.queue_bind(exchange='radio',queue=result.method.queue)

之后由它发布的信息，所有被绑定的消息队列都会接收到消息。让我们来看看完整的示例

import pika

connection = pika.BlockingConnection(
    pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
# 创建exchange radio
channel.exchange_declare(exchange='radio', exchange_type='fanout')

# 创建消息队列radio1 radio2
radio1 = channel.queue_declare(queue='radio1')
radio2 = channel.queue_declare(queue='radio2')

# 绑定radio与 radio1 radio2
channel.queue_bind(exchange='radio',queue=radio1.method.queue)
channel.queue_bind(exchange='radio',queue=radio2.method.queue)

message = 'xxx msg is sent'
channel.basic_publish(exchange='radio', routing_key='', body=message)
print(" [x] Sent %r" % message)

connection.close()

来看看消息队列中的情况

两个消息队列都收到了信息。 来自名为radio的exchange的数据转到两个具有服务器指定名称的队列。这正是我们想要的。

五、选择性的发送信息

有时候我们希望可以对绑定关系做出一些约束，如产生的日志信息，c1进程只获得error信息，而c₂进程可以收到info，erro，warning

只需要在绑定关系时，指定routing_key就可以了。

channel.queue_bind(exchange='log',queue='c1', routing_key=key)

发布消息时也指定routing_key

channel.basic_publish(exchange='log', routing_key='ERROR', body='message')

这样exchange就会根据绑定关系和routing_key来发往对应的消息队列

完整展示

import pika

log_level = ['INFO','DEBUG','WARNING','ERROR']
conn = pika.BlockingConnection(pika.ConnectionParameters(host='127.0.0.1'))
channel = conn.channel()
channel.exchange_declare(exchange='log', exchange_type='direct')
channel.queue_declare(queue='c1')
channel.queue_declare(queue='c2')

channel.queue_bind(exchange='log',queue='c1', routing_key=log_level[0])
channel.queue_bind(exchange='log',queue='c1', routing_key=log_level[1])
channel.queue_bind(exchange='log',queue='c1', routing_key=log_level[2])
channel.queue_bind(exchange='log',queue='c1', routing_key=log_level[3])
channel.queue_bind(exchange='log',queue='c2', routing_key=log_level[3])

e_msg = 'Error, move move'
w_msg = 'WARNING,ok, work on'
channel.basic_publish(exchange='log', routing_key=log_level[3], body=e_msg)
print(" [x] Sent %r:%r" % ('Error', e_msg))

channel.basic_publish(exchange='log', routing_key=log_level[2], body=w_msg)
print(" [x] Sent %r:%r" % ('Error',w_msg))

conn.close()

后台可以看到我们的绑定关系，来看看结果。

按规则模式匹配

可能还不够，如果我想让他按规则匹配，然后我的规则又有一定逻辑关系而且很多怎么办。我们可以用topic类型的exchange

channel.exchange_declare(exchange='topic_logs', exchange_type='topic')

这里用官方的图

将routing_key设置为quick.orange.rabbit的消息，将被发送到两个队列。消息lazy.orange.elephant。也会去他们两个。另一方面，quick.orange.fox只会去第一个队列，lazy.brown.fox,只会去第二个。lazy.pink.rabbit将只被传递到第二个队列一次，即使它匹配两个绑定。

像quick.orange.male.rabbit和orange不会发向任何一个队列。