RabbitMQ 简单使用教程
RabbitMQ 简单使用教程
安装
安装 RabbitMQ 服务
http://www.rabbitmq.com/install-standalone-mac.html
安装 Python RabbitMQ 模块
# 方式一
pip install pika
# 方式二
easy_install pika
# 方式三
# 源码
https://pypi.python.org/pypi/pika
实现简单队列通信
send端
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 声明 queue
channel.queue_declare(queue='hello')
# n RabbitMQ a message can never be sent directly to the queue, it always needs to go through an exchange.
# 一条消息永远不能直接发送到队列中，它总是需要经过一个交换。
channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')
print(" [x] Sent 'Hello World!'")
connection.close()
receive
#_*_coding:utf-8_*_
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# You may ask why we declare the queue again ‒ we have already declared it in our previous code.
# 你可能会问我们为什么要再次声明队列——我们已经在之前的代码中声明了它。
# We could avoid that if we were sure that the queue already exists. For example if send.py program was run before. But we're not yet sure which program to run first. In such cases it's a good practice to repeat declaring the queue in both programs.
# 如果我们确定队列已经存在，我们可以避免这种情况。 例如，如果 send.py 程序之前运行过。 但是我们还不确定首先运行哪个程序。 在这种情况下，最好在两个程序中重复声明队列。
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
channel.basic_consume(callback, queue='hello', no_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
远程连接rabbitmq server的话，需要配置权限
- 首先在rabbitmq server上创建一个用户
sudo rabbitmqctl add_user username password
同时还要配置权限，允许从外面访问
sudo rabbitmqctl set_permissions -p / username ".*" ".*" ".*"
set_permissions [-p vhost] {user} {conf} {write} {read}
vhost -- The name of the virtual host to which to grant the user access, defaulting to /.
-- 授予用户访问权限的虚拟主机的名称，默认为 /。
user -- The name of the user to grant access to the specified virtual host.
-- 授予对指定虚拟主机访问权限的用户名。
conf -- A regular expression matching resource names for which the user is granted configure permissions.
-- 授予用户配置权限的资源名称匹配的正则表达式。
write -- A regular expression matching resource names for which the user is granted write permissions.
-- 授予用户写入权限的资源名称匹配的正则表达式。
read -- A regular expression matching resource names for which the user is granted read permissions.
-- 授予用户读取权限的资源名称匹配的正则表达式。
认证
客户端连接的时候需要配置认证参数
credentials = pika.PlainCredentials('alex', 'alex3714')
connection = pika.BlockingConnection(pika.ConnectionParameters('10.211.55.5', 5672, '/', credentials))
channel = connection.channel()
Work Queues
在这种模式下，RabbitMQ 会默认把生产者（p）发的消息依次分发给各个消费者（c），跟负载均衡差不多
生产者
import pika
import time
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 声明 queue
channel.queue_declare(queue='task_queue')
# n RabbitMQ a message can never be sent directly to the queue, it always needs to go through an exchange.
# 一个消息永远不能直接发送到队列，它总是需要通过交换。
message = ' '.join(sys.argv[1:]) or "Hello World! %s" % time.time()
channel.basic_publish(
exchange='',
routing_key='task_queue',
body=message,
properties=pika.BasicProperties(
delivery_mode=2 # make message persistent
)
)
print(" [x] Sent %r" % message)
connection.close()
消费者
#_*_coding:utf-8_*_
import pika, time
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
time.sleep(20)
print(" [x] Done")
print("method.delivery_tag", method.delivery_tag)
ch.basic_ack(delivery_tag=method.delivery_tag)
channel.basic_consume(callback, queue='task_queue', no_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
此时，先启动消息生产者，然后再分别启动3个消费者，通过生产者多发送几条消息，你会发现，这几条消息会被依次分配到各个消费者身上.
Doing a task can take a few seconds. You may wonder what happens if one of the consumers starts a long task and dies with it only partly done. With our current code once RabbitMQ delivers message to the customer it immediately removes it from memory. In this case, if you kill a worker we will lose the message it was just processing. We'll also lose all the messages that were dispatched to this particular worker but were not yet handled.
完成一项任务可能需要几秒钟。 您可能想知道如果其中一个消费者开始一项长期任务并且只完成了部分任务而死去会发生什么。 使用我们当前的代码，一旦 RabbitMQ 将消息传递给客户，它就会立即将其从内存中删除。 在这种情况下，如果你杀死一个消费者，我们将丢失它刚刚处理的消息。 我们还将丢失所有发送给该特定消费者但尚未处理的消息。
But we don't want to lose any tasks. If a worker dies, we'd like the task to be delivered to another worker.
但是我们不想丢失任何任务。 如果一个消费者死亡，我们希望将任务交付给另一个消费者。
In order to make sure a message is never lost, RabbitMQ supports message acknowledgments. An ack(nowledgement) is sent back from the consumer to tell RabbitMQ that a particular message had been received, processed and that RabbitMQ is free to delete it.
为了确保消息永远不会丢失，RabbitMQ 支持消息确认。 消费者发回一个 ack(nowledgement) 来告诉 RabbitMQ 一个特定的消息已经被接收、处理并且 RabbitMQ 可以自由地删除它。
If a consumer dies (its channel is closed, connection is closed, or TCP connection is lost) without sending an ack, RabbitMQ will understand that a message wasn't processed fully and will re-queue it. If there are other consumers online at the same time, it will then quickly redeliver it to another consumer. That way you can be sure that no message is lost, even if the workers occasionally die.
如果消费者在没有发送 ack 的情况下死亡（其通道关闭、连接关闭或 TCP 连接丢失），RabbitMQ 将理解消息未完全处理并将重新排队。 如果同时有其他消费者在线，它会迅速将其重新发送给另一个消费者。 这样，即使消费者偶尔死亡，您也可以确保不会丢失任何消息。
There aren't any message timeouts; RabbitMQ will redeliver the message when the consumer dies. It's fine even if processing a message takes a very, very long time.
没有任何消息超时； 当消费者死亡时，RabbitMQ 将重新传递消息。 即使处理消息需要非常非常长的时间也没关系。
Message acknowledgments are turned on by default. In previous examples we explicitly turned them off via the no_ack=True flag. It's time to remove this flag and send a proper acknowledgment from the worker, once we're done with a task.
默认情况下启用消息确认。 在前面的示例中，我们通过
no_ack=True标志明确关闭它们。 一旦我们完成了一项任务，就删除这个标志并从消费者那里发送一个适当的确认。
def callback(ch, method, properties, body):
print " [x] Received %r" % (body,)
time.sleep( body.count('.') )
print " [x] Done"
ch.basic_ack(delivery_tag = method.delivery_tag)
channel.basic_consume(callback, queue='hello')
Using this code we can be sure that even if you kill a worker using CTRL+C while it was processing a message, nothing will be lost. Soon after the worker dies all unacknowledged messages will be redelivered
使用此代码，我们可以确定即使您在处理消息时使用 CTRL+C 杀死了一个消费者，也不会丢失任何内容。 消费者死亡后不久，所有未确认的消息将被重新传递.
消息持久化
We have learned how to make sure that even if the consumer dies, the task isn't lost(by default, if wanna disable use no_ack=True). But our tasks will still be lost if RabbitMQ server stops.
我们已经学会了如何确保即使消费者死亡，任务也不会丢失（默认情况下，如果要禁用使用 no_ack=True）。 但是如果 RabbitMQ 服务器停止，我们的任务仍然会丢失。
When RabbitMQ quits or crashes it will forget the queues and messages unless you tell it not to. Two things are required to make sure that messages aren't lost: we need to mark both the queue and messages as durable.
当 RabbitMQ 退出或崩溃时，它会丢失队列和消息，除非你告诉它不要这样做。 确保消息不会丢失需要做两件事：我们需要将队列和消息都标记为持久的。
First, we need to make sure that RabbitMQ will never lose our queue. In order to do so, we need to declare it as durable:
首先，我们需要确保 RabbitMQ 永远不会丢失我们的队列。 为此，我们需要将其声明为持久的：
channel.queue_declare(queue='hello', durable=True)
Although this command is correct by itself, it won't work in our setup. That's because we've already defined a queue called hello which is not durable. RabbitMQ doesn't allow you to redefine an existing queue with different parameters and will return an error to any program that tries to do that. But there is a quick workaround - let's declare a queue with different name, for exampletask_queue:
尽管此命令本身是正确的，但它在我们的设置中不起作用。 那是因为我们已经定义了一个名为 hello 的队列，它不是持久的。 RabbitMQ 不允许您使用不同的参数重新定义现有队列，并且会向任何尝试这样做的程序返回错误。 但是有一个快速的解决方法 - 让我们声明一个具有不同名称的队列，例如 task_queue：
channel.queue_declare(queue='task_queue', durable=True)
This queue_declare change needs to be applied to both the producer and consumer code.
此 queue_declare 更改需要同时应用于生产者和消费者代码。
At that point we're sure that the task_queue queue won't be lost even if RabbitMQ restarts. Now we need to mark our messages as persistent - by supplying a delivery_mode property with a value 2.
到那时，我们可以确定即使 RabbitMQ 重新启动，task_queue 队列也不会丢失。 现在我们需要将我们的消息标记为持久 - 通过提供值为 2 的 delivery_mode 属性。
channel.basic_publish(
exchange='',
routing_key="task_queue",
body=message,
properties=pika.BasicProperties(
delivery_mode = 2, # make message persistent(使消息持久化)
)
)
消息公平分发
如果 RabbitMQ 只管按顺序把消息发到各个消费者身上，不考虑消费者负载的话，很可能出现，一个机器配置不高的消费者那里堆积了很多消息处理不完，同时配置高的消费者却一直很轻松。为解决此问题，可以在各个消费者端，配置 perfetch=1，意思就是告诉 RabbitMQ 在我这个消费者当前消息还没处理完的时候就不要再给我发新消息了。
channel.basic_qos(prefetch_count=1)
带消息持久化 + 公平分发的完整代码
生产者端
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='task_queue', durable=True)
message = ' '.join(sys.argv[1:]) or "Hello World!"
channel.basic_publish(
exchange='',
routing_key='task_queue',
body=message,
properties=pika.BasicProperties(
delivery_mode = 2, # make message persistent
)
)
print(" [x] Sent %r" % message)
connection.close()
消费者端
#!/usr/bin/env python
import pika
import time
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='task_queue', durable=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
time.sleep(body.count(b'.'))
print(" [x] Done")
ch.basic_ack(delivery_tag=method.delivery_tag)
channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback, queue='task_queue')
channel.start_consuming()
Publish\Subscribe(消息发布\订阅)
之前的例子都基本都是 1 对 1 的消息发送和接收，即消息只能发送到指定的 queue 里，但有些时候你想让你的消息被所有的 Queue 收到，类似广播的效果，这时候就要用到 exchange 了。
An exchange is a very simple thing. On one side it receives messages from producers and the other side it pushes them to queues. The exchange must know exactly what to do with a message it receives. Should it be appended to a particular queue? Should it be appended to many queues? Or should it get discarded. The rules for that are defined by the exchange type.
交换是一件非常简单的事情。 一方面它接收来自生产者的消息，另一方面它将它们推送到队列中。 交换必须确切地知道如何处理它收到的消息。 是否应该将其附加到特定队列？它应该附加到许多队列中吗？ 或者它应该被丢弃。 其规则由交换类型定义。
Exchange 在定义的时候是有类型的，以决定到底是哪些 Queue 符合条件，可以接收消息
- fanout: 所有 bind 到此 exchange 的 queue 都可以接收消息
- direct: 通过 routingKey 和 exchange 决定的哪个唯一的 queue 可以接收消息
- topic:所有符合 routingKey（此时可以是一个表达式）的 routingKey 所 bind 的 queue 可以接收消息
表达式符号说明：# 代表一个或多个字符，* 代表任何字符
例：#.a 会匹配 a.a，aa.a，aaa.a等
*.a 会匹配 a.a，b.a，c.a等
注：使用 RoutingKey 为 #，Exchange Type 为 topic 的时候相当于使用 fanout - headers: 通过 headers 来决定把消息发给哪些 queue
消息 publisher
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs', type='fanout')
message = ' '.join(sys.argv[1:]) or "info: Hello World!"
channel.basic_publish(exchange='logs', routing_key='', body=message)
print(" [x] Sent %r" % message)
connection.close()
消息 subscriber
#_*_coding:utf-8_*_
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs', type='fanout')
# 不指定 queue 名字，rabbitMQ 会随机分配一个名字，exclusive=True 会在使用此 queue 的消费者断开后，自动将 queue 删除
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
channel.queue_bind(exchange='logs', queue=queue_name)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r" % body)
channel.basic_consume(callback, queue=queue_name, no_ack=True)
channel.start_consuming()
有选择的接收消息(exchange type=direct)
RabbitMQ 还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息 exchange，exchange 根据关键字判定应该将数据发送至指定队列。
发布
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs', exchange_type='direct')
severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='direct_logs', routing_key=severity, body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()
订阅
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs', exchange_type='direct')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
severities = sys.argv[1:]
if not severities:
sys.stderr.write("Usage: %s [info] [warning] [error]\n" % sys.argv[0])
sys.exit(1)
for severity in severities:
channel.queue_bind(exchange='direct_logs', queue=queue_name, routing_key=severity)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r:%r" % (method.routing_key, body))
channel.basic_consume(callback, queue=queue_name, no_ack=True)
channel.start_consuming()
更细致的消息过滤
Although using the direct exchange improved our system, it still has limitations - it can't do routing based on multiple criteria.
尽管使用直接交换改进了我们的系统，但它仍然有局限性——它不能基于多个标准进行路由。
In our logging system we might want to subscribe to not only logs based on severity, but also based on the source which emitted the log. You might know this concept from the syslog unix tool, which routes logs based on both severity (info/warn/crit...) and facility (auth/cron/kern...).
在我们的日志系统中，我们可能不仅要根据优先级订阅日志，还要根据发出日志的源来订阅。 您可能从 syslog unix 工具中知道这个概念，该工具根据严重性 (info/warn/crit...) 和设施 (auth/cron/kern...) 路由日志。
That would give us a lot of flexibility - we may want to listen to just critical errors coming from 'cron' but also all logs from 'kern'.
这会给我们很大的灵活性——我们可能只想监听来自“cron”的严重错误，也想监听来自“kern”的所有日志。
发布
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='topic_logs', exchange_type='topic')
routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='topic_logs', routing_key=routing_key, body=message)
print(" [x] Sent %r:%r" % (routing_key, message))
connection.close()
订阅
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='topic_logs', exchange_type='topic')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
binding_keys = sys.argv[1:]
if not binding_keys:
sys.stderr.write("Usage: %s [binding_key]...\n" % sys.argv[0])
sys.exit(1)
for binding_key in binding_keys:
channel.queue_bind(exchange='topic_logs', queue=queue_name, routing_key=binding_key)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r:%r" % (method.routing_key, body))
channel.basic_consume(callback, queue=queue_name, no_ack=True)
channel.start_consuming()
To receive all the logs run:
要接收所有日志，请运行：
python receive_logs_topic.py "#"
To receive all logs from the facility "kern":
接收所有“kern”日志：
python receive_logs_topic.py "kern.*"
Or if you want to hear only about "critical" logs:
或者，如果您只想了解“critical”日志：
python receive_logs_topic.py "*.critical"
You can create multiple bindings:
您可以创建多个绑定：
python receive_logs_topic.py "kern.*" "*.critical"
And to emit a log with a routing key "kern.critical" type:
并发出带有路由键“kern.critical”类型的日志：
python emit_log_topic.py "kern.critical" "A critical kernel error"
