1：环境准备
使用 hostnamectl 在三台机器上修改主机名 分别为 basic basic02 basic03
vi /etc/hosts 在三台机器上分别添加如下内容
192.168.217.128 basic
192.168.217.136 basic02
192.168.217.135 basic03
在生产环境需要开端口
4369 Erlang端口
25672 集群通信端口
15672 Rabbitmq管理控制台端口
5672 Rabbitmq服务端口
8100 HAProxy 配置监控页面绑定端口
5671 HAProxy rabbitmq_cluster集群通信端口
学习的时候只需要关闭防火墙
同时还需要关闭 selinux ，关闭selinux如果不关闭,会阻止其他的应用执行shell脚本
SELINUX=enforcing
#此项定义selinux状态。
#enforcing—是强制模式系统受selinux保护,违反了策略将无法继续操作
#permissive—是提示模式系统不会受到selinux保护,只是收到警告信息
permissive就是Selinux有效,但是即使你违反了策略任然可以继续操作
但是会把违反安全的内容记录下来(警告信息)
#disabled—禁用selinux
SELINUXTYPE=targeted
#此项定义selinux使用哪个策略模块保护系统。targeted只对apache,sendmail,bind,postgresql,nfs,cifs等网络服务保护。
以上策略配置都放置在/etc/selinux目录中，目录和策略名称相同
getenforce 查看 selinux 状态
setenforce 临时禁用 sudo setenforce 0 状态变为 Permissive
永久关闭SELINUX
修改方式1: vim /etc/selinux/config
修改 SELINUX=enforcing 为 SELINUX=disabled
reboot
修改方式2:
sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/selinux/config
grep SELINUX=disabled /etc/selinux/config
reboot
修改完成之后 查看状态
getenforce
2:Rabbitmq 安装
在三台机器都安装 Erlang 环境，因为 RabbitMQ 运行需要Erlang支持
安装步骤请参考 RabbitMQ 实战_Java 码农的博客-CSDN博客
3: 集群安装
当单台 RabbitMQ 服务器的处理消息的能力达到瓶颈时，此时可以通过 RabbitMQ 集群来进行扩展，从而达到提升吞吐量的目的。集群还有可以解决单点问题当节点挂掉以后，集群中的其他节点可以继续提供服务，当出现问题的几点修复后小虹心加入集群可以继续提供服务，节点间信息是相互同步的, RabbitMQ 集群是一个或多个节点的逻辑分组，集群中的每个节点都是对等的，每个节点共享所有的用户，虚拟主机，队列，交换器，绑定关系，运行时参数和其他分布式状态等信息.
3.1: 普通集群
在完成三台机器上的 Erlang 和 RabbitMq之后 ，将basic上的 .erlang.cookie文件拷贝到其他两台主机上(basic02,basic03) ，cookie文件相当于密钥令牌,集群中的RabbitMQ节点需要通过交换密钥令牌以获得相互认证，否则在搭建过程中会出现 Authentication Fail错误。RabbitMQ服务启动时，erlangVM会自动创建该cookie文件.
启动 rabbitmq 的时候 报错
rabbitmq-server -detached 会同时启动 Erlang 和 Rabbitmq
rabbitmqctl start_app 开启 rabbitmqctl start_app 关闭 (这两个只启动或关闭 Rabbitmq)
查看.erlang.cookie文件目录 默认的存储路径为 /var/lib/rabbitmq/.erlang.cookie
ls -la /var/lib/rabbitmq/
cat .erlang.cookie
查看 .erlang.cookie 的内容
关闭三个机器上的服务 rabbitmqctl stop
在basic 执行拷贝命令将.erlang.cookie 拷贝到basic02，basic03的/var/lib/rabbitmq/目录下
scp /var/lib/rabbitmq/.erlang.cookie root@basic02:/var/lib/rabbitmq/
scp /var/lib/rabbitmq/.erlang.cookie root@basic03:/var/lib/rabbitmq/
cookie文件原来的权限改为 400
再次查看.erlang.cookie 的内容，cookie 一致了
cat /root/.erlang.cookie
在三台主机上均执行以下命令，启动 RabbitMQ 服务
rabbitmqctl start_app
启动的时候可以看到三台机器的 hash 都是相同的了，说明 .erlang.cookie 一致并且生效了
rabbitmq-server -detached 命令会同时启动 Erlang 虚拟机和 RabbitMQ 应用服务而
rabbitmqctl start_app 只会启动 RabbitMQ 应用服务， rabbitmqctl stop_app 只会停止 RabbitMQ 服务
RabbitMQ 集群的搭建需要选择其中任意一个节点为基准
将其它节点逐步加入,这里我们以basic为基准节点将basic02 和 basic03 加入集群
在basic02 和 basic03 上执行以下命令:
basic02 上执行
# .启动服务
rabbitmqctl start_app
在basic03 上执行以下命令:
# .停止服务
rabbitmqctl stop_app
# .重置状态
rabbitmqctl reset
# .节点加入
rabbitmqctl join_cluster --disc rabbit@basic
# .启动服务
rabbitmqctl start_app
basic03 上执行
# .启动服务
rabbitmqctl start_app
在basic03 上执行以下命令:
# .停止服务
rabbitmqctl stop_app
# .重置状态
rabbitmqctl reset
# .节点加入
rabbitmqctl join_cluster --ram rabbit@basic02
# .启动服务
rabbitmqctl start_app
不要把两个节点都 往 basic 上挂 否者会报异常
Starting node rabbit@basic03 ...
Error:
{:rabbit, {{:timeout_waiting_for_tables, [:rabbit@basic02, :rabbit@basic, :rabbit@basic03], [:rabbit_delayed_messagerabbit@basic03, :rabbit_delayed_messagerabbit@basic03_index]}, {:rabbit, :start, [:normal, []]}}}
如果出现了这个异常 需要做如下步骤 (重要)
rabbitmqctl stop_app
rm -rf /var/lib/rabbitmq/mnesia/*
rabbitmqctl forget_cluster_node rabbit@basic03
在发生错误的节点执行
rabbitmqctl stop_app
删除 rm -rf /var/lib/rabbitmq/mnesia/* 删除 文件
主节点中将该节点移除集群： rabbitmqctl forget_cluster_node rabbit@发生错误的主机名basic03
然后 重启该节点
rabbitmqctl start_app
再此执行
# .停止服务
rabbitmqctl stop_app
# .重置状态
rabbitmqctl reset
# .节点加入
rabbitmqctl join_cluster --ram rabbit@basic02 把Basic03加入到Basic02 ，而不是 Basic
# .启动服务
rabbitmqctl start_app
此时一个普通集群就搭建起来了，我们可以查看管理控制台，
其他节点：
rabbitmqctl cluster_status 在任意一个节点查看集群状态
但是默认的这种集群，是无法在各个节点之间保存数据的，数据只会保存在接受到消息的节点上
当 ram 的节点挂了之后 数据会丢失
3.2: 镜像集群
开启镜像集群，这里我们为所有队列开启镜像配置，高可用策略，其语法如下：
rabbitmqctl set_policy ha-all "^" '{"ha-mode":"all"}' 表示开启HA模式 适用于所有的队列
在上面我们指定了 ha-mode 的值为 all ，代表消息会被同步到所有节点的相同队列中。这里我们之所以这样配置，因为我们本身只有三个节点，因此复制操作的性能开销比较小。如果你的集群有很多节点，那么此时复制的性能开销就比较大，此时需要选择合适的复制系数。通常可以遵循过半写原则，即对于一个节点数为 n 的集群，只需要同步到 n/2+1 个节点上即可。此时需要同时修改镜像策略为 exactly，并指定复制系数 ha-params，示例命令如下：
给默认的 所有的 添加高可用策略
rabbitmqctl set_policy ha-two "^" '{"ha-mode":"exactly","ha-params":2,"ha-sync-mode":"automatic"}'
给指定的 /MSA 添加高可用策略
rabbitmqctl set_policy ha-two "/MSA" '{"ha-mode":"exactly","ha-params":2,"ha-sync-mode":"automatic"}'
官网的 镜像高可用配置
Classic Queue Mirroring — RabbitMQ
其他策略配置
官网路径 Parameters and Policies — RabbitMQ
除此之外，RabbitMQ 还支持使用正则表达式来过滤需要进行镜像操作的队列，示例如下：
rabbitmqctl set_policy ha-all "^ha." '{"ha-mode":"all"}'
节点下线
以上介绍的集群搭建的过程就是服务扩容的过程，如果想要进行服务缩容，即想要把某个节点剔除集群，有两种可选方式：
第一种：可以先使用 rabbitmqctl stop 停止该节点上的服务，然后在其他任意一个节点上执行 forget_cluster_node 命令。
这里以剔除 basic03 上的服务为例，此时可以在 basic01 或 basic02 上执行下面的命令：
rabbitmqctl forget_cluster_node rabbit@basic03
第二种方式：先使用 rabbitmqctl stop 停止该节点上的服务，然后再执行 rabbitmqctl reset 这会清空该节点上所有历史数据，并主动通知集群中其它节点它将要离开集群。
没有一个直接的命令可以关闭整个集群，需要逐一进行关闭。但是需要保证在重启时，最后关闭的节点最先被启动。如果第一个启动的不是最后关闭的节点，那么这个节点会等待最后关闭的那个节点启动，默认进行 10 次连接尝试，超时时间为 30 秒，如果依然没有等到，则该节点启动失败
使用镜像集群的代码 后面还会贴上来：
依赖：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- 必须的依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.2.RELEASE</version>
<relativePath/>
</parent>
<groupId>org.rsp</groupId>
<artifactId>rabbitMQ-sp</artifactId>
<version>1.0-SNAPSHOT</version>
<name>rabbitMQ-sp</name>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- 必须的依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.amqp/spring-rabbit-test -->
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit-test</artifactId>
<version>2.3.10</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
<scope>provided</scope>
</dependency>
<!--swagger图形化接口 開始-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
<!--swagger图形化接口結束-->
<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
配置类
package org.rsp.config;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
/**
Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
Queue:消息的载体,每个消息都会被投到一个或多个队列。
Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
Producer:消息生产者,就是投递消息的程序.
Consumer:消息消费者,就是接受消息的程序.
Channel:消息通道,在客户端的每个连接里,可建立多个channel.
*/
@Slf4j
@Configuration
public class RabbitConfig2 {
@Value("${spring.rabbitmq.addresses}")
private String addresses;
@Value("${spring.rabbitmq.username}")
private String username;
@Value("${spring.rabbitmq.password}")
private String password;
public static final String EXCHANGE_A = "my-mq-exchange_A";
public static final String EXCHANGE_B = "my-mq-exchange_B";
public static final String EXCHANGE_C = "my-mq-exchange_C";
public static final String QUEUE_A = "QUEUE_A";
public static final String QUEUE_B = "QUEUE_B";
public static final String QUEUE_C = "QUEUE_C";
public static final String ROUTINGKEY_A = "spring-boot-routingKey_A";
public static final String ROUTINGKEY_B = "spring-boot-routingKey_B";
public static final String ROUTINGKEY_C = "spring-boot-routingKey_C";
//使用自定义工厂类的方式 ,这种方式适合于 要区别 不同的 vitural host 的时候
//需要将工厂类和模板类区根据业务别开的时候使用
@Bean
public ConnectionFactory connectionFactory() {
CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
connectionFactory.setAddresses(addresses);
connectionFactory.setUsername(username);
connectionFactory.setPassword(password);
connectionFactory.setVirtualHost("/MSA");
connectionFactory.setPublisherConfirms(true); //开启发布确认
return connectionFactory;
}
@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
//必须是prototype类型
public RabbitTemplate rabbitTemplate() {
RabbitTemplate template = new RabbitTemplate(connectionFactory());
return template;
}
//定义交换机 队列 路由 和绑定关系
/**
* 针对消费者配置
* 1. 设置交换机类型
* 2. 将队列绑定到交换机
FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念
HeadersExchange ：通过添加属性key-value匹配
DirectExchange:按照routingkey分发到指定队列
TopicExchange:多关键字匹配
*/
@Bean
public DirectExchange defaultExchange() {
return new DirectExchange(EXCHANGE_A);
}
/**
* 获取队列A
* @return
*/
@Bean
public Queue queueA() {
return new Queue(QUEUE_A, true); //队列持久
}
@Bean
public Binding binding() {
return BindingBuilder.bind(queueA()).to(defaultExchange()).with(RabbitConfig2.ROUTINGKEY_A);
}
}
配置文件：
spring:
rabbitmq:
addresses: 192.168.217.128:5672,192.168.217.135:5672,192.168.217.136:5672
username: developer
password: dev123456
virtual-host: /MSA
server:
port: 8888
生产者：
package org.rsp.producer;
import lombok.extern.slf4j.Slf4j;
import org.rsp.config.RabbitConfig2;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
@Slf4j
@Component
public class MsgProducer implements RabbitTemplate.ConfirmCallback {
//由于rabbitTemplate的scope属性设置为ConfigurableBeanFactory.SCOPE_PROTOTYPE，所以不能自动注入
private RabbitTemplate rabbitTemplate;
/**
* 构造方法注入rabbitTemplate
*/
@Autowired
public MsgProducer(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
rabbitTemplate.setConfirmCallback(this); //rabbitTemplate如果为单例的话，那回调就是最后设置的内容
}
public void sendMsg(String content) {
CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
//把消息放入ROUTINGKEY_A对应的队列当中去，对应的是队列A
rabbitTemplate.convertAndSend(RabbitConfig2.EXCHANGE_A, RabbitConfig2.ROUTINGKEY_A, content, correlationId);
}
/**
* 回调
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
log.info(" 回调id:" + correlationData);
if (ack) {
log.info("消息成功消费");
} else {
log.info("消息消费失败:" + cause);
}
}
}
消费者：
package org.rsp;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class TestConsumer {
@RabbitListener(queues = "spring-queue")
public void test(Message message){
log.info("收到下消息:"+message);
}
@RabbitListener(queues = "QUEUE_A")
public void test2(String content){
log.info("收到下消息:"+content);
}
}
发送消息的接口
package org.rsp;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class TestConsumer {
@RabbitListener(queues = "spring-queue")
public void test(Message message){
log.info("收到下消息:"+message);
}
@RabbitListener(queues = "QUEUE_A")
public void test2(String content){
log.info("收到下消息:"+content);
}
}
执行发送消息查看管理控制台
再查看 消费端的 控制台信息可以看到信息已经被消费了
至此 镜像集群的安装 链接 以及简单的代码演示完成
完整代码路径
https://github.com/wanglei111000/rabbitMqMirrorQueen
3.3 高可用集群
借鉴的网图，能说明我们想要搭建的高可用集群就可以了
在3.2中这种集群还有缺点 ，就是当我们的集群节点很多的时候，在做代码开发的时候，需要要在代码中写很多链接的IP信息，然而在很多大型的公司里面 这是不可取的，我们只想在代码里面写一个ip ，由负载均Haproxy 和 keppalived 来实现 ip 的漂移和故障转移.
按照架构图 三个镜像队列我们已经准备好了 ，还需要 两个 haproxy 和keepalive
3.3.1Haproxy 安装
https://www.haproxy.org/#down HAProxy 官网
https://src.fedoraproject.org/repo/pkgs/haproxy/ 镜像网站
tar -zxvf haproxy-2.4.8.tar.gz -C /usr/local
进入解压后根目录，执行下面的编译命令：
cd /usr/local
mkdir haproxy
cd haproxy-2.4.8
make TARGET=linux-glibc PREFIX=/usr/local/haproxy
make install PREFIX=/usr/local/haproxy
配置环境变量：vim /etc/profile
export HAPROXY_HOME=/usr/local/haproxy
export PATH=$PATH:$HAPROXY_HOME/sbin
使得配置的环境变量立即生效
source /etc/profile
新建配置文件 haproxy.cfg,位置为：/etc/haproxy/haproxy.cfg，文件内容如下
# 全局配置
global
# 日志输出配置、所有日志都记录在本机，通过 local0 进行输出
log 127.0.0.1 local0 info
# 最大连接数
maxconn 4096
# 改变当前的工作目录
chroot /usr/local/haproxy
# 以指定的 UID 运行 haproxy 进程
uid 99
# 以指定的 GID 运行 haproxy 进程
gid 99
# 以守护进行的方式运行
daemon
# 当前进程的 pid 文件存放位置
pidfile /usr/local/haproxy/haproxy.pid
# 默认配置
defaults
# 应用全局的日志配置
log global
# 使用4层代理模式，7层代理模式则为"http"
mode tcp
# 日志类别
option tcplog
# 不记录健康检查的日志信息
option dontlognull
# 3次失败则认为服务不可用
retries 3
# 每个进程可用的最大连接数
maxconn 2000
# 连接超时
timeout connect 5s
# 客户端超时
timeout client 120s
# 服务端超时
timeout server 120s
# 绑定配置
listen rabbitmq_cluster
bind :5671
# 配置TCP模式
mode tcp
# 采用加权轮询的机制进行负载均衡
balance roundrobin
# RabbitMQ 集群节点配置
server node1 basic:5672 check inter 5000 rise 2 fall 3 weight 1
server node2 basic02:5672 check inter 5000 rise 2 fall 3 weight 1
server node3 basic03:5672 check inter 5000 rise 2 fall 3 weight 1
# 配置监控页面
listen monitor
bind :8100
mode http
option httplog
stats enable
stats uri /stats
stats refresh 5s
查看 配置 cat /etc/haproxy/haproxy.cfg
负载均衡的主要配置在 listen rabbitmq_cluster 下，这里指定负载均衡的方式为加权轮询，同时定义好健康检查机制：
server node1 basic:5672 check inter 5000 rise 2 fall 3 weight 1
以上配置代表对地址为 basic:5672 的 node1 节点每隔 5 秒进行一次健康检查，如果连续两次的检查结果都是正常，则认为该节点可用，此时可以将客户端的请求轮询到该节点上；如果连续 3 次的检查结果都不正常，则认为该节点不可用。weight 用于指定节点在轮询过程中的权重
启动haproxy服务
haproxy -f /etc/haproxy/haproxy.cfg
查看 Haproxy 启动状态
http://192.168.217.128:8100/stats
http://192.168.217.135:8100/stats
可以看到发送消费消息数量已经被监控到
haProxy 安装完成
3.3.2： keepalive 安装配置
yum install -y keepalived
rpm -ql keepalived 查看 安装配置位置
cp /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf.bak 备份配置文件
修改 basic 中的 keepalived.conf
echo "" > keepalived.conf
vim keepalived.conf 添加如下内容
global_defs {
# 路由id,主备节点不能相同
router_id node1
}
# 自定义监控脚本
vrrp_script chk_haproxy {
# 脚本位置
script "/etc/keepalived/haproxy_check.sh"
# 脚本执行的时间间隔
interval 5
weight 10
}
vrrp_instance VI_1 {
# Keepalived的角色，MASTER 表示主节点，BACKUP 表示备份节点
state MASTER
# 指定监测的网卡，可以使用 ifconfig 进行查看
interface ens32
# 虚拟路由的id，主备节点需要设置为相同
virtual_router_id 1
# 优先级，主节点的优先级需要设置比备份节点高
priority 100
# 设置主备之间的检查时间，单位为秒
advert_int 2
# 定义验证类型和密码
authentication {
auth_type PASS
auth_pass w123456
}
# 调用上面自定义的监控脚本
track_script {
chk_haproxy
}
virtual_ipaddress {
# 虚拟IP地址，可以设置多个
192.168.217.200
}
}
修改 basic03 中的 keepalived.conf
echo "" > keepalived.conf
vim keepalived.conf 添加如下内容
global_defs {
# 路由id,主备节点不能相同
router_id node3
}
vrrp_script chk_haproxy {
script "/etc/keepalived/haproxy_check.sh"
interval 5
weight 10
}
vrrp_instance VI_1 {
# BACKUP 表示备份节点
state BACKUP
interface ens32
virtual_router_id 1
# 优先级，备份节点要比主节点低
priority 50
advert_int 2
authentication {
auth_type PASS
auth_pass w123456
}
track_script {
chk_haproxy
}
virtual_ipaddress {
192.168.217.200
}
}
cd /etc/keepalived/ 进入文件夹
分别在 basic 和 basic03 机器的 /etc/keepalived/ 编写一个文件haproxy_check.sh 内容是一致的
#!/bin/bash
# 判断haproxy是否已经启动
if [ ${ps -C haproxy --no-header |wc -l} -eq 0 ] ; then
#如果没有启动，则启动
haproxy -f /etc/haproxy/haproxy.cfg
fi
#睡眠3秒以便haproxy完全启动
sleep 3
#如果haproxy还是没有启动，此时需要将本机的keepalived服务停掉，以便让VIP自动漂移到另外一台haproxy
if [ ${ps -C haproxy --no-header |wc -l} -eq 0 ] ; then
systemctl stop keepalived
fi
创建后为其赋予执行权限： chmod +x /etc/keepalived/haproxy_check.sh
分别在 basic 和 basic03 上启动 KeepAlived 服务
service keepalived start 开启服务
systemctl stop keepalived 关闭服务
使用 ip a 命令查看到虚拟 IP 的情况
模拟basic 下线 ，虚拟ip 转移到basic03
重启 basic 和观察状态 会自动将虚拟ip 切回 ，而basic03 将自动切换为备份节点状态
自此 keepalived + haproxy + rabbitmq 高可用集群 搭建完成
3.3.3: 代码验证高可用集群
将我们之前直接连接镜像集群的代码 稍微做一点更改，然后启动服务 ，不停的发送消息
启动日志中可以发现 连接上了虚拟节点
可以看到 消息可以正常发送和接受
再查看 Haproxy 发现两个 haproxy 的节点上 收到了 不同的请求次数，说明负载均衡已经生效
现在将 basic 的节点 keepalived 下线 验证 是否可以正常发送和接受消息
service keepalived stop
查看 basic03 状态 ，虚拟节ip 转移 了
发消息 检查结果 ，发现 任然可以访问
其他情况 请自行验证 ，到此 高可用集群 搭建验证完毕
最后
以上就是飘逸项链最近收集整理的关于RabbitMQ HAProxy +Keepalived 高可用集群1：环境准备 2:Rabbitmq 安装3: 集群安装的全部内容，更多相关RabbitMQ内容请搜索靠谱客的其他文章。
发表评论 取消回复