RabbitMQ: 解析Kubernetes原理与高可用集群部署实践

k8s部署消息中间件RabbitMQ集群 部署前准备: k8s集群,详见k8s集群搭建。 部署机型:本集群有3个master节点,3个worknode节点,rabbitMQ副本3个,则由k8s自由调度到各个工作节点中。 一、编写集群yaml文件,rabbitmq-cluster.yaml。 apiVersion: v1 kind: ServiceAccount metadata: name: rabbitmq namespace: sit --- kind: Role apiVersion: rbac.authorizati... 阅读详情

核心架构解析


  1. Kubernetes核心组件

    • Master节点:包含API Server、Replication Controller等控制组件,负责集群调度管理
    • Worker节点:运行实际工作负载,每个节点包含:
      • Docker:容器运行时环境
      • Kube Proxy/Lite:网络代理组件
      • Pod:最小调度单元,封装一个或多个容器
  2. 核心概念对比

    概念用途描述典型应用场景
    Pod业务最小单元,包含业务容器RabbitMQ节点容器
    StatefulSet管理有状态应用(如RabbitMQ)需持久化存储的服务
    Deployment管理无状态应用如 NestJS 服务
    Service负载均衡抽象层对外暴露服务入口

RabbitMQ高可用集群部署全流程


1 ) Service负载均衡层配置

apiVersion: v1
kind: Service
metadata:
  namespace: test-rabbitmq 
  name: rabbitmq-service
  labels:
    app: rabbitmq
spec:
  type: NodePort  # 物理机端口映射模式 
  ports:
    - name: http 
      protocol: TCP
      port: 15672  # 管控台端口 
      nodePort: 31672  # 物理机暴露端口
    - name: amqp 
      protocol: TCP
      port: 5672   # AMQP协议端口
      nodePort: 30672
  selector:
    app: rabbitmq  # 关联后端Pod标签 

核心作用:

  • 外部通过宿主机端口(如30672)访问RabbitMQ集群
  • 自动将请求分发到所有app: rabbitmq标签的Pod

2 ) ConfigMap配置注入

关键插件配置:

apiVersion: v1 
kind: ConfigMap
metadata:
  name: rabbitmq-config 
  namespace: test-rabbitmq
data:
  enabled_plugins: |
    [rabbitmq_management, rabbitmq_peer_discovery_k8s]  # 必须启用的插件 
  
  rabbitmq.conf: |
    cluster_formation.peer_discovery_backend = rabbit_peer_discovery_k8s
    cluster_formation.k8s.host = kubernetes.default.svc.cluster.local 
    cluster_formation.k8s.address_type = ip 
    cluster_formation.node_cleanup.interval = 30 
    log.console.level = warning 
    loopback_users.guest = false  # !!! 生产环境需禁用guest账户 !!!
  • 核心插件:rabbitmq_peer_discovery_k8s - 实现节点自动发现
    • 使RabbitMQ节点自动通过K8s API发现集群伙伴,无需手动配置节点信息
  • 自动网络分区处理:
    • cluster_formation.node_cleanup.interval=30 每30秒清理失效节点

3 ) StatefulSet有状态集群声明

apiVersion: apps/v1 
kind: StatefulSet 
metadata:
  name: rabbitmq 
  namespace: test-rabbitmq
spec:
  serviceName: rabbitmq 
  replicas: 3  # 集群节点数
  selector:
    matchLabels:
      app: rabbitmq 
  template:
    metadata:
      labels:
        app: rabbitmq
    spec:
      serviceAccountName: rabbitmq
      terminationGracePeriodSeconds: 10 
      containers:
      - name: rabbitmq
        image: rabbitmq:3.12-management
        volumeMounts:
        - name: config-volume
          mountPath: /etc/rabbitmq 
        ports:
        - containerPort: 15672 
          name: http
        - containerPort: 5672 
          name: amqp 
        livenessProbe:  # 存活探针 
          exec:
            command: ["rabbitmq-diagnostics", "status"]
          initialDelaySeconds: 60
          periodSeconds: 30 
          timeoutSeconds: 10
        readinessProbe:  # 就绪探针 
          exec:
            command: ["rabbitmq-diagnostics", "ping"]
          initialDelaySeconds: 20 
          periodSeconds: 10
        env:
        - name: MY_POD_IP 
          valueFrom: { fieldRef: { fieldPath: status.podIP } }
        - name: RABBITMQ_ERLANG_COOKIE 
          value: "IMAKERABBIT"  # !!! 生产环境需替换为强密码 !!!
        - name: RABBITMQ_NODENAME
          value: "rabbit@$(POD_IP)"
      volumes:
      - name: config-volume 
        configMap:
          name: rabbitmq-config

核心机制:

  • 双探针保障高可用:
    • livenessProbe:故障时重启Pod(例如执行rabbitmqctl status失败)
    • readinessProbe:未就绪时从Service摘流
  • Erlang Cookie:
    • 所有节点使用相同Cookie(如IMOK_RABBIT)实现节点间认证
  • 滚动更新策略:
    • terminationGracePeriodSeconds确保旧Pod处理完请求再终止

工程示例:1


方案1:基础消息生产者

// src/messaging/producer.service.ts
import { Injectable } from '@nestjs/common';
import { connect, Channel } from 'amqplib';
 
@Injectable()
export class RabbitMQProducer {
  private channel: Channel;
 
  async connect(host: string) {
    const conn = await connect(`amqp://${host}`);
    this.channel = await conn.createChannel();
    await this.channel.assertExchange('orders', 'direct', { durable: true });
  }
 
  async publish(message: string) {
    this.channel.publish('orders', 'order.created', Buffer.from(message), {
      persistent: true  // 消息持久化 
    });
  }
}

2 ) 方案2:高可用消费者

// src/messaging/consumer.service.ts 
import { Injectable, OnModuleInit } from '@nestjs/common';
import { connect, Channel, ConsumeMessage } from 'amqplib';
 
@Injectable()
export class RabbitMQConsumer implements OnModuleInit {
  private channel: Channel;
 
  async onModuleInit() {
    await this.connectCluster([
      'k8s-node1:30672', 
      'k8s-node2:30672'
    ]);
  }
 
  private async connectCluster(hosts: string[]) {
    for (const host of hosts) {
      try {
        const conn = await connect(`amqp://${host}`);
        this.channel = await conn.createChannel();
        await this.setupConsumer();
        break;  // 连接成功即终止尝试 
      } catch (err) {
        console.error(`Failed to connect to ${host}`, err);
      }
    }
  }
 
  private async setupConsumer() {
    await this.channel.assertQueue('order_queue', { durable: true });
    this.channel.bindQueue('order_queue', 'orders', 'order.created');
    this.channel.consume('order_queue', this.handleMessage, {
      noAck: false  // 启用手动ACK 
    });
  }
 
  private handleMessage(msg: ConsumeMessage) {
    try {
      // 业务处理逻辑 
      console.log(JSON.parse(msg.content.toString()));
      this.channel.ack(msg);  // 明确ACK 
    } catch (err) {
      this.channel.nack(msg); // 处理失败重试 
    }
  }
}

3 ) 方案3:RabbitMQ健康检查模块

// src/health/rabbitmq.health.ts
import { Injectable } from '@nestjs/common';
import { HealthCheckError, HealthIndicator } from '@nestjs/terminus';
import { connect } from 'amqplib';
 
@Injectable()
export class RabbitMQHealthIndicator extends HealthIndicator {
  async check(host: string) {
    try {
      const conn = await connect(`amqp://${host}`);
      await conn.close();
      return this.getStatus('rabbitmq', true);
    } catch (e) {
      throw new HealthCheckError('RabbitMQ连接失败', e.message);
    }
  }
}

工程示例:2


1 ) 方案1:基础消息生产者

// src/messaging/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://user:pass@rabbitmq-service:5672');
    this.channel = await conn.createChannel();
    await this.channel.assertQueue('nestjs_queue');
  }
 
  async sendMessage(message: string) {
    this.channel.sendToQueue('nestjs_queue', Buffer.from(message));
  }
}

2 ) 方案2:带确认机制的消费者

// src/messaging/consumer.service.ts 
import { Injectable } from '@nestjs/common';
import { connect, Channel, Message } from 'amqplib';
 
@Injectable()
export class RabbitMQConsumer {
  async start() {
    const conn = await connect('amqp://user:pass@rabbitmq-service:5672');
    const channel = await conn.createChannel();
    await channel.assertQueue('nestjs_queue');
    
    channel.consume('nestjs_queue', (msg: Message) => {
      if (msg) {
        console.log(`Received: ${msg.content.toString()}`);
        channel.ack(msg);  // 手动确认消息 
      }
    });
  }
}

3 ) 方案3:Topic 模式路由

// src/messaging/topic.service.ts
import { Injectable } from '@nestjs/common';
import { connect, Channel } from 'amqplib';
 
@Injectable()
export class TopicService {
  private channel: Channel;
  private readonly EXCHANGE = 'nestjs_topic';
 
  async setup() {
    const conn = await connect('amqp://user:pass@rabbitmq-service:5672');
    this.channel = await conn.createChannel();
    await this.channel.assertExchange(this.EXCHANGE, 'topic', { durable: true });
  }
 
  async publish(routingKey: string, message: string) {
    this.channel.publish(this.EXCHANGE, routingKey, Buffer.from(message));
  }
}

工程示例:3


1 ) 方案1:NestJS微服务模块(官方推荐)

// app.module.ts
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
 
@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'RABBITMQ_SERVICE',
        transport: Transport.RMQ,
        options: {
          urls: ['amqp://user:pass@k8s-node:30672'], // K8s Service暴露的端口 
          queue: 'nestjs_queue',
          queueOptions: { durable: true },
        },
      },
    ]),
  ],
})
export class AppModule {}
 
// service.ts 
import { Inject, Injectable } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';
 
@Injectable()
export class TaskService {
  constructor(
    @Inject('RABBITMQ_SERVICE') private readonly client: ClientProxy,
  ) {}
 
  async publishEvent(data: any) {
    this.client.emit('task_created', data); // 发布事件到Exchange 
  }
 
  async sendCommand(data: any) {
    return this.client.send('process_task', data); // 发送RPC请求 
  }
}

2 ) 方案2:@golevelup/nestjs-rabbitmq(高级特性支持)

// app.module.ts 
import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
 
@Module({
  imports: [
    RabbitMQModule.forRoot(RabbitMQModule, {
      exchanges: [{ name: 'nestjs_exchange', type: 'topic' }],
      uri: 'amqp://user:pass@k8s-node:30672',
      connectionInitOptions: { wait: true },
    }),
  ],
})
export class AppModule {}
 
// processor.service.ts
import { RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
 
@Injectable()
export class TaskProcessor {
  @RabbitSubscribe({
    exchange: 'nestjs_exchange',
    routingKey: 'task.#',
    queue: 'worker_queue',
  })
  handleEvent(data: any) {
    console.log('Received task:', data);
  }
}

3 ) 方案3:原生amqplib(精细控制)

import * as amqp from 'amqplib';
 
export class RabbitMQConnector {
  private connection: amqp.Connection;
  private channel: amqp.Channel;
 
  async connect(url: string) {
    this.connection = await amqp.connect(url);
    this.channel = await this.connection.createChannel();
    await this.channel.assertExchange('dlx', 'direct', { durable: true }); // 死信交换器 
    await this.channel.assertQueue('tasks', {
      durable: true,
      deadLetterExchange: 'dlx', // 绑定死信队列
    });
  }
 
  async publish(exchange: string, routingKey: string, data: any) {
    this.channel.publish(
      exchange,
      routingKey,
      Buffer.from(JSON.stringify(data)),
      { persistent: true }, // 消息持久化 
    );
  }
 
  async consume(queue: string, callback: (msg: amqp.ConsumeMessage) => void) {
    const { consumerTag } = await this.channel.consume(queue, callback, {
      noAck: false, // 手动ACK 
    });
    return consumerTag;
  }
}

RabbitMQ运维关键配置


在K8s环境中需额外关注:

1 ) 持久化存储

# StatefulSet中追加 
volumeClaimTemplates:
 - metadata:
     name: rabbitmq-data 
   spec:
     accessModes: [ "ReadWriteOnce" ]
     storageClassName: "ssd"
     resources:
       requests:
         storage: 10Gi 

2 ) 资源配额与限流

resources:
 limits:
   cpu: "1"
   memory: "2Gi"
 requests:
   cpu: "500m"
   memory: "1Gi"

3 ) 生产环境安全加固

  • 禁用Guest账户(删除loopback_users.guest=true)
  • 启用TLS加密AMQP连接
  • 配置NetworkPolicy限制Pod网络访问

4 ) 监控方案

# 启用Prometheus指标插件 
kubectl exec rabbitmq-pod-0 -- rabbitmq-plugins enable rabbitmq_prometheus

集群运维关键操作手册


1 ) Kubernetes运维命令

# 部署集群 
kubectl apply -f rabbitmq.yaml -n test-rabbitmq
 
# 查看Pod状态
kubectl get pods -l app=rabbitmq -n test-rabbitmq 
 
# 日志诊断 
kubectl logs rabbitmq-0 -n test-rabbitmq 
 
# 集群扩缩容(调整节点数)
kubectl scale statefulset rabbitmq --replicas=5 -n test-rabbitmq 

2 ) RabbitMQ运维命令

# 检查集群节点状态
kubectl exec rabbitmq-0 -n test-rabbitmq -- rabbitmqctl cluster_status
 
# 重置节点(故障恢复场景)
kubectl exec rabbitmq-1 -n test-rabbitmq -- rabbitmqctl reset && rabbitmqctl start_app

# 创建管理账号(生产环境必须)
kubectl exec rabbitmq-0 -n test-rabbitmq -- \
  rabbitmqctl add_user admin StrongPassword! && \
  rabbitmqctl set_user_tags admin administrator

运维增强配置


  1. 健康检查命令

    # 节点状态检测
    kubectl exec rabbitmq-0 -- rabbitmq-diagnostics status
    
    # 集群状态查看
    kubectl exec rabbitmq-0 -- rabbitmqctl cluster_status 
    
  2. 关键调优参数

    # StatefulSet 资源限制
    resources:
      limits:
        memory: "2Gi"
        cpu: "1"
      requests:
        memory: "1Gi"
        cpu: "0.5"
    
    # 持久化存储(PVC示例)
    volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes: [ "ReadWriteOnce" ]
        storageClassName: "ssd"
        resources:
          requests:
            storage: 10Gi
    

部署与验证流程


1 ) 应用配置

kubectl apply -f rabbitmq-configmap.yaml
kubectl apply -f rabbitmq-service.yaml
kubectl apply -f rabbitmq-statefulset.yaml

2 ) 状态监控

# 查看Pod状态
kubectl get pods -n test-rabbitmq -l app=rabbitmq 

# 实时日志监控 
kubectl logs -f rabbitmq-0 -n test-rabbitmq

3 ) 访问控制台

http://<NodeIP>:31672 (使用配置文件中的 guest/guest 或预设凭证)

架构优势与生产建议


核心价值:

  1. 故障自愈:通过livenessProbe自动重启异常节点
  2. 弹性伸缩:StatefulSet支持秒级集群扩缩容
  3. 零单点故障:Service实现节点负载均衡
  4. 配置标准化:ConfigMap统一管理集群配置

生产环境关键配置

# rabbitmq-prod.yaml 
env:
- name: RABBITMQ_DEFAULT_USER 
  valueFrom:
    secretKeyRef:  # !!! 使用Secret存储凭证 !!!
      name: rabbitmq-credentials
      key: username 
- name: RABBITMQ_DEFAULT_PASS 
  valueFrom:
    secretKeyRef:
      name: rabbitmq-credentials
      key: password 
securityContext:
  readOnlyRootFilesystem: true  # 提升安全性 

最佳实践:

  1. 通过NetworkPolicy限制Pod网络访问
  2. 使用PersistentVolume持久化消息队列数据
  3. 配置ResourceQuota防止资源超限
  4. 启用PodDisruptionBudget保证维护期可用性

附录:NestJS集成配置详解


1 ) 安装必备依赖

npm install amqplib @nestjs/microservices 

2 ) 动态连接配置模块

// src/config/rabbitmq.config.ts
import { registerAs } from '@nestjs/config';
 
export default registerAs('rabbitmq', () => ({
  hosts: process.env.RABBITMQ_HOSTS.split(','),  // 集群节点地址 
  queueOptions: {
    durable: true,    // 持久化队列 
    messageTtl: 60000 // 消息过期时间
  },
  reconnectDelay: 5000  // 断线重连间隔
}));

3 ) 连接管理器实现

// src/messaging/connection-manager.ts 
import { Injectable, Logger } from '@nestjs/common';
import { connect, Connection } from 'amqplib';
 
@Injectable()
export class ConnectionManager {
  private connection: Connection;
  private readonly logger = new Logger(ConnectionManager.name);
 
  constructor(private readonly configService: ConfigService) {}
 
  async getConnection() {
    if (this.connection) return this.connection;
    
    const hosts = this.configService.get<string[]>('rabbitmq.hosts');
    for (const host of hosts) {
      try {
        this.connection = await connect(`amqp://${host}`);
        this.logger.log(`Connected to RabbitMQ at ${host}`);
        this.setupErrorHandlers();
        return this.connection;
      } catch (err) {
        this.logger.error(`Connection failed to ${host}`, err.stack);
      }
    }
    throw new Error('All RabbitMQ hosts unreachable');
  }
 
  private setupErrorHandlers() {
    this.connection.on('close', () => {
      this.logger.warn('Connection closed! Attempting reconnect...');
      setTimeout(() => this.reconnect(), 5000);
    });
  }
 
  private async reconnect() {
    this.connection = null;
    await this.getConnection();
  }
}

设计要点总结


1 ) 高可用保障

  • StatefulSet 确保节点唯一标识
  • Liveness/Readiness Probe 实现故障自愈
  • 跨节点部署避免单点故障

2 ) 安全增强

  • 生产环境必须禁用 loopback_users.guest
  • 通过 Secret 管理 Erlang Cookie
env:
- name: RABBITMQ_ERLANG_COOKIE
 valueFrom:
   secretKeyRef:
     name: rabbitmq-secret
     key: erlang-cookie

3 ) NestJS 集成最佳实践

  • 使用 amqplib 原生驱动保证性能
  • 消息确认机制防止数据丢失
  • 连接池复用 TCP 链接

性能数据:

  • 在 3 节点集群中,上述方案可达到:
    • 消息吞吐量 20,000+/秒
    • 故障转移时间 < 15秒(依赖 probe 配置)

总结

通过Kubernetes部署RabbitMQ集群,开发者可自动化实现故障转移、水平扩展和配置管理。核心要点包括:

  1. StatefulSet保障有状态服务的稳定拓扑和持久存储。
  2. 双探针机制(Liveness/Readiness)实现秒级故障自愈。
  3. NestJS微服务集成提供三种灵活方案,平衡开发效率与控制粒度。
  4. 生产级加固需关注持久化、资源隔离和网络安全。

最终部署验证:

kubectl create -f rabbitmq.yaml          # 部署集群 
kubectl get pods -n test-rabbitmq        # 查看Pod状态
kubectl logs rabbitmq-0 -c rabbitmq      # 检查节点日志 
RabbitMQ集群部署与高可用架构实战指南 消息队列作为分布式系统解耦的核心组件,其集群化部署是实现高可用的关键技术路径。RabbitMQ基于Erlang的分布式特性,通过镜像队列和节点协同机制,既保障了消息可靠性,又实现了水平扩展能力。在金融支付、电商订单等对数据一致性要求严格的场景中,合理配置磁盘节点与内存节点、优化镜像队列策略,可显著提升系统吞吐量并降低故障风险。本文结合生产环境实践,详解集群拓扑设计、关键参数调优及灾备方案,帮助开发者构建日均20亿级消息处理的稳定消息中间件架构。 阅读详情

相关推荐

在Kubernetes上部署RabbitMQ集群的完整指南

Kubernetes作为当前最流行的容器编排平台,它通过声明式API简化了复杂分布式系统的管理。通过部署、扩展和管理应用程序容器的生命周期,Kubernetes能够支持在物理或虚拟机集群上运行的容器化应用。Kubernetes不仅支持自动化部署、扩展和故障转移,还提供了负载均衡、服务发现、自动配置、批量执行和日志收集等高级功能。这使得Kubernetes成为管理大规模应用的理想选择。在Kubernetes中,Service资源是核心组件之一,它定义了一组Pod的访问策略。

weixin_42600407的博客 1303

k8s部署rabbitmq集群

k8s部署rabbitmq集群

ApexPredator的博客 1792

k8s下部署rabbitmq集群部署方式

包含k8s下部署rabbitmq集群部署方式的说明,有pv.yaml, svc.yaml, statefulset.yaml

在k8s上安装rabbitmq集群,附完整yaml文件

像rabbitmq集群这种有状态服务,在k8s里面部署还是挺复杂的,镜像里有些配置也跟平时部署不一样,很多人在创建StorageClass的时候也是一头雾水,这边直接提供yaml文件和针对特殊之处的解释。自备k8s集群,不会安装的也没必要看这篇。

草,卷起来了。 1054

U型槽微带贴片天线:从理论公式到带宽扩展实战

本文深入探讨了U型槽微带贴片天线的设计与带宽扩展实战。针对传统微带天线带宽窄的痛点,详细解析了通过引入U型槽形成双谐振点以拓宽带宽的原理,并提供了从MATLAB理论计算、ANSYS HFSS仿真建模到参数优化的一站式工程指南。文章还分享了多种带宽扩展组合技巧及仿真与实测避坑经验,助力射频工程师设计出高性能的宽带微带天线。

weixin_29168153的博客 455

TPAMI 2025新作LRFormer复现笔记:我的Windows 11 + RTX 4090配置全流程

本文详细记录了在Windows 11系统下使用RTX 4090显卡复现TPAMI 2025顶会论文LRTransformer的完整流程,包括硬件配置、系统优化、Python环境搭建及模型训练中的常见问题解决方案。特别针对Windows平台特有的路径管理、CUDA版本冲突和显存优化等关键技术细节提供了实用指南,帮助开发者高效完成环境搭建和模型训练。

weixin_29094301的博客 414

【k8s中安装rabbitmq】k8s中基于安装rabbitmq并搭建镜像集群-pvc版

该文搭建的rabbitmq集群是采用rabbitmq_peer_discovery_k8s的形式进行搭建,是通过该插件自动从k8s api中读取节点信息并组建rabbitmq集群,采用搭建方式是一个statefulset,三个副本的形式,所以要保证数据的持久可以采用hostpath+节点亲和性,也可以采用pvc的形式,本文将讲述采用pvc的形式来报障数据的持久化

weixin_56364253的博客 1773

VS2015+Qt+OpenCV+open62541开发过程(05_VS2015中使用OPCUA open62541通过Kepware读写PLC数据)

此外还需要所需lib包:WS2_32.Lib(opcua通讯用到的库,opcua使用socket通讯,需使用此库),添加#pragma comment(lib,"ws2_32.lib") 语句,有的文章说需要添加ws2_32.lib文件或ws2_32.dll到项目资源中,貌似影响不大。2.在VS中选择x64平台会报错,选择x86平台可以用,应该是ws2_32.lib相关的库不支持64位,目前没有解决,继续后面的实验,看看用Qt后是否可以解决。6.VS中建立的变量,与读取的OPC点数据类型注意对应。

zzh17的博客 1863

k8s部署rabbitmq集群(内网环境)

【代码】k8s部署rabbitmq集群(内网环境)

m0_63979533的博客 166

Halcon相机标定实战:从参数设置到精度优化全解析

本文详细解析Halcon相机标定的全流程,从基础概念到实战技巧,涵盖参数设置、精度优化及常见问题解决方案。通过实际案例和代码示例,帮助读者掌握工业视觉项目中相机标定的关键技术,提升测量精度和系统稳定性。

weixin_29279153的博客 323

人工智能——框架表示法

1975年美国明斯基在“A framework for representing knowledge”提出了框架理论。 1. 框架及框架的一般表示形式 框架:一种描述对象属性的数据结构。 框架的一般表示形式 <框架名> 槽名1: 侧面名1:值1,值2…,值p1 侧面名2:值1,值2…,值p2 侧面名2:值1,值2…,值pm1 槽名2: 侧面名...

weixin_33759269的博客 1642

《架构300讲》学习笔记(151-200)

《架构300讲》学习笔记(151-200)

CERTAINTY的博客 1288

YOLOv8/v9 遥感图像目标检测实战指南:建筑物检测与变化监测

遥感图像在城市规划、灾害评估、农业监管等领域应用广泛,但传统目标检测方法存在效率低、精度不足、难以适配遥感图像大尺寸、多尺度目标等问题。本文以“建筑物检测与变化监测”为核心,基于DOTA、NWPU VHR-10等公开数据集,系统讲解YOLOv8/v9在遥感图像中的实战流程。从数据获取、格式转换、模型训练优化,到大图切片推理、建筑物变化监测,全程提供可复现的代码与参数配置。通过针对性优化(旋转增强、切片推理等),模型在NWPU VHR-10数据集上mAP50达0.85以上,可适配卫星影像、无人机航拍等多场景

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 520

RabbitMQ面试精讲 Day 28:Docker与Kubernetes部署实践

RabbitMQ云原生部署,是指将RabbitMQ服务以容器化方式运行在Kubernetes等编排平台中,实现自动化部署、弹性伸缩、故障自愈和集中管理。由于RabbitMQ是有状态服务(Stateful Service),其部署需解决数据持久化、节点发现、配置统一、网络标识稳定等问题。核心原理:StatefulSet、Headless Service、PVC、自动集群发现完整配置:ConfigMap、环境变量、Service暴露高频面试题:StatefulSet必要性、自动加入、消息不丢失生产案例。

在未来等你的专栏 1540

机器人控制基础:伺服驱动电机 PID 参数自适应控制的实现方法及研究

伺服电机PID参数自适应控制技术研究 摘要:针对伺服驱动电机在动态负载工况下传统PID控制性能下降的问题,本文研究了多种自适应控制方法。通过分析6种主流技术(包括模型参考自适应、模糊逻辑、神经网络等)的原理、实现步骤及适用场景,揭示了负载感知精度、参数调节实时性和系统稳定性三大技术难点,并提出了相应解决方案。以模糊自适应PID为例的实验验证表明,该技术能有效提升伺服系统在变负载条件下的控制性能。研究为工业应用中伺服电机的精确控制提供了重要参考。

start_up_go的博客 829

基于Jeecgboot3.9.0的flowable7.2.0流程增加一个OA请假单功能例子(二)

基于Jeecgboot3.9.0的flowable7.2.0流程增加一个OA请假单功能例子(二)

宁波阿成的博客 202

RabbitMQ Kubernetes 对等发现插件(rabbitmq_peer_discovery_k8s)原理与配置指南

本文围绕 RabbitMQ 官方仓库 [deps/rabbitmq_peer_discovery_k8s](https://link.gitcode.com/i/87aeb511e58fb3af6fe48cb6e2437590) 中的插件文档展开,深入讲解 Kubernetes 环境下 RabbitMQ 集群自动组网的实现机制、默认行为与高级配置方法。读完本文,你将掌握 StatefulSet 序

gitblog_00220的博客 299

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

RabbitMQ高可用架构全揭秘:99.99%可靠性的实现之道

可用性等级等级年故障时间适用场景99%87.6小时非关键业务99.9%8.76小时普通企业99.99%52.6分钟金融系统99.999%5.26分钟支付核心💡 RabbitMQ通过集群+镜像队列可实现99.99%可用性真实案例支付宝:仲裁队列+5节点集群,99.999%可用京东618:镜像队列+自动扩容,峰值100万/秒特斯拉车联网:Federation跨洲集群,5机房同步学习资源最后结语:RabbitMQ的高可用设计如同为消息系统构建多重重力防护罩。

全栈开发工程师 1202

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

RabbitMQ故障恢复:集群节点故障自动切换机制

在分布式系统中,消息队列作为核心组件,其高可用性直接决定了业务连续性。RabbitMQ通过集群架构和自动故障转移机制,确保在节点失效时服务不中断。本文将深入解析RabbitMQ集群的故障检测、自动切换原理及实战配置,帮助运维人员构建 resilient 消息系统。 ## 集群架构与故障恢复基础 RabbitMQ集群由多个节点组成,通过共享元数据实现分布式协作。核心组件包括: - **Quor...

gitblog_00723的博客 1347

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

RabbitMQ云原生部署终极指南:Kubernetes Operator完整教程

RabbitMQ作为一款功能强大的开源消息代理,在云原生环境中部署时面临着集群管理、动态扩缩容和高可用性等挑战。而RabbitMQ Kubernetes Operator则提供了一种声明式的管理方式,让开发者能够轻松在K8s环境中部署和运维RabbitMQ集群。本文将从基础概念到实战操作,全面讲解如何利用Operator实现RabbitMQ的云原生部署。 ## 为什么选择Kubernetes O

gitblog_00001的博客 899

K8s 利用docker快速部署RabbitMQ集群

1.创建容器(所有节点都需要做) 1.1 宿主机环境 kubeadm-1.15.1 kubectl-1.15.1 kubelet-1.15.1 docker-19.03.13 1.2 三台节点配置信息 1.2创建持久数据目录和hosts配置 2.创建容器并运行(所有节点都需要做) 3.加入节点(除主节点的其他节点需要做) ...

qq_16397829的博客 556

erlang rabbitmq源码解析_k8s上创建高可用RabbitMQ集群

SK 服务器维护 在项目中需要业务解耦的时候要用着MQ,那么我们需要将RabbitMQ变的更加健壮和稳定,提高可用性。所有需要在kubernetes上创建高可用Rabbitmq集群或者在传统的服务器之间架设高可用的MQ集群。由于RabbitMQ是由Erlang写的,所以天生支持分布式。集群分类对等集群节点ha all 所有节点为对等体不对等集群节点disk ram 节点类型镜像队列策略根据策略进行...

weixin_39622084的博客 138

5分钟搭建跨地域高可用RabbitMQ集群:多数据中心部署指南

你是否正在为分布式系统的消息可靠性发愁?当单个数据中心故障导致整个消息队列瘫痪时,业务损失该如何挽回?本文将通过RabbitMQ的多数据中心部署方案,教你在30分钟内构建一个能抵御区域性故障的消息架构,确保订单、支付等核心业务消息零丢失。 ## 一、为何需要多数据中心架构? 现代企业IT架构中,单数据中心部署面临三大致命风险:极端天气导致机房断电、网络运营商光缆被挖断、硬件故障引发服务不可用。...

gitblog_00198的博客 980

RabbitMQ集群新范式:节点自动发现与智能组网全解析

你还在为手动配置RabbitMQ集群节点而头疼吗?面对云环境动态扩缩容时,是否常因节点IP变化导致集群不稳定?本文将彻底解决这些问题,通过剖析节点发现机制与自动集群形成原理,带你掌握企业级RabbitMQ集群的零接触部署方案。读完本文你将获得:3种主流发现模式的配置指南、故障自愈的实现原理、跨平台部署最佳实践,以及基于最新4.3.0版本的功能增强解析。 ## 集群发现机制核心架构 Rabbit...

gitblog_00058的博客 1093

大数据环境下 RabbitMQ 的容器化部署方案

在当今数据驱动的时代,大数据技术栈已成为企业处理海量信息的核心基础设施。作为分布式系统中解耦服务、削峰填谷的关键组件,消息队列承担着连接数据采集、处理与存储的重要角色。RabbitMQ 凭借其卓越的可靠性、灵活的路由策略和成熟的生态,在大数据流水线中得到了广泛应用。然而,传统物理机或虚拟机部署的 RabbitMQ 在面对大数据环境的挑战时,逐渐暴露出诸多痛点:环境一致性难以保证导致的"在我机器上能运行"问题、节点扩缩容效率低下无法应对流量波动、跨环境迁移复杂阻碍 DevOps 流程落地、运维成本高昂(尤其在

Agentic AI人工智能与大数据正在引领一场新智能科技革命。 982
上一篇: RabbitMQ: 基于Docker技术实施集群部署实战指南
下一篇: RabbitMQ: 集群网络分区的深度解析之意义、风险与处理策略
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、付费专栏及课程。

余额充值