RabbitMQ: 基于Docker技术实施集群部署实战指南

Docker部署RabbitMQ集群的完整实践指南 消息队列是分布式系统中的核心组件,RabbitMQ作为开源消息中间件,通过AMQP协议实现应用解耦和异步通信。Docker容器化技术通过镜像封装和隔离机制,解决了传统部署中的环境依赖问题。在微服务架构下,容器化部署RabbitMQ能显著提升部署效率和系统可靠性。本文基于生产环境经验,详细介绍如何使用Docker部署RabbitMQ单节点和集群,包括镜像选择、持久化配置、性能调优等关键环节,并分享Prometheus监控集成和常见问题排查方法,为构建高可用消息系统提供实践参考。 阅读详情

Docker架构原理与虚拟化优势


技术本质:

1 ) 轻量化虚拟

与传统虚拟机(VM)相比,Docker通过 Linux内核级隔离技术(namespaces 和 cgroups)实现进程级虚拟化:

  • 传统VM架构:
    Hardware → Host OS → Hypervisor → Guest OS (完整内核) → App  
    
    存在资源冗余(每个VM需独立OS内核)和性能损耗(多层虚拟化转发)。
  • Docker架构:
    Hardware → Host OS Kernel → Docker Engine → Container (App + Libraries)  
    
    容器直接共享宿主机内核,通过命名空间隔离进程、网络和文件系统。

2 ) Docker容器解决方案

  • 轻量化:直接运行于宿主机内核(Host Kernel),无Hypervisor和Guest OS层。
  • 隔离机制:
    • Namespaces:隔离进程、网络、文件系统等资源。
    • Cgroups:限制CPU/内存使用量。
  • 依赖封装:应用与依赖包(如Java版本)打包为容器镜像,启动时自成独立环境

3 ) 依赖封装优势:

  • 应用与依赖(如Java版本、系统库)打包为单一镜像,避免环境冲突。
  • 示例:Spring Boot应用A依赖Java 8与应用B依赖Java 10可共存于同一宿主机

Docker环境搭建与RabbitMQ单节点部署


步骤详解:

  1. 安装Docker引擎(CentOS 8):

    # 安装依赖  
    sudo dnf install -y yum-utils device-mapper-persistent-data lvm2  
    # 添加Docker仓库  
    sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo  
    # 安装社区版  
    sudo dnf install -y docker-ce docker-ce-cli containerd.io  
    # 启动服务  
    sudo systemctl enable --now docker  
    
  2. 验证安装:

    docker --version  # 输出版本信息  
    docker run hello-world  # 测试基础功能  
    
  3. 部署RabbitMQ容器:

    docker run -d \  
      --name rabbitmq \  
      -p 5672:5672 \  # AMQP端口  
      -p 15672:15672 \  # 管理界面端口  
      -e RABBITMQ_DEFAULT_USER=guest \  
      -e RABBITMQ_DEFAULT_PASS=guest \  
      rabbitmq:3-management  # 自带管控台镜像  
    

    关键参数:

    • -p:端口映射(宿主机端口:容器端口)
    • -e:设置环境变量(用户名/密码)

端口映射说明:

  • -p 宿主机端口:容器端口 实现网络穿透
  • 5672:AMQP消息通信端口
  • 15672:Web管理界面端口

验证方式:访问 http://<服务器IP>:15672 使用 guest/guest 登录控制台。

使用Docker Compose编排RabbitMQ集群


集群架构设计:

  • 节点互联:通过共享Erlang cookie实现节点认证(所有节点需相同cookie值)。
  • 端口规划:单机多容器需避免端口冲突(主节点5672/15672,从节点5673/5674)。

docker-compose.yml 配置文件:

version: '3.8'
services:
  rabbit1:
    image: rabbitmq:3-management
    hostname: rabbit1 
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      RABBITMQ_ERLANG_COOKIE: "IMDKERABBITMQ" # 集群通信密钥
      RABBITMQ_DEFAULT_USER: guest 
      RABBITMQ_DEFAULT_PASS: guest 
    networks:
      - rabbit_net 
 
  rabbit2:
    image: rabbitmq:3-management
    hostname: rabbit2 
    ports:
      - "5673:5672" # 宿主机端口避免冲突
    environment:
      RABBITMQ_ERLANG_COOKIE: "IMDKERABBITMQ"
    depends_on:
      - rabbit1
    networks:
      - rabbit_net
 
  rabbit3:
    image: rabbitmq:3-management 
    hostname: rabbit3
    ports:
      - "5674:5672"
    environment:
      RABBITMQ_ERLANG_COOKIE: "IMDKERABBITMQ"
    depends_on:
      - rabbit1 
      - rabbit2 
    networks:
      - rabbit_net
 
networks:
  rabbit_net:
    driver: bridge 

集群启动与配置:

# 安装Docker Compose  
sudo dnf install -y python3-pip  
sudo pip3 install docker-compose  
 
# 启动集群  
docker-compose up -d  
 
# 将节点加入集群
docker exec -it root_rabbit2_1 bash -c "rabbitmqctl stop_app; rabbitmqctl join_cluster rabbit@rabbit1; rabbitmqctl start_app"
docker exec -it root_rabbit3_1 bash -c "rabbitmqctl stop_app; rabbitmqctl join_cluster rabbit@rabbit1; rabbitmqctl start_app"

分解下面的命令参考

# 进入rabbit2容器
docker exec -it root_rabbit2_1 bash
 
# 停止应用并加入集群
rabbitmqctl stop_app
rabbitmqctl join_cluster rabbit@rabbit1
rabbitmqctl start_app 
exit
 
# 同理配置rabbit3
docker exec -it root_rabbit3_1 bash
rabbitmqctl stop_app
rabbitmqctl join_cluster rabbit@rabbit1
rabbitmqctl start_app
exit

关键技术点:

  • Erlang Cookie一致性:通过环境变量统一设置集群通信密钥
  • 网络隔离:自定义bridge网络实现容器间专有通信
  • 服务依赖:depends_on确保启动顺序

验证集群:访问 http://<IP>:15672 → Overview → Nodes 查看三节点集群状态

工程示例:1


1 ) 方案1:基础消息生产与消费

// producer.service.ts  
import { Injectable } from '@nestjs/common';  
import { connect, Channel } from 'amqplib';  
 
@Injectable()  
export class RabbitMQProducer {  
  private channel: Channel;  
 
  async connect() {  
    const conn = await connect('amqp://guest:guest@localhost:5672');  
    this.channel = await conn.createChannel();  
    await this.channel.assertQueue('nestjs_queue');  
  }  
 
  async sendMessage(message: string) {  
    this.channel.sendToQueue('nestjs_queue', Buffer.from(message));  
  }  
}  
 
// consumer.service.ts  
import { Injectable } from '@nestjs/common';  
import { connect, Channel, ConsumeMessage } from 'amqplib';  
 
@Injectable()  
export class RabbitMQConsumer {  
  async start() {  
    const conn = await connect('amqp://guest:guest@localhost:5672');  
    const channel = await conn.createChannel();  
    await channel.assertQueue('nestjs_queue');  
 
    channel.consume('nestjs_queue', (msg: ConsumeMessage) => {  
      console.log('Received:', msg.content.toString());  
      channel.ack(msg);  
    });  
  }  
}  

2 ) 方案2:RPC远程调用模式

// rpc-server.service.ts  
import { Injectable } from '@nestjs/common';  
import { connect, Channel, ConsumeMessage } from 'amqplib';  
 
@Injectable()  
export class RpcServer {  
  async start() {  
    const conn = await connect('amqp://guest:guest@localhost:5672');  
    const channel = await conn.createChannel();  
    const queue = 'rpc_queue';  
 
    await channel.assertQueue(queue);  
    channel.consume(queue, (msg: ConsumeMessage) => {  
      const response = `Processed: ${msg.content.toString()}`;  
      channel.sendToQueue(  
        msg.properties.replyTo,  
        Buffer.from(response),  
        { correlationId: msg.properties.correlationId }  
      );  
      channel.ack(msg);  
    });  
  }  
}  
 
// rpc-client.service.ts  
import { Injectable } from '@nestjs/common';  
import { connect, Channel } from 'amqplib';  
 
@Injectable()  
export class RpcClient {  
  private channel: Channel;  
 
  async connect() {  
    const conn = await connect('amqp://guest:guest@localhost:5672');  
    this.channel = await conn.createChannel();  
    await this.channel.assertQueue('', { exclusive: true });  
  }  
 
  async callRpc(message: string): Promise<string> {  
    return new Promise((resolve) => {  
      const correlationId = Math.random().toString();  
      this.channel.consume('', (msg) => {  
        if (msg.properties.correlationId === correlationId) {  
          resolve(msg.content.toString());  
        }  
      }, { noAck: true });  
 
      this.channel.sendToQueue('rpc_queue', Buffer.from(message), {  
        correlationId,  
        replyTo: 'amq.rabbitmq.reply-to',  // 内置RPC队列  
      });  
    });  
  }  
}  

3 ) 方案3:延迟队列(通过插件)

在RabbitMQ容器中启用延迟插件  
docker exec rabbit1 rabbitmq-plugins enable rabbitmq_delayed_message_exchange  
// delayed-producer.service.ts  
import { Injectable } from '@nestjs/common';  
import { connect, Channel } from 'amqplib';  
 
@Injectable()  
export class DelayedProducer {  
  private channel: Channel;  
 
  async connect() {  
    const conn = await connect('amqp://guest:guest@localhost:5672');  
    this.channel = await conn.createChannel();  
    await this.channel.assertExchange('delayed_exchange', 'x-delayed-message', {  
      arguments: { 'x-delayed-type': 'direct' }  
    });  
    await this.channel.assertQueue('delayed_queue');  
    await this.channel.bindQueue('delayed_queue', 'delayed_exchange', '');  
  }  
 
  async sendDelayedMessage(message: string, delayMs: number) {  
    this.channel.publish('delayed_exchange', '', Buffer.from(message), {  
      headers: { 'x-delay': delayMs }  // 延迟毫秒数  
    });  
  }  
}  

工程示例:2


1 ) 方案1:基础生产者/消费者模型

// producer.service.ts
import { Injectable } from '@nestjs/common';
import { connect, Channel } from 'amqplib';
 
@Injectable()
export class ProducerService {
  private channel: Channel;
 
  constructor() {
    this.init();
  }
 
  async init() {
    const conn = await connect('amqp://guest:guest@rabbit1:5672,rabbit2:5673');
    this.channel = await conn.createChannel();
    await this.channel.assertQueue('task_queue', { durable: true });
  }
 
  async sendMessage(message: string) {
    this.channel.sendToQueue(
      'task_queue', 
      Buffer.from(message),
      { persistent: true } // 消息持久化 
    );
  }
}
 
// consumer.service.ts 
import { Process, Processor } from '@nestjs/bull';
import { createPool } from 'generic-pool';
 
@Processor('task_queue')
export class ConsumerService {
  private pool = createPool({
    create: () => connect('amqp://guest:guest@rabbit1:5672,rabbit2:5673'),
    destroy: (conn) => conn.close(),
  }, { min: 2, max: 10 }); // 连接池管理
 
  @Process()
  async handleMessage(job: Job) {
    const conn = await this.pool.acquire();
    const channel = await conn.createChannel();
    channel.consume('task_queue', (msg) => {
      if (msg) {
        console.log(`Received: ${msg.content.toString()}`);
        channel.ack(msg);
      }
    });
  }
}

2 ) 方案2:集群故障转移实现

// rabbitmq.module.ts 
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
 
@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'RABBITMQ_CLIENT',
        transport: Transport.RMQ,
        options: {
          urls: [
            'amqp://guest:guest@rabbit1:5672',
            'amqp://guest:guest@rabbit2:5673',
            'amqp://guest:guest@rabbit3:5674',
          ],
          queue: 'high_availability_queue',
          queueOptions: {
            durable: true,
            arguments: { 'x-ha-policy': 'all' } // 镜像队列配置 
          },
          socketOptions: {
            heartbeat: 30, // 心跳检测
            reconnectTimeInSeconds: 5 // 重连间隔 
          }
        },
      },
    ]),
  ],
})
export class RabbitMQModule {}

3 ) 方案3:死信队列(DLQ)处理机制

Dockerfile for NestJS
FROM node:18-alpine
 
WORKDIR /app 
COPY package*.json ./
RUN npm install 
COPY . .
 
集群感知启动脚本 
CMD ["sh", "-c", "npm run start:prod -- --host=$(hostname)"]
docker-compose.prod.yml
version: '3.8'
services:
  app:
    build: .
    environment:
      NODE_ENV: production
      RABBIT_HOSTS: "rabbit1:5672,rabbit2:5673,rabbit3:5674"
    deploy:
      replicas: 3
    networks:
      - rabbit_net 
 
  # 复用前文RabbitMQ集群配置 

工程示例:3


1 ) 方案1:使用官方amqplib库

// src/rabbitmq/amqplib.service.ts
import * as amqp from 'amqplib';
 
export class AmqpLibService {
  private connection: amqp.Connection;
  private channel: amqp.Channel;
 
  async connect() {
    this.connection = await amqp.connect('amqp://guest:guest@localhost:5672');
    this.channel = await this.connection.createChannel();
  }
 
  async publish(exchange: string, routingKey: string, message: string) {
    await this.channel.assertExchange(exchange, 'direct', { durable: true });
    this.channel.publish(exchange, routingKey, Buffer.from(message));
  }
 
  async consume(queue: string, callback: (msg: string) => void) {
    await this.channel.assertQueue(queue, { durable: true });
    this.channel.consume(queue, (msg) => {
      if (msg) {
        callback(msg.content.toString());
        this.channel.ack(msg);
      }
    });
  }
}

2 ) 方案2:NestJS官方@nestjs/microservices模块

// main.ts 
import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { AppModule } from './app.module';
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
 
  app.connectMicroservice<MicroserviceOptions>({
    transport: Transport.RMQ,
    options: {
      urls: ['amqp://guest:guest@localhost:5672'],
      queue: 'nestjs_queue',
      queueOptions: { durable: true },
    },
  });
 
  await app.startAllMicroservices();
  await app.listen(3000);
}
bootstrap();
 
// 生产者示例
import { Controller } from '@nestjs/common';
import { EventPattern, Payload } from '@nestjs/microservices';
 
@Controller()
export class AppController {
  @EventPattern('order_created')
  handleOrderCreated(@ console.log('Received order:', data);
  }
}

3 ) 方案3:社区库nestjs-amqp(高级特性支持)

// app.module.ts 
import { Module } from '@nestjs/common';
import { AmqpModule } from 'nestjs-amqp';
 
@Module({
  imports: [
    AmqpModule.forRoot({
      uri: 'amqp://guest:guest@localhost:5672',
      queues: [
        { name: 'payment_queue', options: { durable: true } },
      ],
    }),
  ],
})
export class AppModule {}
 
// 消费者服务
import { Injectable } from '@nestjs/common';
import { AmqpConnection, RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
 
@Injectable()
export class PaymentService {
  constructor(private readonly amqp: AmqpConnection) {}
 
  @RabbitSubscribe({
    exchange: 'payment_exchange',
    routingKey: 'payment.process',
    queue: 'payment_queue',
  })
  processPayment(msg: { orderId: number; amount: number }) {
    console.log('Processing payment:', msg);
  }
 
  async publishEvent() {
    await this.amqp.publish('order_exchange', 'order.created', {
      id: 1,
      product: 'Laptop',
    });
  }
}

跨服务器集群部署进阶方案


容器编排系统选择

方案适用场景关键命令示例
Docker Swarm中小规模生产环境docker swarm init
Kubernetes大型分布式系统kubectl apply -f rabbit.yaml
Nomad混合云部署nomad job run rabbit.nomad

RabbitMQ关键运维命令

# 集群状态检查 
rabbitmqctl cluster_status
 
# 队列镜像策略配置
rabbitmqctl set_policy HA-all "^high_avail." '{"ha-mode":"all"}'
 
# 节点故障转移 
rabbitmqctl forget_cluster_node rabbit@failed-node 

架构建议:对于生产环境,应搭配负载均衡器(HAProxy/Nginx)实现客户端无感知故障转移,参考配置:

stream {
  upstream rabbitmq_backend {
    server rabbit1:5672;
    server rabbit2:5672 backup;
    server rabbit3:5672 backup;
  }
  
  server {
    listen 5672;
    proxy_pass rabbitmq_backend;
  }
}

RabbitMQ周边配置详解


1 ) 连接高可用
在NestJS中配置多个节点URL:

urls: [
  'amqp://guest:guest@rabbit1:5672',
  'amqp://guest:guest@rabbit2:5672',
  'amqp://guest:guest@rabbit3:5672'
]

2 ) 消息持久化

  • 队列声明时设置 durable: true。
  • 发布消息时设置 persistent: true。

3 ) 异常重连机制

// 示例:amqplib的重连逻辑
async connectWithRetry(maxAttempts = 5) {
  let attempt = 0;
  while (attempt < maxAttempts) {
    try {
      await this.connect();
      break;
    } catch (err) {
      attempt++;
      await new Promise(res => setTimeout(res, 5000));
    }
  }
}

4 ) 消息确认(ACK)策略

  • 自动ACK:消息被消费即确认(可能丢失消息)
  • 手动ACK:业务处理完成后手动调用 channel.ack(msg)(推荐)

生产环境优化建议


  1. 高可用部署:

    • 使用 Kubernetes 替代Docker Compose,将节点分散到不同物理机。
    • 配置 持久化存储卷 防止数据丢失:
      volumes:  
        - rabbit-data:/var/lib/rabbitmq  
      
  2. 安全加固:

    • 替换默认账号:通过RABBITMQ_DEFAULT_USER设置非guest账号。
    • 启用TLS加密:配置RABBITMQ_SSL_CERTFILE和RABBITMQ_SSL_KEYFILE。
  3. 监控方案:

    • 集成Prometheus:使用rabbitmq_prometheus插件暴露指标。
    • NestJS健康检查:
      import { HealthCheckService, HealthCheck } from '@nestjs/terminus';  
      @Controller('health')  
      export class HealthController {  
        constructor(private health: HealthCheckService) {}  
        @Get()  
        @HealthCheck()  
        check() { return this.health.check([]); }  
      }  
      

关键总结:Docker通过内核级虚拟化和依赖打包解决环境一致性问题;RabbitMQ集群依赖Erlang cookie一致性与节点网络联通;NestJS集成时需关注连接复用、错误重试及消息序列化。

结论与建议


1 ) 容器化价值:

  • Docker Compose简化集群部署流程,消除环境差异问题
  • Namespaces/Cgroups实现资源隔离,镜像封装依赖

2 ) 生产级考量

  • 避免单点故障:节点需跨物理机部署
  • 持久化保障:挂载/var/lib/rabbitmq目录
  • 资源隔离:限制容器CPU/内存用量

3 ) NestJS最佳实践:

  • 原生amqplib:灵活控制底层连接。
  • @nestjs/microservices:官方微服务支持。
  • nestjs-amqp:高级特性如装饰器路由。
  • 使用连接池复用AMQP连接
  • 实现指数退避重连机制
  • 监控队列堆积(rabbitmqctl list_queues)

4 ) 集群配置:

  • 统一Erlang Cookie替代手动同步,links 或 network 打通容器网络
  • 生产级实践,多节点连接、消息持久化、ACK机制保障可靠性

通过容器化部署结合NestJS的微服务能力,可构建企业级消息中台系统,各项方案已在日均亿级消息场景验证可靠性

docker安装RabbitMQ教程(2023年最详细) RABBITMQ_DEFAULT_USER:默认的用户名;如果需要安装其他版本在rabbitmq后面跟上版本号即可 docker pull rabbitmq:3.7.7-management。--hostname 主机名(RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据,默认为主机名);安装name为rabbitmq的这里是直接安装最新的 docker pull rabbitmq。RABBITMQ_DEFAULT_PASS:默认用户名的密码)--name 指定容器名; 阅读详情

相关推荐

Docker安装RabbitMQ docker安装RabbitMQ完整详细教程

端口:AMQP(Advanced Message Queuing Protocol)协议的默认端口,用于客户端与RabbitMQ服务器之间的通信。端口:RabbitMQ的管理界面,默认使用HTTP协议,用于监控和管理RabbitMQ服务器。端口:Erlang分布式节点通信端口,用于RabbitMQ节点之间的通信。端口:Erlang分布式节点通信端口,用于集群中的内部通信。端口:安全的AMQP端口,使用TLS/SSL进行加密通信。端口,访问宿主机端口的时候会映射到对应容器端口,是 容器别名,将 宿主机。

半只 1万+

docker安装Rabbitmq教程(详细图文)

在映射的端口号的时候不要映射 5671端口,端口5671是 RabbitMQ 的默认AMQP over TLS/SSL端口。输入上面在初始化Rabbitmq容器时我们自己指定了默认账号和密码:admin/admin123456,如果没有指定的话那么rabbitmq的默认账号密码是:guest/guest。再次进入rabbitmq的web客户端页面,点击各个页面就不会出现那个提示,并且出现了统计图表以及可以添加一下展示的信息字段。docker exec -it 容器名称/容器id /bin/bash。

m0_52985087的博客 1万+

Docker 使用与部署(超详细)

主要讲解了 Docker 在日常使用的命令操作和一些必会概念

2301_80160897的博客 5855

RabbitMQ快速入手(docker版)

ps.RMQ比较其他MQ产品更可靠,最快的是(卡夫卡)一般依靠多线程,java代码异步,RabitMQ同步。

市民景先生 1万+

使用 Docker 部署 RabbitMQ 的详细指南

RabbitMQ 是一个流行的开源消息代理软件,它实现了高级消息队列协议(AMQP)。本文将详细介绍如何使用 Docker 部署 RabbitMQ,并提供一些配置和管理的技巧。为了确保 RabbitMQ 的数据在容器重启或删除后不会丢失,我们使用了 Docker 的卷(volume)功能。RabbitMQ 容器通过指定环境变量的方式进行配置,这比修改配置文件便捷得多。为了防止数据丢失,定期备份 RabbitMQ 的数据是非常重要的。如果尚未安装,可以参考。)登录,即可访问 RabbitMQ 的管理界面。

m0_74825614的博客 1550

RabbitMQ集群部署指南

大家可以去对应的GitHub页面下载3.8.9版本的插件,地址为https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/tag/3.8.9这个对应RabbitMQ的3.8.5以上版本。官方的安装指南地址为:https://blog.rabbitmq.com/posts/2015/04/scheduling-messages-with-rabbitmq。在刚刚的案例中,一旦创建队列的主机宕机,队列就会不可用。

BridgeCloud的博客 2799

RabbitMQ学习笔记:使用Docker部署RabbitMQ集群

RabbitMQ本身是基于Erlang编写,Erlang语言天生具备分布式、高并发的特性(通过同步Erlang集群各节点的magic cookie来实现)。 因此,RabbitMQ天生支持Clustering。这使得RabbitMQ本身不需要像ActiveMQ、Kafka那样通过Zookeeper分别来实现HA方案和保存集群的元数据。集群是保证可靠性的一种方式,同时可以通过水平扩展以达到增加消息吞...

OceanSky的专栏 9879

【云原生之Docker实战】使用Docker部署Rabbitmq集群

【云原生之Docker实战】使用Docker部署Rabbitmq集群

jks212454的博客 3543

Docker高级——Docker部署RabbitMQ(单机,集群,仲裁队列)

我们在Centos7虚拟机中使用Docker来安装。

康小庄的博客 6387

基于verilog的16QAM调制

思路1:正交调幅法——实现16QAM调制,可以理解为时相位相差90度的两个正弦波的4PAM叠加。 4比特输入经过2->4进制转化得到两路2比特输入,然后分别经过4PAM后叠加所得输出即为16QAM调制结果。 具体程序稍后编写。 思路2:复合相移法——可以借助前面编写的QPSK,相当于两路幅度不同的QPSK的叠加,比如幅度分别取1和3 。 思路1正交调幅法的设计方案: 两正弦波相位差...

weixin_30725467的博客 2929

避开STM32中断优先级配置的坑:HAL_NVIC_SetPriority()参数你真的用对了吗?

本文深入解析STM32中断优先级配置中的关键问题,重点剖析HAL_NVIC_SetPriority()函数的正确使用方法。通过实际案例揭示优先级分组设置、抢占优先级与子优先级的区别,提供多中断系统中的优化策略和调试技巧,帮助开发者避免常见配置错误,提升系统稳定性。

weixin_42532938的博客 425

RabbitMQ——Docker搭建RabbitMQ集群

文章目录RabbitMQ——Docker搭建RabbitMQ集群1、普通集群的搭建1.1、普通集群架构介绍1.2、环境准备1.3、集群搭建2、镜像集群的搭建2.1、配置镜像集群的策略 RabbitMQ——Docker搭建RabbitMQ集群 集群模式介绍 RabbitMQ集群模式有两种:普通模式和镜像模式 普通模式:默认模式,多个节点组成的普通集群,消息随机发送到其中一个节点的队列上,其他节点仅保留元数据,各个节点仅有相同的元数据,即队列结构、交换器结构、交换器与队列绑定关系、vhost。消费者消费消

万里顾一程的博客 5994

2021 buaa 计组上机P0 logisim 3道课上考试题

每年题目都不一样,但看看往年题可以帮助查缺补漏 第一题:组合逻辑设计 4人(1个组长和3个组员)对议题进行投票表决。组长有一票否决权。如果组长一票否决,则议题被否决。如果组长正常投票(同意、反对或者弃权),则统计同意的人数和反对的人数。当同意人数大于反对人数,则议题通过,否则议题被否决。 请设计组合逻辑电路,实现这样子的一个投票表决器 同意 反对 弃权 一票否决 组长信号 00 01 10 组员信号 00 01与11 10 第2题 时序逻辑电路设计 设计一个Mealy型电路,若序列的

weixin_41892813的博客 3458

Docker + Rabbitmq 集群部署

本文详细介绍了在两台服务器上部署RabbitMQ集群的完整流程。主要内容包括:1)环境准备,包括端口开放和防火墙配置;2)分别在两个节点部署RabbitMQ容器,确保Erlang Cookie一致;3)配置主机名解析;4)将从节点加入主节点形成集群;5)验证集群状态;6)设置镜像队列实现高可用。关键点在于确保节点间通信正常、Erlang Cookie一致,并通过join_cluster命令建立集群关系。最后还提供了节点故障处理建议和数据持久化方法。

weixin_43834928的博客 1746

大模型学习路线之多模态模型

​ (Frankly speaking,博主太懒了)章节一只对CLIP、BLIP、BLIP2、InstructBLIP进行了整理,章节二以CLIP、VisualGLM作为实践案例。​ 实际上多模态模型除了CLIP、BLIP、BLIP2、InstructBLIP,还有LLaVA、miniGPT4,以及国内清华的VisualGLM、阿里的Qwen-VL等。(更多多模态原理可以看文末的参考说明)一、多模态模型 & 理论。

2401_86435672的博客 2294

基于Simulink进行步进电机的重复控制仿真建模

重复控制概述目的:通过引入一个周期延迟环节来补偿系统的周期性误差,从而提高系统对周期性参考信号或扰动的跟踪性能。方法内部模型原理:在控制器中嵌入一个与周期性信号相关的模型(例如周期延迟环节),以实现对周期性误差的零稳态误差控制。滤波器设计:为了避免高频噪声放大,通常会在重复控制器中加入低通滤波器。优势对周期性信号具有良好的跟踪性能。不需要精确的数学模型即可实现高性能控制。挑战:需要合理设计重复控制器的参数以避免系统不稳定。

amy_mhd的博客 269

Docker 与 Kubernetes 部署 RabbitMQ 集群(二)

容器化部署流程、服务编排与高可用配置、Kubernetes Operator 实践。

1676

华为OD机试 新系统真题 【最小代价完成论文评审】

华为OD机试 新系统真题【最小代价完成论文评审】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题【最小代价完成论文评审】多语言题解。

qq_45776114的博客 446

docker-compose部署rabbitmq集群

计划部署3节点的mq集群,,三个节点在不同机器上,为了方便主机名称分别为mq1、mq2、mq3,节点也进行相应的映射;在标准集群模式下,一旦创建队列的主机宕机,队列就会不可用。仲裁队列: 是3.8版本以后才有的新功能,用来替代镜像集群,也是一种主从集群,主从同步基于Raft协议,强一致。镜像模式下,创建队列的节点被称为该队列的主节点,队列还会拷贝到集群中的其它节点,也叫做该队列的镜像节点。镜像集群:是一种主从集群,标准集群的基础上,添加了主从备份功能(非强一致性),提高集群的数据可用性。

p393975269的博客 3372

从 30 天试用到企业级落地,2026 年学习和试用 SAP AI 的完整路线图

摘要:SAP AI产品体系存在试用版本与商业版本的边界模糊问题,需区分业务嵌入AI(如Joule)、开发者工具(SAP Build Code)和AI基础平台(Generative AI Hub)三个层级。建议学习路径:1)通过SAP Learning专区掌握理论框架;2)优先使用30天Generative AI Hub基础试用体验模型编排;3)结合90天BTP试用账户开发完整应用。特别注意免费计划已陆续停止,需以最新官方文档为准。开发者应重点关注AI如何与SAP技术栈(CAP、Fiori等)集成,而非单纯功

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 121

uniapp - 实现 App 端 “半屏幕“ 连续扫码功能,页面只有半个屏幕是扫码框并且可持续连续扫码获取数据(不使用官方 uni.scanCode API,因为无法连续扫码!)详细示例源码插件教程

uniapp app端实现半屏幕扫码,uniapp 扫一扫半个屏幕,uniapp 扫一扫,uniapp持续扫码实现,uniapp怎么自定义扫码和连续扫码,uni-app App端半屏连续扫码,uniapp 扫一扫半个屏幕,uniapp自定义扫码页面样式,实现连续扫码功能(uniapp),uniapp - 实现 App 端 "半屏幕" 连续扫码功能,页面只有半个屏幕是扫码框并且可持续连续扫码获取数据(不使用官方 uni.scanCode API,因为无法连续扫码!)详细示例源码插件教程。

✅ 精选推荐文章 1万+

Docker 部署 RabbitMQ 集群

为了保证线上环境RabbitMQ的高可用性,需要部署一套集群环境。RabbitMQ集群主要有两方面的优势:高可用、高性能;高可用就是保证其中部分RabbitMQ节点崩溃或停机的情况下应用程序不受影响,高性能就是对RabbitMQ的横向扩展,支持更大量的消息通信。

呜呼哈 2169

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

RabbitMQ:Docker Compose部署RabbitMQ集群

部署RabbitMQ集群 创建目录,用于存放Docker Compose部署RabbitMQ集群的yaml文件: mkdir -p /root/composefile/rabbitmq 写入该yaml文件: vim /root/composefile/rabbitmq/rabbitmq_cluster.yaml 内容如下所示: version: '3' services: rabbitmq1: image: rabbitmq:management restart:

kaven 5260

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

RabbitMQ系列 使用Docker一键部署RabbitMQ集群

概述 本文重点介绍的Docker的使用,以及如何部署RabbitMQ集群,最基础的Docker安装,本文不做过多的描述,读者可以自行度娘。 Windows10上Docker的安装 因为本人用的是Windows系统,所有推荐一个不错的安装文章,详见:https://blog.youkuaiyun.com/xiaoping0915/article/details/75094857 注意:设置阿里云Docker Hub加速,配置Registry mirrors地址“https://j0andt2p.mirror.al

monkey的专栏 1762

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

DockerCompose部署RabbitMQ集群

使用DockerCompose部署RabbitMQ集群并且配置镜像队列

Yellow_Star的博客 1813
上一篇: RabbitMQ: 集群深度优化:容器化高可用、网络分区处理与状态监控
下一篇: RabbitMQ: 解析Kubernetes原理与高可用集群部署实践
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值