Windows 下 redis 哨兵模式（一主一从两哨兵）

tizzybepeacejoy

已于 2023-03-31 17:51:07 修改

阅读量2.8k

点赞数

分类专栏： Redis 文章标签： redis 数据库缓存

于 2020-03-06 17:24:06 首次发布

本文链接：https://blog.csdn.net/weixin_38361347/article/details/104689239

版权

Redis 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

前言

有了主从模式，主库如果发生故障，从库可以转为主库，这时候我们需要对redis进行监控，此时就需要用到redis中的哨兵机制。

哨兵是建立在主从模式基础之上

哨兵模式是redis 2.x 版本提供的，3.x 版本的时候一般我们使用 redis集群 cluster
在这里插入图片描述

redis 哨兵模式

哨兵模式

这里我们使用一个主节点（主）和一个子节点（从）

从节点使用哨兵模式进行监控主节点，如果主挂了，从库自动升级为主节点，等待主库恢复了，主库会自动变为从库。

但此时，如果升级为主库的从节点挂了，此时变为从库的主节点不会变为主库，出现这种问题，我们一般采用的是主从都进行哨兵模式配置，互相监控对方，从而达到高可用。

配置哨兵

redis 主 port 6380 Sentinel （哨兵端口）26380
redis 从 port 6381 Sentinel （哨兵端口）26381

由于windows版本的redis没有 Sentinel.conf文件所以在redis的文件中创建一个
在这里插入图片描述

主服务6380 哨兵监听从节点6381


# 当前Sentinel服务运行的端口
port 26380
#master
sentinel monitor master 127.0.0.1 6381 1
sentinel down-after-milliseconds master 5000
sentinel failover-timeout master 180000
sentinel parallel-syncs master 1

从节点6381 哨兵监听主服务6380


# 当前Sentinel服务运行的端口
port 26381

# Sentinel去监视一个名为mymaster的主redis实例，
# 这个主实例的IP地址为本机地址127.0.0.1，端口号为6379，
# 而将这个主实例判断为失效至少需要2个 Sentinel进程的同意，
# 只要同意Sentinel的数量不达标，自动failover就不会执行

 # 这个一定设置为 no 或者这里不设置  需要在哨兵中关闭保护模式。
# protected-mode no

# 指定了Sentinel认为Redis实例已经失效所需的毫秒数。
# 当 实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。
# 只有一个 Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行

sentinel monitor mymaster 127.0.0.1 6380 1

# 指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，在从Redis实例较多的情况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长

sentinel down-after-milliseconds mymaster 5000

# 如果在该时间（ms）内未能完成failover操作，则认为该failover失败

sentinel failover-timeout mymaster 10000

启动redis
redis-server.exe redis.windows.conf

启动哨兵
redis-server.exe sentinel.conf --sentinel

停止6380 主节点，查看从节点6381 可以看到升为主节点了

可以从6381哨兵中看到
在这里插入图片描述

在启动6380 主节点，可以看到 6380主节点转为6380的从节点

可以在6380的哨兵中看到
在这里插入图片描述

一主一从两哨兵的目的是

主库挂了从升级为主库，原来主库恢复了之后成为从库

升级为主库的从库挂了之后，降为从库的主库再升级为主句

两者进行切换

可以在redis中用命令info replication查看，这里是切换之后的

主
在这里插入图片描述
从

至于如何在代码中使用？

这里演示Spring Boot 项目中，配置文件直接配置即可。

# redis 主从哨兵配置
spring:
  redis:
    database: 0
    host: 127.0.0.1 #主节点的地址
    port: 6379
    password:
    pool:
      max-active: 8
      max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
      max-idle: 8
      min-idle: 0
    timeout: 0
    # 主节点哨兵名
    sentinel:
      master: mymaster #这个需要和主节点哨兵配置文件中的保持一致
      # comma-separated list of host:port pairs  哨兵节点配置列表
      nodes: 127.0.0.1:26380,127.0.0.1:26381

需要注意的是，这里默认从主库读写。

如果要配置，需要配置一下。

这里我用 springboot 2.0.8.RELEASE 这个版本

redis 版本

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.1.4.RELEASE</version>
<!--            <version>2.6.3</version>-->
        </dependency>

package com.xxxxxx.component.redis;


import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializeWriter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import io.lettuce.core.ReadFrom;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericToStringSerializer;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.HashSet;

@Configuration
public class RedisConfig {

//    @Value("${spring.redis.sentinel.master}")
//    private String sentinelMaster;
//
//    @Value("${spring.redis.sentinel.nodes}")
//    private String sentinelNodes;

    /**
     * 改用fastjson redis序列化，请删除redis数据后使用此序列化
     *
     * @param redisConnectionFactory
     * @return
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {


        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        GenericToStringSerializer<String> stringRedisSerializer = new GenericToStringSerializer<>(String.class);
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        FastJsonConfig fastJsonConfig = fastJsonRedisSerializer.getFastJsonConfig();
        SerializeConfig serializeConfig = fastJsonConfig.getSerializeConfig();
        //加入的locadatetime序列化，也可以不加（但是要用@JSONField(format = "yyyy-MM-dd HH:mm:ss")）格式化
        serializeConfig.put(LocalDateTime.class, (serializer, object, fieldName, fieldType, features) -> {
            SerializeWriter out = serializer.out;
            if (object == null) {
                out.writeNull();
                return;
            }
            out.writeString(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format((LocalDateTime) object));
        });
        serializeConfig.put(LocalDate.class, (serializer, object, fieldName, fieldType, features) -> {
            SerializeWriter out = serializer.out;
            if (object == null) {
                out.writeNull();
                return;
            }
            out.writeString(DateTimeFormatter.ofPattern("yyyy-MM-dd").format((LocalDate) object));
        });
        serializeConfig.put(LocalTime.class, (serializer, object, fieldName, fieldType, features) -> {
            SerializeWriter out = serializer.out;
            if (object == null) {
                out.writeNull();
                return;
            }
            out.writeString(DateTimeFormatter.ofPattern("HH:mm:ss").format((LocalTime) object));
        });
        fastJsonConfig.setSerializeConfig(serializeConfig);
        fastJsonConfig.setFeatures(Feature.SupportAutoType);
        fastJsonConfig.setSerializerFeatures(SerializerFeature.WriteClassName);
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }


    @Bean
    public RedisConnectionFactory lettuceConnectionFactory(RedisProperties redisProperties) {
//        RedisURI node1 = RedisURI.create("127.0.0.1", 7000);
//        RedisURI node2 = RedisURI.create("127.0.0.1", 7001);
//        RedisURI node3 = RedisURI.create("127.0.0.1", 7002);
//        RedisClusterClient client = RedisClusterClient.create(Arrays.asList(node1, node2, node3));
//        StatefulRedisClusterConnection con = client.connect();
//        con.setReadFrom(ReadFrom.SLAVE_PREFERRED);
//


        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration(
                redisProperties.getSentinel().getMaster(), new HashSet<>(redisProperties.getSentinel().getNodes())
        );


        LettucePoolingClientConfiguration lettuceClientConfiguration = (LettucePoolingClientConfiguration) LettucePoolingClientConfiguration.builder()
                //优先读取主节点，如果主节点不可用，则读取从节点
                .readFrom(ReadFrom.MASTER_PREFERRED)
                //优先读取从节点，如果从节点不可用，则读取主节点
//                .readFrom(ReadFrom.UPSTREAM_PREFERRED)
                //从任意一个从节点读取
//                .readFrom(ReadFrom.ANY_REPLICA)
                .build();

        return new LettuceConnectionFactory(redisSentinelConfiguration, lettuceClientConfiguration);

    }


}

根据

ReadFrom中策略进行读取

在这里插入图片描述

这个版本中只有如下这些读写策略

在这里插入图片描述

设置可以这样设置一下


    @Bean
    public RedisConnectionFactory lettuceConnectionFactory(RedisProperties redisProperties) {

        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration(
                redisProperties.getSentinel().getMaster(), new HashSet<>(redisProperties.getSentinel().getNodes())
        );


//这里强转一下
        LettucePoolingClientConfiguration lettuceClientConfiguration = (LettucePoolingClientConfiguration) LettucePoolingClientConfiguration.builder()
                //优先读取主节点，如果主节点不可用，则读取从节点
                .readFrom(ReadFrom.MASTER_PREFERRED)
                //优先读取从节点，如果从节点不可用，则读取主节点
//                .readFrom(ReadFrom.UPSTREAM_PREFERRED)
                //从任意一个从节点读取
//                .readFrom(ReadFrom.ANY_REPLICA)
                .build();

        return new LettuceConnectionFactory(redisSentinelConfiguration, lettuceClientConfiguration);

    }

而在 spring-boot-starter-data-redis 2.6.3版本中，策略枚举值相对较多，可以根据自己需求设置。
在这里插入图片描述

设置和上面设置一样，但不需要强转，直接设置即可。当然springboot版本也需要提供，尽可能和redis版本相差不大。

在这里插入图片描述

如何查看自己redis是从哪个库读取数据的，可以debug打印日志看一下redis的地址。

这里在我们测试服务测的日志，可以看到读和写的链接地址是不同的。

服务器测试程序中，131是写库，121 是读库，策略我是使用 ReadFrom.SLAVE_PREFERRED 优先从从库读

在这里插入图片描述

tizzybepeacejoy

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
2
评论
Windows 下 redis 哨兵模式（一主一从两哨兵）

前言有了主从模式，主库如果发生故障，从库可以转为主库，这时候我们需要对redis进行监控，此时就需要用到redis中的哨兵机制。哨兵是建立在主从模式基础之上哨兵模式是redis 2.x版本提供的，3.x版本的时候一般我们使用 redis集群 clusterredis 哨兵模式哨兵模式这里我们使用一个主节点（主）和一个子节点（从）从节点使用哨兵模式进行监控主节点，如果主挂了，从库自动...
复制链接

扫一扫