为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 RabbitMQ入门：新手指南与实用教程

RabbitMQ入门：新手指南与实用教程

标签：
中间件
概述

RabbitMQ入门介绍了RabbitMQ的基本概念、主要特点和优势，涵盖了RabbitMQ的安装与配置方法，以及核心概念和消息路由模型。文章还提供了常用的RabbitMQ操作示例和常见问题的解决方案。

RabbitMQ简介

RabbitMQ 是一个开源的消息代理和队列实现，它使用 AMQP (Advanced Message Queuing Protocol) 作为其标准消息传递协议。RabbitMQ 的设计原则是简单、可伸缩和高度可用，支持多种编程语言，包括 Java、Python、Node.js 和 Go 等，能够方便地集成到不同的系统中。

RabbitMQ的主要特点和优势
  • 异步通信：通过解耦生产者和消费者，实现了异步通信，提高了系统的解耦度和灵活性。
  • 消息队列：通过使用消息队列，可以实现消息的可靠传递和持久化，确保消息不丢失。
  • 负载均衡：可以将消息分布到多个消费者，实现负载均衡。
  • 持久性：支持消息的持久化存储，即使在服务器崩溃后，消息仍然可以恢复。
  • 多种路由模式：支持多种消息路由模式（Direct、Topic、Fanout、Headers），以满足不同应用场景的需求。
  • 扩展性：支持水平和垂直扩展，能够应对高并发和大数据量的场景。
  • 监控与管理：提供了丰富的监控和管理工具，方便运维人员进行监控和故障排查。
RabbitMQ安装与配置
安装环境准备

在安装 RabbitMQ 之前，需要确保你的系统符合以下要求：

  • 支持的操作系统：Windows、Linux、macOS
  • 内存：建议至少 1GB RAM，具体取决于消息量和并发量。
  • 磁盘空间：建议至少有 1GB 空间用于存储消息，具体取决于消息量和持久化策略。
  • 网络：确保 RabbitMQ 服务器能够访问网络，并且网络延迟较低。
RabbitMQ的安装步骤

以 Linux 系统为例，安装步骤如下：

  1. 安装 Erlang：RabbitMQ 是基于 Erlang 语言开发的，因此需要先安装 Erlang。

    # 添加 Erlang 的官方仓库
sudo apt-get update
sudo apt-get install apt-transport-https
wget https://packages.erlang-solutions.com/ubuntu/erlang_solutions.asc
sudo apt-key add erlang_solutions.asc
echo "deb https://packages.erlang-solutions.com/ubuntu $(lsb_release -sc) stable" | sudo tee /etc/apt/sources.list.d/erlang_solutions.list
sudo apt-get update
sudo apt-get install erlang

# 安装 RabbitMQ
sudo apt-get install rabbitmq-server

  2. 启动 RabbitMQ 服务：

    sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server
sudo systemctl status rabbitmq-server

  3. 配置 RabbitMQ：

    sudo rabbitmq-plugins enable rabbitmq_management
sudo systemctl restart rabbitmq-server

    启动后，可以通过浏览器访问 http://<服务器IP>:15672 来查看 RabbitMQ 的管理界面，默认用户名和密码都是 guest。

  4. 防火墙配置：
    如果服务器启用了防火墙，需要开放 RabbitMQ 的端口（默认是 5672 和 15672）。 
    sudo ufw allow 5672
sudo ufw allow 15672
sudo ufw reload
RabbitMQ的基本配置方法

RabbitMQ 的配置可以通过修改配置文件来完成，配置文件通常位于 /etc/rabbitmq/ 目录下。以下是一些常用的配置项：

  • 配置文件路径：/etc/rabbitmq/rabbitmq.conf

  • 设置默认用户名和密码：

    sudo rabbitmqctl change_password guest newpassword

  • 配置持久化存储：
    修改 /etc/rabbitmq/rabbitmq.conf 文件，添加以下配置：

    rabbitmq.conf
[
{kernel, [
  {disk_free_limit, 50000000} % 50MB
]}
]

  • 启用或禁用插件：

    sudo rabbitmq-plugins enable <插件名称>
sudo rabbitmq-plugins disable <插件名称>
  • 配置虚拟主机和用户权限： 
    sudo rabbitmqctl add_vhost my_vhost
sudo rabbitmqctl add_user myuser mypassword
sudo rabbitmqctl set_permissions -p my_vhost myuser ".*" ".*" ".*"
RabbitMQ核心概念
交换器（Exchange）

交换器是消息传递的核心组件，负责接收生产者发送的消息并将其路由到一个或多个队列。交换器根据类型分为 Direct、Topic、Fanout 和 Headers 四种。

  • Direct：根据消息的路由键（Routing Key）将消息路由到匹配的队列。
  • Topic：使用通配符模式匹配消息的路由键。
  • Fanout：将消息广播到所有绑定的队列。
  • Headers：基于消息头的属性进行路由。
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='my_queue', durable=True) # 持久化队列

channel.close()
connection.close()
队列（Queue）

队列是消息的存储容器，负责缓存消息并将其分发给消费者。队列可以持久化，确保消息不会因服务器重启而丢失。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='my_queue', durable=True) # 持久化队列

channel.close()
connection.close()
消息（Message）

消息是交换器从生产者接收并发送到队列的数据单元。消息需要指定一个路由键，以便交换器将其路由到正确的队列。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.basic_publish(exchange='',
                      routing_key='my_queue',
                      body='Hello, World!',
                      properties=pika.BasicProperties(
                          delivery_mode=pika.spec.PERSISTENT_DELIVERY_MODE # 持久化消息
                      ))

connection.close()
绑定（Binding）

绑定是将交换器与队列关联起来的行为。绑定允许消息从交换器路由到队列。通过绑定，交换器可以将消息传递给多个队列。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_bind(exchange='my_exchange',
                   queue='my_queue',
                   routing_key='my_routing_key')

connection.close()
RabbitMQ消息路由模型
直连模型（Direct）

直连模型是最简单的一种模型，它将消息直接路由到具有匹配路由键的队列。以下是一个简单的直连模型示例：

# 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                         exchange_type='direct')

channel.basic_publish(exchange='direct_exchange',
                      routing_key='direct_key',
                      body='Direct Message')

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                         exchange_type='direct')

channel.queue_declare(queue='direct_queue')

channel.queue_bind(exchange='direct_exchange',
                   queue='direct_queue',
                   routing_key='direct_key')

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

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

channel.start_consuming()
主题模型（Topic）

主题模型允许使用通配符模式匹配路由键，实现更为灵活的消息路由。以下是一个简单的主题模型示例：

# 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

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

channel.basic_publish(exchange='topic_exchange',
                      routing_key='topic.*',
                      body='Topic Message')

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

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

channel.queue_declare(queue='topic_queue')

channel.queue_bind(exchange='topic_exchange',
                   queue='topic_queue',
                   routing_key='topic.*')

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

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

channel.start_consuming()
扇出模型（Fanout）

扇出模型将消息广播到所有绑定的队列，实现了消息的广播功能。以下是一个简单的扇出模型示例：

# 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

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

channel.basic_publish(exchange='fanout_exchange',
                      routing_key='',
                      body='Fanout Message')

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

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

channel.queue_declare(queue='fanout_queue_1')
channel.queue_declare(queue='fanout_queue_2')

channel.queue_bind(exchange='fanout_exchange',
                   queue='fanout_queue_1')
channel.queue_bind(exchange='fanout_exchange',
                   queue='fanout_queue_2')

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

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

channel.start_consuming()
通配符模型（Headers）

通配符模型允许使用消息头（Headers）进行路由，提供了一种更为灵活的路由机制。以下是一个简单的通配符模型示例：

# 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='headers_exchange',
                         exchange_type='headers')

channel.basic_publish(exchange='headers_exchange',
                      routing_key='',
                      body='Headers Message',
                      properties=pika.BasicProperties(
                          headers={'header1': 'value1', 'header2': 'value2'}
                      ))

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='headers_exchange',
                         exchange_type='headers')

channel.queue_declare(queue='headers_queue')

channel.queue_bind(exchange='headers_exchange',
                   queue='headers_queue',
                   arguments={'x-match': 'all', 'header1': 'value1', 'header2': 'value2'})

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

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

channel.start_consuming()
RabbitMQ常用操作示例
发送和接收消息

发送和接收消息是 RabbitMQ 的基本功能，以下是一个简单的发送和接收消息的示例：

# 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                         exchange_type='direct')

channel.basic_publish(exchange='direct_exchange',
                      routing_key='direct_key',
                      body='Direct Message')

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                         exchange_type='direct')

channel.queue_declare(queue='direct_queue')

channel.queue_bind(exchange='direct_exchange',
                   queue='direct_queue',
                   routing_key='direct_key')

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

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

channel.start_consuming()
消息确认和持久化

消息确认机制可以确保消息被正确接收，持久化可以保证消息不丢失。以下是一个使用消息确认和持久化的示例：

# 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                         exchange_type='direct')

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

channel.basic_publish(exchange='direct_exchange',
                      routing_key='direct_key',
                      body='Persistent Message',
                      properties=pika.BasicProperties(
                          delivery_mode=2 # 持久化消息
                      ))

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                         exchange_type='direct')

channel.queue_declare(queue='direct_queue')

channel.queue_bind(exchange='direct_exchange',
                   queue='direct_queue',
                   routing_key='direct_key')

def callback(ch, method, properties, body):
    print("Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag) # 确认消息

channel.basic_consume(queue='direct_queue',
                      on_message_callback=callback,
                      auto_ack=False)

channel.start_consuming()
工作队列（Work Queues）的应用

工作队列（Work Queues）用于公平分发任务，确保任务均匀分配给不同的消费者。以下是一个简单的任务分发示例：

# 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

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

for i in range(10):
    message = 'Task %d' % i
    channel.basic_publish(exchange='',
                          routing_key='work_queue',
                          body=message,
                          properties=pika.BasicProperties(
                              delivery_mode=2 # 持久化消息
                          ))

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='work_queue')

def callback(ch, method, properties, body):
    print("Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag) # 确认消息

channel.basic_qos(prefetch_count=1) # 限制每个消费者一次只处理一个任务
channel.basic_consume(queue='work_queue',
                      on_message_callback=callback,
                      auto_ack=False)

channel.start_consuming()
RabbitMQ常见问题与解决方案
常见错误及其解决方法

连接问题

  • 错误信息：Socket connection unexpectedly closed
  • 解决方法：确保 RabbitMQ 服务器运行正常，检查网络连接是否通畅，防火墙是否开放了正确的端口。

消息丢失

  • 原因：未启用持久化存储或消息未被正确确认。
  • 解决方法：确保消息和队列都是持久化的，并在消费者中正确地确认消息。

  • 代码示例：

    # 生产者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                       exchange_type='direct')

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

channel.basic_publish(exchange='direct_exchange',
                    routing_key='direct_key',
                    body='Persistent Message',
                    properties=pika.BasicProperties(
                        delivery_mode=2
                    ))

connection.close()

# 消费者代码
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_exchange',
                       exchange_type='direct')

channel.queue_declare(queue='direct_queue')

channel.queue_bind(exchange='direct_exchange',
                 queue='direct_queue',
                 routing_key='direct_key')

def callback(ch, method, properties, body):
  print("Received %r" % body)
  ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_consume(queue='direct_queue',
                    on_message_callback=callback,
                    auto_ack=False)

channel.start_consuming()

性能问题

  • 原因：消息量大或消费者处理能力不足。
  • 解决方法：增加消费者数量，优化消费者代码，使用工作队列模式进行负载均衡。
性能优化技巧
  • 水平扩展：增加多个 RabbitMQ 实例，实现负载均衡。
  • 优化消息处理：减少消息的大小，优化消息处理逻辑，避免在消息处理中进行耗时操作。
  • 持久化存储：合理设置持久化存储策略，避免不必要的磁盘写操作。
RabbitMQ监控与日志

RabbitMQ 提供了丰富的监控和日志工具，可以通过以下方式查看和管理：

  • 管理界面：通过浏览器访问 http://<服务器IP>:15672，使用默认的用户名和密码 guest 登录。
  • 命令行工具：使用 rabbitmqctl 命令行工具进行操作，例如查看状态、重启服务等。
  • 日志文件：查看 /var/log/rabbitmq/ 目录下的日志文件，获取详细的日志信息。

通过这些工具，可以方便地监控 RabbitMQ 的运行状态，及时发现并解决问题。

点击查看更多内容
发表于 2024.12.09 11:31， 共 42 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

慕后森

手记
篇
粉丝
57
获赞与收藏
235

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消