RabbitMQ
RabbitMQ消息队列
消息队列
概念:消息队列(Message Queue,简称MQ)是一种跨进程、异步的通信机制,用于上下游传递消息。由消息系统来确保消息的可靠传递。主要用于不同进程Process/线程Thread之间通信。
适用场景:
- 上下游逻辑解耦、物理解耦
- 保证数据最终一致性
- 广播
- 错峰流控等
RabbitMQ
RabbitMQ是一个开源的,在AMQP基础上完成的,可复用的企业消息系统。由Erlang语言开发。
AMQP: Advanced Message Queue Protocol, 高级消息队列协议。它是应用层协议的一个开放标准,为面向消息的中间件设计,基于此协议的客户端与消息中间件可传递消息,并不受产品、开发语言等条件的限制。
RabbitMQ特点
可靠性(Relibility):
使用了一些机制来保证可靠性,比如持久化、传输确认、发布确认灵活的路由(Flexible Routing):
在消息进入队列之前,通过Exchanage来路由消息,对于典型的路由功能,Rabbit已经提供了一些内置的Exchange来实现。针对更复杂的路由功能,可以将多个Exchange绑定在一起,也可通过插件机制来实现自己的Exchange。消息集群(Clustering):
多个RabbitMQ服务器可以组成一个集群,行程一个逻辑的Broker。高可用(Highly Avaliable Queues):
队列可以在集群中的机器上进行镜像,使得在部分节点出问题的情况下队列仍然可用。多种协议(Multi-protocol):
支持多种消息队列协议,如,STOMP、MQTT等。多种语言客户端(Many Clients):
几乎支持多有常用语言,如,Java、Ruby等。管理界面(Management UI):
提供了易用的用户界面,使得用户可以监控和管理Broker的许多方面。跟踪机制(Tracing):
如果消息异常,RabbitMQ提供了消息的跟踪机制,使用者可以找出发生了什么。插件机制(Plugin System):
提供了许多插件,来从多方面进行扩展,也可以编辑自己的插件。
RabbitMQ简单使用
概念简介
Broker:
标识消息队列服务器实体Virtual Host:
虚拟主机。标识一批交换机、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个vhost本质上就是一个mini版的RabbitMQ服务器,拥有自己的队列、交换器、绑定和权限机制。vhost是AMQP概念基础,必须在链接时指定,RabbitMQ默认的vhost是/。Exchange:
交换器,用来接收生产者发送的消息并将这些消息路由给服务器中的队列。Queue:
消息队列,用来保存消息直到发送给消费者。它是消息容器,也是消息的终点。一个消息可以投入一个或多个队列。消息一直在队列里面,等待消费者连接到这个队列将其取走。Binding:
绑定,用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则,所以可以将交换器理解成一个由绑定构成的路由表。Channel:
信道,多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟链接,AMQP命令都是通过信道发送出去的,不管是发布消息、订阅队列还是接收消息这些动作都是通过信道完成的。因为对于操作系统来说,建立和销毁TCP都是非常昂贵的开销,所以引入了信道的概念,以复用一条TCP连接。Connection:
网络连接,比如一个TCP连接Publisher:
消息的生产者,也是一个向交换器发布消息的客户端应用程序。Consumer:
消息的消费者,表示一个从一个消息队列中取得的消息的客户端应用程序。Message:
消息,消息是不具名的,它是由消息头和消息体组成的。消息体是不透明的,而消息头则是由一系列的可选属性组成,这些属性包括routing-key(路由键)、priority(优先级)、delivery-mode(消息可能需要持久性存储)。
五种工作模式
1.简单模式
生产者将消息交给默认的交换器
交换器获取消息后交给绑定这个生产者的队列(挂你是通过队列名称完成的)
监听当前队列的消费者获取消息,执行消费逻辑。
应用场景:短信,聊天
2.工作模式(资源争抢)
- 生产者将消息交给交换器
- 交换器交给绑定队列
- 队列由多个消费者同时监听,只有其中一个能够获取这一条消息,形成了资源的争抢,谁的资源空闲大,谁争抢到的可能性就越大。
应用场景:抢红包,大型系统的资源调度
3.发布订阅(publish/fanout)
生产者将消息交给交换器
交换器根据自身的类型(fanout)将会把所有消息复制同步到所有与其绑定的队列
每个队列可以有一个消费者,接收消息,执行消费逻辑
应用场景:邮件群发,广告
工作模式和发布订阅模式的对比
区别:
- 工作模式不用定义交换器,而发布订阅模式不需要定义交换器
- 发布订阅模式的生产者是面向交换器发送消息,工作模式的生产者是面向队列发送消息(底层使用默认交换器)
- 发布订阅模式需要设置队列和交换器绑定,工作模式不需要设置,实质上工作模式会将队列绑定到默认交换器上。
相同点:
- 两者实现的发布/订阅的效果是一样的,多个消费监听同一个队列不会重复消费消息。
发布工作模式比工作模式更强大,并且发布订阅模式可以指定自己专用的交换器。
4.路由模式(routing/direct)
- 生产者将消息发送给交换器,消息携带具体的路由key(routing-key)
- 交换器类型direct,将接收到的消息中的routing-key,比对与之绑定的队列的routing-key
- 消费者监听一个队列,获取消息,执行消费逻辑
应用场景:根据生产者的要求发送给特定的一个或者一批队列,错误的通报
5.主题模式(topic)
- 生产者将消息发送给交换器,消息携带具体的路由key
- 交换机的类型topic
- 队列绑定交换机不在使用具体的路由key,而是一个范围值
和路由模式的区别:
路由模式中的queue绑定携带的是具体的key值,路由细化划分
topic主题模式queue携带的是范围的匹配,某一类的消息获取
RabbitMQ常用命令
- 查看所有消息队列:
rabbitmqctl list_queues
- 清除所有的队列:
rabbitmqctl reset
- 查看集群状态:
rabbitmqctl cluster_status
- 打印服务状态信息,包括内存,硬盘和使用erlang的版本:
rabbitmqctl -q status
- 添加用户:
rabbitmqctl add_user admin 123456
- 删除用户:
rabbitmqctl delete_user admin
- 修改密码:
rabbitmqctl change_password admin admin123
- 查看用户列表:
rabbitmqctl list_users
- 设置用户角色:
rabbitmqctl set_user_tags admin administrator [monitoring policymaker management]
- 添加权限:
rabbitmqctl set_permissions -p "/" username ".*" ".*" ".*"
- 查看用户权限:
rabbitmqctl list_permissions [-p VHostPath]
- 查看指定用户权限:
rabbitmqctl list_user_permissions admin
- 清除用户权限:
rabbitmqctl clear_permissions [-p VHostPath] admin
Python操作RabbitMQ
配置远程连接用户
-
添加root用户并设置密码,
rabbitmqctl add_user root 123
-
添加root用户未administrator角色,
rabbitmqctl set_user_tags root administrator
-
设置root用户的权限,指定允许访问的vhost以及write/read,
rabbitmqctl set_premissions -p "/" root ".*" ".*" ".*"
-
查看vhost(/)允许哪些用户访问,
rabbitmqctl list_permissions -p /
-
配置允许远程访问的用户,RabbitMQ的guest用户默认不允许远程主机访问。
vim /etc/rabbitmq/rabbitmq.config
修改[{rabbit, [{loopback_users, [“root”]}]}].
-
重启RabbitMQ
RabbitMQ默认端口5672,web管理端口15672
启动命令:
- rabbitmq-server(前台启动)
- rabbitmq-server -detached(后台启动)
简单使用
生产者producer
import pika
username = "root"
password = "123"
usr_pwd = pika.PlainCredentials(username, password) # 配置远程连接的用户名和密码
# 创建一个连接实例
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明一个管道,在管道里收发消息
channel = connection.channel()
# 在管道里声明队列
channel.queue_declare(queue='abc')
channel.basic_publish(exchange='',
routing_key='abc', # 队列名称
body='Hello World!') # 消息内容
print("[x] Sent 'Hello World!'")
connection.close() # 关闭连接
消费者consumer
import pika
username = "root"
password = "123"
usr_pwd = pika.PlainCredentials(username, password)
# 创建连接实例
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明管道
channel = connection.channel()
# 如果确定已经声明过这个队列,可以不声明
channel.queue_declare(queue='abc') # 如果队列没有创建,就创建这个队列
def callback(ch, method, propertities, body):
print(" [x] Received %r" % body)
# 消费消息
channel.basic_consume('abc', # 要从哪个队列接收消息
callback, # 接收到消息就使用callback函数来处理消息
True)
print(' [*] Waiting for message. To exit press CTRL+C')
# 执行消费逻辑
channel.start_consuming()
上面例子当有多个消费者的时候,将会采用轮询机制
当在
basic_consume()
之前加上channel.basic_qos(prefetch_count=1)
时,就表示如果你有一个消息,就不再给你发送。
消息持久化
如果队列里还有消息,当服务端宕机时,按照上述代码,消息就会丢失,队列也会丢失。
为了使消息持久化,每次声明队列的时候,都要加上durable。(客户端,服务端声明的时候都得写)
channel.queue_declare(queue='abc', durable=True)
但这样只是把队列持久化了,队列里的消息并没有持久化。为了让队列中的消息持久化,在发送消息的时候,需要加上properties。
channel.basic_publish(exchange='',
routing_key='abc', # 队列名称
body='Hello World!', # 消息内容
properties=pika.BasicProperties(
delivery_mode=2, # 使消息持久化
)
)
RabbitMQ广播模式
要实现广播效果,就必须使用到exchange。
共有以下几种类型:
- fanout:所有绑定到此exchange的queue都可以接收消息
- direct:通过routing-key和exchange决定哪个唯一的queue可以接收消息
- topic:所有符合routing-key(可以是表达式)的routing-key所绑定的queue可以接收消息。
fanout纯广播
需要queue和exchange绑定,因为消费者不是和exchange直连的,消费者连在queue上,queue绑定在exchange上,消费者从queue里读消息。
fanout_producer
import pika
usr_pwd = pika.PlainCredentials("root", "123")
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明管道
channel = connection.channel()
channel.exchange_declare(exchange="logs", exchange_type='fanout')
message = "info: Hello World!"
channel.basic_publish(exchange="logs", routing_key="", body=message)
print("[x] Sent %r" % message)
connection.close()
fanout_consumer
import pika
usr_pwd = pika.PlainCredentials("root", "123")
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明管道
channel = connection.channel()
channel.exchange_declare(exchange="logs", exchange_type="fanout")
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(queue_name,
callback,
True)
channel.start_consuming()
广播是实时的,收不到就没有了,消息不会存下来,类似收音机
direct
接受者只接收自己想要接收的类型消息。
publisher
import pika, sys
usr_pwd = pika.PlainCredentials("root", "123")
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明管道
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs',
exchange_type='direct')
# 重要程度级别,这里默认定义为 info
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()
subscriber
import pika, sys
usr_pwd = pika.PlainCredentials("root", "123")
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明管道
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(queue_name,
callback,
True)
channel.start_consuming()
运行接收端时,指定接收级别的参数,如:
python direct_subscriber.py info warning
topic
更细致的过滤要接收的消息类型。
publisher
import pika, sys
usr_pwd = pika.PlainCredentials("root", "123")
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明管道
channel = connection.channel()
channel.exchange_declare(exchange='topic_logs',
exchange_type='topic')
routing_key = sys.argv[1] if len(sys.argv) > 1 else 'test.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()
subscriber
import pika, sys
usr_pwd = pika.PlainCredentials("root", "123")
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='x.x.x.x', port=5672, virtual_host="/", credentials=usr_pwd))
# 声明管道
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(queue_name,
callback,
True)
channel.start_consuming()
python topic_subscriber.py *.info
python topic_subscriber.py *.error mysql.*
python topic_subscriber.py #
#表示接收所有消息
部分参考自:https://blog.csdn.net/fgf00/article/details/52872730
https://blog.csdn.net/hellozpc/article/details/81436980