RabbitMQ笔记

最新推荐文章于 2021-01-18 17:17:11 发布

BELL__Meng

最新推荐文章于 2021-01-18 17:17:11 发布

阅读量221

点赞数

分类专栏： Python 文章标签： rabbitmq

本文链接：https://blog.csdn.net/CARL__Meng/article/details/104207783

版权

Python 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

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

BELL__Meng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ笔记

RabbitMQ消息队列RabbitMQRabbitMQ简单使用概念简介五种工作模式1.简单模式2.工作模式(资源争抢)3.发布订阅(publish/fanout)4.路由模式(routing/direct)5.主题模式(topic)消息队列概念：消息队列（Message Queue，简称MQ）是一种跨进程、异步的通信机制，用于上下游传递消息。由消息系统来确保消息的可靠传递。主要用于不同进程P...
复制链接

扫一扫