Redis主从+哨兵配置(简洁、清晰)

服务器一主二从、三哨兵

IP职责
192.168.6.50Master 、Sentinel
192.168.6.51Slave 、 Sentinel
192.168.6.52Slave 、 Sentinel

一、主从配置

1.1 Master配置(/etc/redis/redis.conf)

port 6379
masterauth "redis_pwd" #这里三台redis我使用了相同的密码，便于哨兵在master故障之后重新恢复时连接其他的redis

# bind 127.0.0.1 ::1 # 注释掉bind
protected-mode no
requirepass "redis_pwd"

1.2 其他两台Slave配置

port 6379
replicaof 192.168.6.50 6379
masterauth "redis_pwd"

# bind 127.0.0.1 ::1 # 注释掉bind
protected-mode no
requirepass "redis_pwd"

1.3 开启与检验

systemctl start redis # 分别在每台服务器开启redis
redis-cli
info replication # 检验master与slave角色是否正确

二、哨兵Sentinel配置

apt install redis-sentinel # 首先安装哨兵

# 三台服务器上都部署上哨兵，配置除了announce-ip都一样
port 6380 # 哨兵端口
# sentinel monitor <master-name> <ip> <redis-port> <quorum> quorum即是同意切换故障master的最小哨兵数
sentinel monitor mymaster 192.168.6.50 6379 2
sentinel auth-pass mymaster redis_pwd # 设置redis密码
sentinel announce-ip "192.168.6.51" # sentinel所在的本机ip

# 别忘了注释bind 

# 启动
systemctl start redis-sentinel

三、SpringBoot配置

详细源码可见github，如果对你有帮助，希望给个star吖！

# application.yml
spring:
  redis:
    database: 3
    password: redis_pwd
    timeout: 2000
    sentinel: # 哨兵配置
      master: mymaster
      nodes: 192.168.6.50:6380,192.168.6.51:6380,192.168.6.52:6380
    lettuce:
      pool:
        max-idle: 20
        min-idle: 10
        max-active: 50
        max-wait: 1000

@Configuration
@EnableCaching
public class RedisConfig {
    
    @Value("${spring.redis.database}")
    private int database;

    @Value("${spring.redis.password}")
    private String password;

    @Value("#{'${spring.redis.sentinel.nodes}'.split(',')}")
    private Set<String> sentinelCluster;

    @Value("${spring.redis.sentinel.master}")
    private String sentinelName;

    @Value("${spring.redis.timeout}")
    private long timeout;

    @Value("${spring.redis.lettuce.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.lettuce.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.lettuce.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.lettuce.pool.max-wait}")
    private long maxWait;

    @Bean("connectionFactory")
    public LettuceConnectionFactory getConnectionFactory() {
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(2000);
        //哨兵模式
        RedisSentinelConfiguration configuration = new RedisSentinelConfiguration(sentinelName, sentinelCluster);
        configuration.setDatabase(database);
        configuration.setPassword(RedisPassword.of(password));
        // 集群模式
        // RedisClusterConfiguration configuration2 = new RedisClusterConfiguration();

        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(genericObjectPoolConfig)
                .build();
        LettuceConnectionFactory factory = new LettuceConnectionFactory(configuration, clientConfig);
        // 使用前先校验连接
        factory.setValidateConnection(true);
        return factory;
    }
}

hhhhh