Redis 哨兵模式实战

作者: GeekerLou | 来源:发表于2019-07-23 18:00 被阅读0次

主从切换技术方案是，当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这中间就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。

一、Redis哨兵模式概述

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

image

这里的哨兵有两个作用

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

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

用文字描述一下故障切换（failover）的过程。

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。这样对于客户端而言，一切都是透明的。

二、Redis哨兵模式配置实战

配置3个哨兵和1主2从的Redis服务器来演示这个过程。

服务类型	是否是主服务器	IP地址	端口
Redis	是	192.168.91.134	6379
Redis	否	192.168.91.137	6379
Redis	否	192.168.91.138	6379
Sentinel	-	192.168.91.134	26379
Sentinel	-	192.168.91.137	26379
Sentinel	-	192.168.91.138	26379

image

注意：修改配置文件之前记得先备份，免得操作失误无法回滚，切记！！！

首先配置Redis的主从服务器，修改redis.conf文件如下

# 以后台守护进程的方式启动
daemonize yes
# 使得Redis服务器可以跨网络访问
bind 0.0.0.0
# 设置密码
requirepass "123456"
# 指定主服务器，注意：有关slaveof的配置只是配置从服务器，主服务器不需要配置
slaveof 192.168.91.134  6379
# 主服务器密码，注意：有关slaveof的配置只是配置从服务器，主服务器不需要配置
masterauth 123456

其他可选修改：

# 默认端口为 6379
port 6381 
# 定义 Redis 日志文件路径，默认为空
logfile "/data/redis/logs/redis_6381.log"
# 定义 Redis 持久化文件路径，默认为 `./` 当前目录
dir /data/redis
# 定义已守护进程方式启动 Redis，默认为 no
daemonize yes
# 定义 pid 文件，默认为 redis_6379.pid
pidfile /var/run/redis_6381.pid
# 定义 RDB 持久化文件名，默认为 dump.rdb
dbfilename 6381.rdb
# 定义 AFO 持久化文件名，默认为 appendonly.aof
appendfilename "6381.aof"

上述内容主要是配置Redis服务器，从服务器比主服务器多一个slaveof的配置和密码。

配置3个哨兵，每个哨兵的配置都是一样的。在Redis安装目录下有一个sentinel.conf文件，copy一份进行修改

# 以后台守护进程的方式启动
daemonize yes
# 配置监听的主服务器，这里sentinel monitor代表监控，mymaster代表服务器的名称，可以自定义，192.168.91.134 代表监控的主服务器，6379代表端口，2代表只有两个或两个以上的哨兵认为主服务器不可用的时候，才会进行failover操作。
sentinel monitor mymaster 192.168.91.134  6379 2
# sentinel author-pa/requss定义服务的密码，mymaster是服务名称，123456是Redis服务器密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster 123456

有了上述的修改，我们可以进入Redis的安装目录，通过下面的命令启动redis服务器和Sentinel哨兵：

# 启动Redis服务器进程
./src/redis-server redis.conf
# 启动哨兵进程
./src/redis-sentinel  sentinel.conf

检查启动情况：

louxj424@ubuntu:~/Downloads/redis-2.8.17/src$ ps -ef|grep redis
louxj424  13544   7801  0 Jul22 pts/5    00:00:01 ./src/redis-server 0.0.0.0:6379
louxj424  15737  13602  0 Jul22 pts/15   00:00:02 ./src/redis-sentinel *:26379      
louxj424  18730   3593  0 00:06 pts/10   00:00:00 ./redis-cli
louxj424  19633  18984  0 00:09 pts/25   00:00:00 grep --color=auto redis

登录主节点：

louxj424@ubuntu:~/Downloads/redis-2.8.17/src$ ./redis-cli
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=192.168.91.137,port=6379,state=online,offset=86718,lag=0
slave1:ip=192.168.91.138,port=6379,state=online,offset=86575,lag=1
master_repl_offset:86718
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:86717

登录任一从节点：

127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> 
127.0.0.1:6379> info replication
# Replication
role:slave
master_host:192.168.91.134
master_port:6379
master_link_status:up
master_last_io_seconds_ago:0
master_sync_in_progress:0
slave_repl_offset:97799
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

从节点启动后从主节点同步信息的日志记录：

[8831] 23 Jul 00:01:34.420 # Server started, Redis version 2.8.17
[8831] 23 Jul 00:01:34.420 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
[8831] 23 Jul 00:01:34.420 * The server is now ready to accept connections on port 6379
[8831] 23 Jul 00:01:34.420 * Connecting to MASTER 192.168.91.134:6379
[8831] 23 Jul 00:01:34.421 * MASTER <-> SLAVE sync started
[8831] 23 Jul 00:01:34.421 * Non blocking connect for SYNC fired the event.
[8831] 23 Jul 00:01:34.421 * Master replied to PING, replication can continue...
[8831] 23 Jul 00:01:34.422 * Partial resynchronization not possible (no cached master)
[8831] 23 Jul 00:01:34.423 * Full resync from master: 35437a9a95f63757b24a70ed709d2eba72844af0:1
[8831] 23 Jul 00:01:34.449 * MASTER <-> SLAVE sync: receiving 18 bytes from master
[8831] 23 Jul 00:01:34.450 * MASTER <-> SLAVE sync: Flushing old data
[8831] 23 Jul 00:01:34.450 * MASTER <-> SLAVE sync: Loading DB in memory
[8831] 23 Jul 00:01:34.450 * MASTER <-> SLAVE sync: Finished with success

注意启动的顺序。首先是主Redis服务进程，然后启动从机的服务进程，最后启动3个哨兵的服务进程。

三、Java中使用哨兵模式

添加依赖：

<!--jedis连接客户端-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${jedis.version}</version>
        </dependency>

        <!--封装的Redis高级客户端-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>${spring-data-redis.version}</version>
        </dependency>

/**
 * 哨兵模式测试
 */
public class SentinelsTest extends BaseTest {

    @SuppressWarnings("resource")
    @Test
    public void testSentinel1() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(10);
        jedisPoolConfig.setMaxIdle(5);
        jedisPoolConfig.setMinIdle(5);
        // 哨兵信息
        Set<String> sentinels = new HashSet<>(Arrays.asList("192.168.91.134:26379",
                "192.168.91.137:26379", "192.168.91.138:26379"));
        // 创建连接池
        JedisSentinelPool pool = new JedisSentinelPool("mymaster", sentinels, jedisPoolConfig, "123456");
        // 获取客户端
        Jedis jedis = pool.getResource();
        // 执行两个命令
        jedis.set("mykey", "myvalue");
        String value = jedis.get("mykey");
        System.out.println(value);
        assertEquals("myvalue", value);
    }

上面是通过Jedis进行使用的，同样也可以使用Spring进行配置RedisTemplate使用。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <!--***哨兵模式部署的Redis集群Spring配置***-->

    <!--连接池配置-->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大空闲连接数 -->
        <property name="maxIdle" value="50"/>
        <!-- 最大连接数 -->
        <property name="maxTotal" value="100"/>
        <!-- 每次释放连接的最大数目 -->
        <property name="numTestsPerEvictionRun" value="1024"/>
        <!-- 释放连接的扫描间隔（毫秒） -->
        <property name="timeBetweenEvictionRunsMillis" value="30000"/>
        <!-- 连接最小空闲时间 -->
        <property name="minEvictableIdleTimeMillis" value="1800000"/>
        <!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
        <property name="softMinEvictableIdleTimeMillis" value="10000"/>
        <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
        <property name="maxWaitMillis" value="1500"/>
        <!-- 在获取连接的时候检查有效性, 默认false -->
        <property name="testOnBorrow" value="false"/>
        <!-- 在空闲时检查有效性, 默认false -->
        <property name="testWhileIdle" value="true"/>
        <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
        <property name="blockWhenExhausted" value="false"/>
    </bean>

    <!-- 哨兵配置 -->
    <bean id="sentinelConfig" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
        <!-- 服务名称 -->
        <property name="master">
            <bean class="org.springframework.data.redis.connection.RedisNode">
                <property name="name" value="mymaster" />
            </bean>
        </property>

        <!-- 哨兵服务IP和端口 -->
        <property name="sentinels">
            <set>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.91.134" />
                    <constructor-arg name="port" value="26379" />
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.91.137" />
                    <constructor-arg name="port" value="26379" />
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.91.138" />
                    <constructor-arg name="port" value="26379" />
                </bean>
            </set>
        </property>
    </bean>

    <!--连接工厂类-->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg name="poolConfig" ref="poolConfig" />
        <constructor-arg name="sentinelConfig" ref="sentinelConfig" />
        <property name="password" value="123456" />
    </bean>

    <!-- JDK序列化器 -->
    <bean id="jdkSerializationRedisSerializer"
          class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />

    <!-- String序列化器 -->
    <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />

    <!--操作句柄之RedisTemplate-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="keySerializer" ref="stringRedisSerializer" />
        <property name="valueSerializer" ref="jdkSerializationRedisSerializer" />
        <property name="defaultSerializer" ref="stringRedisSerializer" />
    </bean>

    <!--操作句柄之jedisSentinelPool-->
    <bean id = "jedisSentinelPool" class="redis.clients.jedis.JedisSentinelPool">
       <constructor-arg name="masterName" value="mymaster"/>
        <constructor-arg name="sentinels" >
            <set>
                <value>192.168.91.134:26379</value>
                <value>192.168.91.137:26379</value>
                <value>192.168.91.138:26379</value>
            </set>
        </constructor-arg>
        <constructor-arg name="poolConfig" ref="poolConfig" />
        <constructor-arg name="password" value="123456" />
    </bean>
    </beans>

/**
 * 哨兵模式测试
 */
public class SentinelsTest extends BaseTest {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testSentinel2() {
        redisTemplate.opsForValue().set("tt","myvalue");
        String value = (String)redisTemplate.opsForValue().get("tt");
        System.out.println(value);
        assertEquals("myvalue", value);
    }
}

有人可能比较习惯于使用Jedis操作，那么可以基于JedisSentinelPool封装一下常用的操作，下面举一些Demo，后续可以根据自身需求添加即可：
JedisSentinelService

public interface JedisSentinelService {

    void set(String key, String value);

    String get(String key);

    boolean tryGetDistributedLock(String lockKey, String requestId, int expireTime);

    boolean releaseDistributedLock(String lockKey, String requestId);
}

JedisSentinelServiceImpl

@Service
public class JedisSentinelServiceImpl implements JedisSentinelService {

    private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";
    private static final Long RELEASE_SUCCESS = 1L;

    @Autowired
    @Qualifier("jedisSentinelPool")
    private JedisSentinelPool jedisSentinelPool;

    private static final Logger logger = LoggerFactory.getLogger(JedisSentinelServiceImpl.class);

    private Jedis getJedis() {
        Jedis jedis = null;
        try {
            jedis = jedisSentinelPool.getResource();
        } catch (Exception e) {
            logger.error("get jedis error: JedisPool getResource.", e);
            if (jedis != null) {
                jedisSentinelPool.returnResource(jedis);
            }
            throw e;
        }
        return jedis;
    }

    protected void release(Jedis jedis, boolean isBroken) {
        if (jedis != null) {
            if (isBroken) {
                jedisSentinelPool.destroy();
                logger.error("connection is broken");
            } else {
                jedisSentinelPool.destroy();
                logger.error("connection closed successfully");
            }
        }
    }

    @Override
    public void set(String key, String value) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            jedis.set(key, value);
        } catch (Exception e) {
            isBroken = true;
            this.release(jedis, isBroken);
        }
    }

    @Override
    public String get(String key) {
        Jedis jedis = null;
        boolean isBroken = false;
        String result = null;
        try {
            jedis = this.getJedis();
            result = jedis.get(key);
        } catch (Exception e) {
            isBroken = true;
            this.release(jedis, isBroken);
        }
        return result;
    }

    /**
     * 尝试获取分布式锁
     *
     * @param lockKey    锁
     * @param requestId  请求标识
     * @param expireTime 超期时间
     * @return 是否获取成功
     */
    @Override
    public boolean tryGetDistributedLock(String lockKey, String requestId, int expireTime) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
            if (LOCK_SUCCESS.equals(result)) {
                String value = jedis.get(lockKey);
                logger.info("set {} = {}", lockKey, value);
                return true;
            }
        } catch (Exception e) {
            isBroken = true;
            this.release(jedis, isBroken);
        }
        return false;
    }

    /**
     * 释放分布式锁
     *
     * @param lockKey   锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    @Override
    public boolean releaseDistributedLock(String lockKey, String requestId) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = this.getJedis();
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
            if (RELEASE_SUCCESS.equals(result)) {
                return true;
            }
        } catch (Exception e) {
            isBroken = true;
            this.release(jedis, isBroken);
        }
        return false;
    }
}

写个类简单测试一下：

public class SentinelsTest extends BaseTest {

    @Autowired
    private JedisSentinelService jedisSentinelService;
      
       @Test
    public void testSentinel3() {
        jedisSentinelService.set("mykey", "myvalue");
        String value = jedisSentinelService.get("mykey");
        System.out.println(value);
        assertEquals("myvalue", value);
    }
}

四、哨兵模式的其他配置项

配置项	参数类型	作用
port	整数	启动哨兵进程端口
dir	文件夹目录	哨兵进程服务临时文件夹，默认为/tmp，要保证有可写入的权限
sentinel down-after-milliseconds	<服务名称><毫秒数（整数）>	指定哨兵在监控Redis服务时，当Redis服务在一个默认毫秒数内都无法回答时，单个哨兵认为的主观下线时间，默认为30000（30秒）
sentinel parallel-syncs	<服务名称><服务器数（整数）>	指定可以有多少个Redis服务同步新的主机，一般而言，这个数字越小同步时间越长，而越大，则对网络资源要求越高
sentinel failover-timeout	<服务名称><毫秒数（整数）>	指定故障切换允许的毫秒数，超过这个时间，就认为故障切换失败，默认为3分钟
sentinel notification-script	<服务名称><脚本路径>	指定sentinel检测到该监控的redis实例指向的实例异常时，调用的报警脚本。该配置项可选，比较常用

sentinel down-after-milliseconds配置项只是一个哨兵在超过规定时间依旧没有得到响应后，会自己认为主机不可用。对于其他哨兵而言，并不是这样认为。哨兵会记录这个消息，当拥有认为主观下线的哨兵达到sentinel monitor所配置的数量时，就会发起一次投票，进行failover，此时哨兵会重写Redis的哨兵配置文件，以适应新场景的需要。

五、干货总结

线上Redis集群的高可用推荐一主两从三哨兵（至少一主一从三哨兵），内存淘汰策略为allkey-lru。

Redis 哨兵模式实战

一、Redis哨兵模式概述

二、Redis哨兵模式配置实战

三、Java中使用哨兵模式

四、哨兵模式的其他配置项

五、干货总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读