SpringBoot如何整合Redis哨兵集群？高并发场景方案

来源：互联网 2026-07-26 08:37:02

Redis高可用依赖主从复制与哨兵机制。主从复制实现数据冗余、读写分离及故障恢复，通过异步复制保证数据一致性；哨兵自动监控主节点状态，在宕机时执行自动故障转移，选举新主节点并通知客户端，确保服务持续可用。

Redis 高可用环境搭建

概念：

主从复制，就是把一台 Redis 服务器的数据复制到其他 Redis 服务器上。前者称为主节点（master/leader），后者称为从节点（slave/follower）。复制是单向的，只能从主节点到从节点。Master 主要负责写操作，Slave 主要负责读操作。

长期稳定更新的攒劲资源： >>>点此立即查看<<<

默认情况下，每台 Redis 服务器都是主节点。一个主节点可以拥有多个从节点（也可以没有），但一个从节点只能有一个主节点。

主从复制的主要作用包括：

1. 数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。

2. 故障恢复：当主节点出现问题时，可以直接使用从节点提供服务，实现快速故障恢复，这实际上是服务的冗余。

3. 负载均衡：在主从复制的基础上，结合读写分离，主节点提供写服务，从节点提供读服务。写 Redis 时连接主节点，读 Redis 时连接从节点，分担服务器负载。尤其是在写少读多的场景下，使用多个从节点分担读负载，可以大幅提升 Redis 服务器的并发能力。

4. 高可用（集群）基石：除了上述作用，主从复制还是哨兵和集群能够实施的基础，因此主从复制是 Redis 高可用的根基。

一般来说，要将 Redis 真正用于工程项目，仅靠一台 Redis 是远远不够的——一旦宕机，所有服务都会中断。原因很简单：

1. 从结构上看，单台 Redis 存在单点故障，且所有请求负载都集中在一台机器上，压力太大。

2. 从容量上看，单台 Redis 的内存容量有限，即使一台机器有 256GB 内存，也不能全部分配给 Redis 使用。通常单台 Redis 的最大使用内存不应超过 20GB。电商网站的商品，基本都是一次上传、无数次浏览，典型的是读多写少。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

主从复制，读写分离！80% 的情况都是在执行读操作，可以有效减轻服务器压力。架构中经常使用，最少也是一主二从。

环境配置

只需要配置从库即可，主库不需要配置（Redis 默认自己就是主库）。

主从复制（一主二从）单台服务器搭建

1. 搭建集群前，建议创建一个 redis-cluster 文件夹，方便管理。

mkdir redis-cluster

2. 上传 redis-6.2.6.tar.gz。可以到官网下载后上传到服务器。

3. 解压并完成单机安装。

[root@instance-ou4346s0 software]# tar -zxvf redis-6.2.6.tar.gz
mv redis-6.2.6 /usr/local/lixiaoxing/redis-cluster/
mv redis-6.2.6/ redis-6381
# 安装gcc环境，因为redis是C语言写的，需要环境
yum install gcc-c++
# 编译与安装
cd /usr/local/lixiaoxing/redis-cluster/redis-6381
make
cd ./src
make install

完成如下：

SpringBoot如何整合Redis哨兵集群？高并发场景方案

4. 为了方便管理，将 redis 文件中的 conf 配置文件和常用命令移到统一文件夹中。

（1）创建 bin 文件夹

mkdir bin

SpringBoot如何整合Redis哨兵集群？高并发场景方案

（2）将安装好的 redis-6.2.4 改名为 redis-6381 方便维护。将 redis-6381 目录下的 redis.conf 移到 bin 文件夹下。再将 mkreleasehdr.sh、redis-benchmark、redis-check-aof、redis-cli、redis-server 移到 /usr/local/redis-5.0.0/bin/ 目录下。

[root@instance-ou4346s0 redis-6381]# mv redis.conf  bin
[root@instance-ou4346s0 redis-6381]# cd src/
[root@instance-ou4346s0 src]# mv mkreleasehdr.sh redis-benchmark redis-check-aof redis-cli redis-server /usr/local/lixiaoxing/redis-cluster/redis-6381/bin/
# 修改配置
[root@instance-ou4346s0 redis-6381]# cd bin
[root@instance-ou4346s0 bin]# vim redis.conf

（3）将文件中的 daemonize 属性改为 yes（表示需要在后台运行）。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

（4）编辑 redis.conf，开启远程访问服务。

（1）将 bind 127.0.0.1 这一行注释掉。这里的 bind 指的是只有指定的网段才能远程访问，注释后就没有限制了。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

（2）将 protected-mode 设置为 no（默认是 yes，防止远程访问，redis 3.2.3 版本后）。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

（3）修改默认密码（默认密码为空）。在配置文件中找到 # requirepass foobared，去掉注释，将 foobared 改为自己的密码，或者另起一行 requirepass 自己的密码。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

（4）端口号改为 6381。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

5. 启动服务。

[root@instance-ou4346s0 bin]# ./redis-server redis.conf

查看 redis 是否有进程。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

单机版完成

安装完成，查看当前库的信息。

启动redis服务
./redis-cli
# 连接服务端：./redis-server --port 端口号  如果更换端口号了就输入这个指令
# client端：./redis-cli -p 端口号 -h 127.0.0.1
# NOAUTH Authentication required. 需要登录， auth 123456
127.0.0.1:6379>clear
127.0.0.1:6379> info replication
# 出现报错，输入redis的当前密码
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> info replication
# Replication
role:master                        # 主节点
connected_slaves:0                 # 连接的从机 0
master_failover_state:no-failover
master_replid:fbdfc1384c1ed87a0bf85ffde924714e4ff3a728
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

6. 配置日志，方便以后查看。

（1）配置 logfile，这是日志存放位置。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

（2）配置 dbfilename 修改 db 名称。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

（3）配置 pidfile。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

保存！

7. 在 redis-cluster 目录中将 redis 名称修改为 redis-6381，然后复制两份，分别改名为 redis-6382、redis-6383。同时修改每个 redis.conf 下的端口号，分别为 6381、6382、6383。修改 logfile 等配置，然后启动 redis。

cp redis-6381/ redis-6382 -r
cp redis-6381/ redis-6383 -r

SpringBoot如何整合Redis哨兵集群？高并发场景方案

启动 Redis。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

启动以后，现在开始配置一主二从模式。

./redis.cli     或者
[root@instance-ou4346s0 bin]# ./redis-cli -p 6381
127.0.0.1:6381> clear
127.0.0.1:6381> info replication
NOAUTH Authentication required.   # 从机登录授权 auth 密码

6381

SpringBoot如何整合Redis哨兵集群？高并发场景方案

6382

SpringBoot如何整合Redis哨兵集群？高并发场景方案

6383

SpringBoot如何整合Redis哨兵集群？高并发场景方案

随意指定其他两台redis服务器为从机，6381为主机
在6382和6383上使用 SLAVEOF 127.0.0.1 6381
配置2台从机器指定127.0.0.1:6381为主机
当然通过命令行的方式来配置主机，只是临时配置，如果要从Redis启动时就配置好需连接的主机，就需要修改配置文件中的 replicaof 即可

6381

SpringBoot如何整合Redis哨兵集群？高并发场景方案

127.0.0.1:6381> info replication
# Replication
role:master                                                           # 角色 主机
connected_slaves:2                                                    # 两个从机
slave0:ip=127.0.0.1,port=6383,state=online,offset=168,lag=0
slave1:ip=127.0.0.1,port=6382,state=online,offset=168,lag=0
master_failover_state:no-failover
master_replid:634ba5af8b23268c22bc1a3b39b6d7b215ba5d4a
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:168
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:168

6382

SpringBoot如何整合Redis哨兵集群？高并发场景方案

127.0.0.1:6382> info replication
# Replication
role:slave                                                             # 角色从机
master_host:127.0.0.1                                                  # 主机信息
master_port:6381
master_link_status:up
master_last_io_seconds_ago:3
master_sync_in_progress:0
slave_repl_offset:238
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:634ba5af8b23268c22bc1a3b39b6d7b215ba5d4a
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:238
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:57
repl_backlog_histlen:182

6383同上

注意：这种配置，从机重启以后会自动变成主机。所以想要永久配置，就需要在从机配置文件 redis.conf 中配置永久选项。这里需要注意，如果配置了密码，建议每个 redis 都要写上密码，这样哨兵部分才不会出错。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

配置主机地址，有密码也要配置密码。

replicaof
masterauth

SpringBoot如何整合Redis哨兵集群？高并发场景方案

主机密码这样写最好。配置成功保存退出，查看当前从机是否配置成功，关闭重启，看看重启后从机角色不变就说明配置成功了。

细节：

主机可读可写，从机只能读。主机中所有的信息和数据，都会自动被从机保存。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

如果尝试在从机中存数据，会报错。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

测试：

（1）主机断开连接，从机依旧连接到主机，但没有写操作。如果主机再回来，从机依旧可以直接获取到主机写的信息。

（2）如果使用命令行配置的主从，重启后从机都会变成主机。但只要变为从机，立刻就会从主机中获取值。

主从复制原理

（1）Slave 启动成功连接到 Master 后，会发送一个 sync 同步命令。

（2）Master 接收命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集的命令。后台进程执行完毕后，将整个数据文件发送给 Slave，完成一次完全同步。

（3）全量复制：Slave 服务接收到数据文件后，将其存盘并加载到内存中。

（4）增量复制：Master 继续将新的收集到的修改命令依次传给 Slave，完成同步。

（5）只要重新连接 master，一次完全同步（全量复制）就会被自动执行。

哨兵模式

哨兵作用

通过发送命令，让 Redis 服务器返回监控其运行状态，包括主服务器和从服务器。
当哨兵监测到 master 宕机，会自动将 slave 切换成 master，然后通过发布订阅模式通知其他从服务器，修改配置文件让它们切换主机。

单哨兵

主从切换的传统方法是：主服务器宕机后，需要手动把一台从服务器切换为主服务器，这需要人工干预，还会造成一段时间内服务不可用。Redis 从 2.8 开始正式提供了 Sentinel（哨兵模式）来解决这个问题。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

1. 配置单哨兵模式来监管 redis。

（1）在 redis-cluster 目录下创建 redis-sentinel 方便管理哨兵。从一个 redis 目录的 src 目录中把 redis-sentinel 和 redis 目录下的 sentinel.conf 复制到 redis-sentinel。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

注意：如果主机此时回来，只能归并到新的主机下，当做从机，这就是哨兵模式的规则。

注意:此报错是密码没有配置
Next failover delay: I will not start a failover before Thu Nov 25 21:04:25 2021

按需配置：一般配置连接、主密码、日志位置、daemonize 等。

# Example sentinel.conf
# 哨兵sentinel实例运行的端口 默认26379
port 26379
# 哨兵sentinel的工作目录
dir /tmp
# 哨兵sentinel监控的redis主节点的 ip port
# master-name 可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了
# sentinel monitor    
sentinel monitor mymaster 127.0.0.1 6379 1   # 配置连接
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass  
sentinel auth-pass mymaster 12345678   # 主密码，不设置的话不能动态切换
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
# sentinel down-after-milliseconds  
sentinel down-after-milliseconds mymaster 30000
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行同步，这个数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为replication而不可用。可以通过将这个值设为 1 来保证每次只有一个slave处于不能处理命令请求的状态。
# sentinel parallel-syncs  
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间 failover-timeout 可以用在以下这些方面：
# 1. 同一个sentinel对同一个master两次failover之间的间隔时间。
# 2. 当一个slave从一个错误的master那里同步数据开始计算时间，直到slave被纠正为向正确的master那里同步数据时。
# 3. 当想要取消一个正在进行的failover所需要的时间。
# 4. 当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout  
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
# 配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
# 对于脚本的运行结果有以下规则：
# 若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
# 若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
# 如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
# 一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
# 通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
# 通知脚本
# sentinel notification-script  
sentinel notification-script mymaster /var/redis/notify.sh
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
# 以下参数将会在调用脚本时传给脚本:
#       
# 目前总是“failover”,
# 是“leader”或者“observer”中的一个。
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script  
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

测试：

我们停了 6381，sentinel 会自动选取一个从机做服务器。最开始的主机重启后，只能配置做从机。被 sentinel 选取的从机做主机后，配置文件也会发生改变，所以不用担心。

3882:X 25 Nov 2021 22:58:31.771 # +failover-end master mymaster 127.0.0.1 6381
3882:X 25 Nov 2021 22:58:31.771 # +switch-master mymaster 127.0.0.1 6381 127.0.0.1 6383
3882:X 25 Nov 2021 22:58:31.771 * +slave slave 127.0.0.1:6382 127.0.0.1 6382 @ mymaster 127.0.0.1 6383
3882:X 25 Nov 2021 22:58:31.771 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ mymaster 127.0.0.1 6383

多哨兵

单哨兵存在一个问题：如果那个哨兵挂了怎么办？那就没人监控了。所以在生产环境中通常会部署多个哨兵同时监控 Redis，并且多个哨兵之间也相互监控。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

假设主服务器宕机，哨兵1先检测到这个结果，系统不会马上进行 failover 过程，仅仅是哨兵1主观认为主服务器不可用，这叫主观下线。当其他哨兵也检测到主服务不可用，并且数量达到一定值，这些哨兵之间就会进行一次投票，投票由某个哨兵发起，进行 failover（故障转移）操作。切换成功后，通过发布订阅模式，让各哨兵把自己监控的从服务器实现切换主机，这就是客观下线。

多哨兵搭建

1. 为了方便管理，在 redis-sentinel 目录下创建一个 redis-sentinel-1，把刚才的单机 sentinel 配置文件复制到这个目录下。

[root@instance-ou4346s0 redis-sentinel]# mkdir redis-sentinel-1
[root@instance-ou4346s0 redis-sentinel]# mv redis-sentinel redis-sentinel-1/

SpringBoot如何整合Redis哨兵集群？高并发场景方案

2. 配置 sentinel.conf：redis-sentinel-2 的端口为 26380，redis-sentinel-3 为 26381，日志文件和 pid 文件也要更换。分别配置如下：

# 添加守护进程模式
daemonize yes
# 添加指明日志文件名
logfile "/opt/redis/6379/sentinel26379.log"
# 修改工作目录
dir "/opt/redis/6379"
# 修改启动端口
port 26379
# 关闭保护模式
protected-mode no
# 修改sentinel monitor
sentinel monitor redis-test-master 192.168.29.128 6379 2
# 将配置文件中mymaster全部替换为redis-test-master
# 依次修改26380,26381
# 配置说明：
# redis-test-master:监控主数据的名称，自定义即可，可以使用大小写字母和“.-_”符号
# 192.168.29.128:监控的主数据库的IP
# 6379:监控的主数据库的端口
# 2:最低通过票数
# 端口默认为26379。
port:26379
# 关闭保护模式，可以外部访问。
protected-mode:no
# 设置为后台启动。
daemonize:yes
# 日志文件。
logfile "/usr/local/lixiaoxing/redis-cluster/redis-sentinel/sentinel.log"
# pid位置
pidfile "/usr/local/lixiaoxing/redis-cluster/redis-sentinel/redis-sentinel.pid"
# 指定主机IP地址和端口，并且指定当有2台哨兵认为主机挂了，则对主机进行容灾切换。
sentinel monitor mymaster 127.0.0.1 6382 2
# 当在Redis实例中开启了requirepass，这里就需要提供密码。
sentinel auth-pass mymaster 12345678
# 这里设置了主机多少秒无响应，则认为挂了。
sentinel down-after-milliseconds mymaster 30000
# 主备切换时，最多有多少个slave同时对新的master进行同步，这里设置为默认的1。
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间，这里设置为三分钟。
sentinel failover-timeout mymaster 180000

监控设置成两个投票就主观下线。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

哨兵模式常用命令

1. 查看sentinel的基本状态信息
127.0.0.1:26379> INFO
2. 列出所有被监视的主服务器，以及这些主服务器的当前状态
127.0.0.1:26379> SENTINEL MASTERS redis-test-master
3. 列出给定主服务器的所有从服务器，以及这些从服务器的当前状态
127.0.0.1:26379> SENTINEL SLAVES redis-test-master
4. 返回给定名字的主服务器的IP地址和端口号
127.0.0.1:26379> SENTINEL GET-MASTER-ADDR-BY-NAME redis-test-master
5. 重置所有名字和给定模式pattern相匹配的主服务器，重置操作清除主服务器目前的所有状态，包括正在执行中的故障转移，并移除目前已经发现和关联的，主服务器的所有从服务器和Sentinel
127.0.0.1:26379> SENTINEL RESET redis-test-master
6. 当主服务器失效时，在不询问其他Sentinel意见的情况下，强制开始一次自动故障迁移，但是它会给其他Sentinel发送一个最新的配置，其他sentinel会根据这个配置进行更新
127.0.0.1:26379> SENTINEL FAILOVER redis-test-master
7. 查看其它哨兵信息
127.0.0.1:26379> SENTINEL sentinels redis-test-master

SpringBoot如何整合Redis哨兵集群？高并发场景方案

出现以上信息后，sentinel 集群配置成功。

sentinel 的 log 日志查看：

26379 日志

SpringBoot如何整合Redis哨兵集群？高并发场景方案

26380 日志

SpringBoot如何整合Redis哨兵集群？高并发场景方案

26381 日志

SpringBoot如何整合Redis哨兵集群？高并发场景方案

SpringBoot 整合一主二从加哨兵：

server:
  port: 8081
# 单节点+哨兵
spring:
  redis:
    sentinel:
      nodes: 192.168.109.160:26379,192.168.109.163:26379,192.168.109.164:26379
      password: root
      master: mymaster
    password: root
# 单节点
#spring:
#  redis:
#    host: 192.168.109.160
#    port: 6379
#    timeout: 10000
#    password: root

Redis 集群搭建（3主3从）

本文是在一台服务器上搭建的，如果需要分布式部署，也可以参考。

1. 准备一台服务器，开启端口号 6381,6382,6383,6384,6385,6386。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

2. 下载解压安装一个 redis，具体操作参考前面的单机安装。然后创建一个 redis-cluster 文件目录，把单机 redis 移动到这个目录中，并修改名称为 6381。

[root@instance-ou4346s0 lixiaoxing]# mv redis-6.2.6/ redis-cluster/
[root@instance-ou4346s0 redis-cluster]# mv redis-6.2.6/ redis-6381

3. 开始安装。

（1）如果 centos 中没有 gcc 环境，则需要安装 gcc 环境，如果有直接下一步。

[root@localhost tools]# yum install -y gcc

（2）进入 redis-6381 中，编译安装。

[root@localhost tools]# cd redis-6381/
[root@localhost redis-6381]# make
[root@localhost redis-6381]# cd src
[root@instance-ou4346s0 src]# make install
[root@instance-ou4346s0 redis-6381]# echo $   # 执行这句如果出现0表示编译成功

（3）为了方便管理，在 redis-6381 目录下创建 bin 目录、log 目录、data 目录。

[root@instance-ou4346s0 redis-6381]# mkdir bin && mkdir data && mkdir log

（4）将 redis-6381/src 目录下的 redis-server、redis-check-aof、redis-check-rdb、redis-cli、mkreleasehdr.sh 移动到 redis-6381/bin 目录下，再把 redis-6381 下的 redis.conf 也移动到 bin。

[root@instance-ou4346s0 src]# mv redis-server redis-check-aof redis-check-rdb redis-cli mkreleasehdr.sh /usr/local/lixiaoxing/redis-cluster/redis-6381/bin
[root@instance-ou4346s0 redis-6381]# mv redis.conf bin/

（5）配置 master 6381 下的 redis.conf。

[root@instance-ou4346s0 bin]# vim redis.conf
# 绑定服务器域名或IP地址
bind redis-166     # 如果多台服务器部署的话绑定的ip+端口，如果是单台建议注销掉
# 关闭远程保护
protected-mode no
# 设置端口，区分集群中Redis的实例
port 6381
# 后台运行
daemonize yes
# pid进程文件名，以端口号命名
pidfile /usr/local/lixiaoxing/redis-cluster/redis-6381/data/redis_6381.pid
# 日志文件名称，以端口号为目录来区分
logfile "/usr/local/lixiaoxing/redis-cluster/redis-6381/data/redis_6381.log"
# 数据文件存放地址，以端口号为目录名来区分
dir /usr/local/lixiaoxing/redis-cluster/redis-6381/data
# 启用集群
cluster-enabled yes
# 配置每个节点的配置文件，同样以端口号为名称
cluster-config-file nodes_7001.conf
# 配置集群节点的超时时间
cluster-node-timeout 15000
# 启动AOF增量持久化策略
appendonly yes
# 保存名称
appendfilename "appendonly-6381.aof"
# 发生改变，则记录日志
appendfsync always

配置 master 6382 下的 redis.conf（把 redis-6381 复制成 redis-6382）。

[root@instance-ou4346s0 redis-cluster]# cp redis-6381/ redis-6382 -r
# 绑定服务器域名或IP地址
bind redis-166
# 关闭远程保护
protected-mode no
# 设置端口，区分集群中Redis的实例
port 6382
# 后台运行
daemonize yes
# pid进程文件名，以端口号命名
pidfile /usr/local/lixiaoxing/redis-cluster/redis-6382/data/redis_6382.pid
# 日志文件名称，以端口号为目录来区分
logfile "/usr/local/lixiaoxing/redis-cluster/redis-6382/log/redis_6382.log"
# 数据文件存放地址，以端口号为目录名来区分
dir /usr/local/lixiaoxing/redis-cluster/redis-6382/data
# 启用集群
cluster-enabled yes
# 配置每个节点的配置文件，同样以端口号为名称
cluster-config-file nodes-6382.conf
# 配置集群节点的超时时间
cluster-node-timeout 15000
# 启动AOF增量持久化策略
appendonly yes
# 保存名称
appendfilename "appendonly-6382.aof"
# 发生改变，则记录日志
appendfsync always

然后按需复制，6381 复制成 6383、6385，6382 复制成 6384、6386，并修改每个 redis 的配置文件。

SpringBoot如何整合Redis哨兵集群？高并发场景方案

一个一个启动很麻烦，可以写脚本。使用 touch 命令创建运行脚本，其中 redis-cli --cluster create 命令是创建集群的命令。

[root@instance-ou4346s0 redis-cluster]# touch start-redis-cluster.sh
[root@instance-ou4346s0 redis-cluster]# chmod +x start-redis-cluster.sh
[root@instance-ou4346s0 redis-cluster]# vim start-redis-cluster.sh
# 编辑内容
cd /usr/local/lixiaoxing/redis-cluster/redis-6381/bin
./redis-server redis.conf
sleep 5
cd /usr/local/lixiaoxing/redis-cluster/redis-6382/bin
./redis-server redis.conf
sleep 5
cd /usr/local/lixiaoxing/redis-cluster/redis-6383/bin
./redis-server redis.conf
sleep 5
cd /usr/local/lixiaoxing/redis-cluster/redis-6384/bin
./redis-server redis.conf
sleep 5
cd /usr/local/lixiaoxing/redis-cluster/redis-6385/bin
./redis-server redis.conf
sleep 5
cd /usr/local/lixiaoxing/redis-cluster/redis-6386/bin
./redis-server redis.conf
sleep 5
cd /usr/local/lixiaoxing/redis-cluster/redis-6386/bin
./redis-cli --cluster create 192.168.16.4:6381 192.168.16.4:6383 192.168.16.4:6385 192.168.16.4:6382 192.168.16.4:6384 192.168.16.4:6386 --cluster-replicas 1
# 编辑完成保存并退出
# 启动
[root@instance-ou4346s0 redis-cluster]# ./start-redis-cluster.sh

SpringBoot如何整合Redis哨兵集群？高并发场景方案

输入 yes 同意。然后进行测试。

[root@instance-ou4346s0 bin]# ./redis-cli -c -h 180.76.242.96 -p 6381
180.76.242.96:6381> set 1 hello redis
# 输入以后出现以下数据代表成功
-> Redirected to slot [9842] located at 192.168.16.4:6383
OK
[root@instance-ou4346s0 bin]# ./redis-cli -c -h 180.76.242.96 -p 6386
# 取出来
180.76.242.96:6386> get 1
-> Redirected to slot [9842] located at 192.168.16.4:6383
"li"
成功

至此集群搭建完毕！