Ubuntu 系统下 AMQP 协议 RabbitMQ服务器部署

一、安装RabbitMQ及其配置

步骤1：安装RabbitMQ

# 更新系统
sudo apt update
sudo apt upgrade -y

# 安装Erlang和RabbitMQ
sudo apt install -y erlang
sudo apt install -y rabbitmq-server

# 启动并设置开机自启
sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server

# 检查状态
sudo systemctl status rabbitmq-server

步骤2：安全配置（设置账户、密码 、可以正常接收局域网消息）

# 创建新用户（替换为你自己的用户名和密码）
sudo rabbitmqctl add_user mi_user YourStrongPassword123!

# 设置管理员权限（可选，根据需要）
sudo rabbitmqctl set_user_tags mi_user administrator

# 设置权限
sudo rabbitmqctl set_permissions -p / mi_user ".*" ".*" ".*"

# 删除默认的guest用户（必须！）
sudo rabbitmqctl delete_user guest

# 启用管理插件（可选，方便监控）
sudo rabbitmq-plugins enable rabbitmq_management

# 配置监听所有网络接口
echo 'listeners.tcp.default = 5672' | sudo tee -a /etc/rabbitmq/rabbitmq.conf
echo 'management.tcp.ip = 0.0.0.0' | sudo tee -a /etc/rabbitmq/rabbitmq.conf

# 重启服务使配置生效
sudo systemctl restart rabbitmq-server

# 开放防火墙
sudo ufw allow 5672/tcp
sudo ufw allow 15672/tcp

步骤3：验证安装

# 查看RabbitMQ状态
sudo rabbitmqctl status

# 查看监听端口
sudo netstat -tlnp | grep 5672
#查看所有用户
sudo rabbitmqctl list_users

步骤4：安装 pika 1.3.2 版本并使用阿里云镜像源的命令

pip install pika==1.3.2 -i https://mirrors.aliyun.com/pypi/simple/

二、Python程序（极简版）

1. set.py：运行一次，创建队列
2. producer.py：发送消息到队列
3. consumer.py：监听队列，接收消息

1. set.py

# setup.py - 交换机版（端口56723）
import pika

# 关键参数
HOST = 'localhost'  # 如果在同一台服务器，用localhost；如果在其他设备，改成服务器IP
PORT = 5672       # 你的自定义端口
USER = 'mi_user'
PASSWORD = 'YourPassword123'

try:
    # 连接（指定端口）
    conn = pika.BlockingConnection(
        pika.ConnectionParameters(
            host=HOST,
            port=PORT,
            credentials=pika.PlainCredentials(USER, PASSWORD)
        )
    )
    ch = conn.channel()
    print(f"✅ 连接成功 {HOST}:{PORT}")

    # 1. 创建交换机
    ch.exchange_declare(
        exchange='my_exchange',  # 交换机名称
        exchange_type='direct',  # 类型：direct/topic/fanout
        durable=True             # 持久化
    )
    print("✅ 交换机 'my_exchange' 已创建")

    # 2. 创建队列
    ch.queue_declare(queue='high_queue', durable=True)
    ch.queue_declare(queue='low_queue', durable=True)
    print("✅ 队列已创建")

    # 3. 绑定（交换机 -> 队列）
    ch.queue_bind(
        exchange='my_exchange',
        queue='high_queue',
        routing_key='high'  # 路由键 high -> high_queue
    )

    ch.queue_bind(
        exchange='my_exchange',
        queue='low_queue',
        routing_key='low'   # 路由键 low -> low_queue
    )
    print("✅ 绑定完成")

    conn.close()
    print("\n✅ 基础设施配置完成！")
    print("现在可以运行：")
    print("  python consumer.py  # 启动消费者")
    print("  python producer.py  # 发送消息")

except Exception as e:
    print(f"❌ 配置失败: {e}")

可运行下面命令查看配置：

# 查看交换机
sudo rabbitmqctl list_exchanges

# 查看绑定
sudo rabbitmqctl list_bindings

2.producer.py

# producer.py - 交换机版（端口56723）
import pika
import json

# 关键参数
HOST = '192.168.1.100'  # RabbitMQ服务器的IP地址
PORT = 5672            # 自定义端口
USER = 'mi_user'
PASSWORD = 'YourPassword123'

def send_message():
    # 连接（指定端口）
    conn = pika.BlockingConnection(
        pika.ConnectionParameters(
            host=HOST,
            port=PORT,
            credentials=pika.PlainCredentials(USER, PASSWORD)
        )
    )
    ch = conn.channel()

    # 发送消息到交换机，指定路由键
    # 路由键决定消息去哪个队列

    # 消息1：高优先级
    message1 = {"id": 1, "task": "紧急备份", "priority": "high"}
    ch.basic_publish(
        exchange='my_exchange',  # 使用自定义交换机
        routing_key='high',      # 路由键 high -> high_queue
        body=json.dumps(message1)
    )
    print(f"✅ 发送高优先级: {message1}")

    # 消息2：低优先级
    message2 = {"id": 2, "task": "日常清理", "priority": "low"}
    ch.basic_publish(
        exchange='my_exchange',  # 使用自定义交换机
        routing_key='low',       # 路由键 low -> low_queue
        body=json.dumps(message2)
    )
    print(f"✅ 发送低优先级: {message2}")

    conn.close()
    print("✅ 所有消息发送完成！")

if __name__ == "__main__":
    send_message()

3. consumer.py

# consumer.py - 交换机版（端口56723）
import pika
import json
import time

# 关键参数
HOST = '192.168.1.100'  # RabbitMQ服务器的IP地址
PORT = 5672            # 自定义端口
USER = 'mi_user'
PASSWORD = 'YourPassword123'
QUEUE = 'high_queue'    # 监听哪个队列？可以改成 low_queue

def callback(ch, method, properties, body):
    """收到消息时调用"""
    try:
        message = json.loads(body.decode('utf-8'))
        print(f"\n📨 收到消息: {message}")

        # 模拟处理
        if message.get('priority') == 'high':
            print("🔧 处理高优先级任务...")
            time.sleep(2)
        else:
            print("🔧 处理普通任务...")
            time.sleep(1)

        print("✅ 处理完成")

        # 确认消息
        ch.basic_ack(delivery_tag=method.delivery_tag)
    except Exception as e:
        print(f"❌ 处理失败: {e}")
        ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)

def start_consumer():
    # 连接（指定端口）
    conn = pika.BlockingConnection(
        pika.ConnectionParameters(
            host=HOST,
            port=PORT,
            credentials=pika.PlainCredentials(USER, PASSWORD)
        )
    )
    ch = conn.channel()

    # 声明队列（确保存在）
    ch.queue_declare(queue=QUEUE, durable=True)

    # 设置每次只处理一条消息
    ch.basic_qos(prefetch_count=1)

    # 开始消费
    ch.basic_consume(queue=QUEUE, on_message_callback=callback, auto_ack=False)

    print(f"🔄 开始监听队列: {QUEUE} ({HOST}:{PORT})")
    print("按 Ctrl+C 退出")

    try:
        ch.start_consuming()
    except KeyboardInterrupt:
        print("\n⏹️  已停止")
        conn.close()

if __name__ == "__main__":
    start_consumer()