基于Redis Sentinel主从切换以及Sharding分片的Redis集群高可用方案
2017-04-30 21:16
1171 查看
本文主要介绍一种通过Jedis&Sentinel实现Redis集群高可用方案,该方案需要使用Jedis2.2.2及以上版本(强制),Redis2.8及以上版本(可选,Sentinel最早出现在Redis2.4中,Redis2.8中Sentinel更加稳定),Redis集群是以分片(Sharding)加主从的方式搭建,满足可扩展性的要求;
监控,能持续监控Redis的主从实例是否正常工作;
通知,当被监控的Redis实例出问题时,能通过API通知系统管理员或其他程序;
自动故障恢复,如果主实例无法正常工作,Sentinel将启动故障恢复机制把一个从实例提升为主实例,其他的从实例将会被重新配置到新的主实例,且应用程序会得到一个更换新地址的通知。
Redis Sentinel是一个分布式系统,可以部署多个Sentinel实例来监控同一组Redis实例,它们通过Gossip协议来确定一个主实例宕机,通过Agreement协议来执行故障恢复和配置变更,一般在生产环境中部署多个实例来提高系统可用性,只要有一个Sentinel实例运行正常,就能保证被监控的Redis实例运行正常(类似Zookeeper,通过多个Zookeeper来提高系统可用性);
本文不涉及Sentinel的实现细节和工作原理,读者可以阅读其他文章了解;
1,keepalived:通过keepalived的虚拟IP,提供主从的统一访问,在主出现问题时,通过keepalived运行脚本将从提升为主,待主恢复后先同步后自动变为主,该方案的好处是主从切换后,应用程序不需要知道(因为访问的虚拟IP不变),坏处是引入keepalived增加部署复杂性;
2,zookeeper:通过zookeeper来监控主从实例,维护最新有效的IP,应用通过zookeeper取得IP,对Redis进行访问;
3,sentinel:通过Sentinel监控主从实例,自动进行故障恢复,该方案有个缺陷:因为主从实例地址(IP&PORT)是不同的,当故障发生进行主从切换后,应用程序无法知道新地址,故在Jedis2.2.2中新增了对Sentinel的支持,应用通过redis.clients.jedis.JedisSentinelPool.getResource()取得的Jedis实例会及时更新到新的主实例地址。
笔者所在的公司先使用了方案1一段时间后,发现keepalived在有些情况下会导致数据丢失,keepalived通过shell脚本进行主从切换,配置复杂,而且keepalived成为新的单点,后来选用了方案3,使用Redis官方解决方案;(方案2需要编写大量的监控代码,没有方案3简便,网上有人使用方案2读者可自行查看)
Sentinel&Jedis看上去是个完美的解决方案,这句话只说对了一半,在无分片的情况是这样,但我们的应用使用了数据分片-sharing,数据被平均分布到4个不同的实例上,每个实例以主从结构部署,Jedis没有提供基于Sentinel的ShardedJedisPool,也就是说在4个分片中,如果其中一个分片发生主从切换,应用所使用的ShardedJedisPool无法获得通知,所有对那个分片的操作将会失败。
本文提供一个基于Sentinel的ShardedJedisPool,能及时感知所有分片主从切换行为,进行连接池重建,源码见ShardedJedisSentinelPool.java
类似之前的Jedis Pool的构造方法,需要参数poolConfig提供诸如maxIdle,maxTotal之类的配置,masters是一个List,用来保存所有分片Master在Sentinel中配置的名字(注意master的顺序不能改变,因为Shard算法是依据分片位置进行计算,如果顺序错误将导致数据存储混乱),sentinels是一个Set,其中存放所有Sentinel的地址(格式:IP:PORT,如127.0.0.1:26379),顺序无关;
在构造函数中,通过方法
取得当前所有分片的master地址(IP&PORT),对每个分片,通过顺次连接Sentinel实例,获取该分片的master地址,如果无法获得,即所有Sentinel都无法连接,将休眠1秒后继续重试,直到取得所有分片的master地址,代码块如下:
通过
初始化连接池,到此连接池中的所有连接都指向分片的master;
在方法
最后,会为每个Sentinel启动一个Thread来监控Sentinel做出的更改:
该线程的run方法通过Jedis Pub/Sub API(实现JedisPubSub接口,并通过jedis.subscribe进行订阅)向Sentinel实例订阅“+switch-master”频道,当Sentinel进行主从切换时,该线程会得到新Master地址的通知,通过master name判断哪个分片进行了切换,将新master地址替换原来位置的地址,并调用initPool(List masters)进行Jedis连接池重建;后续所有通过该连接池取得的连接都指向新Master地址,对应用程序透明;
总结
本文通过现实中遇到的问题,即在Redis数据分片的情况下,在使用Sentinel做HA时,如何做到主从的切换对应用程序透明,通过Jedis的Pub/Sub功能,能同时监控多个分片的主从切换情况,并通过监听到的新地址重新构造连接池,后续从连接池中取得的所有连接都指向新地址。该方案的关键是:使用sentinel做HA,Jedis版本必须2.2.2及以上,所有访问Redis实例的连接都必须从连接池中获取;
该项目的GitHub主页: https://github.com/warmbreeze/sharded-jedis-sentinel-pool
==================================以下有代验证==============================================
==================================以下有代验证==============================================
补丁很简单,就是参照Jedis的ShardedJedisPool,覆写一些资源管理的方法。
Redis Sentinel介绍
Redis Sentinel是Redis官方提供的集群管理工具,主要有三大功能:监控,能持续监控Redis的主从实例是否正常工作;
通知,当被监控的Redis实例出问题时,能通过API通知系统管理员或其他程序;
自动故障恢复,如果主实例无法正常工作,Sentinel将启动故障恢复机制把一个从实例提升为主实例,其他的从实例将会被重新配置到新的主实例,且应用程序会得到一个更换新地址的通知。
Redis Sentinel是一个分布式系统,可以部署多个Sentinel实例来监控同一组Redis实例,它们通过Gossip协议来确定一个主实例宕机,通过Agreement协议来执行故障恢复和配置变更,一般在生产环境中部署多个实例来提高系统可用性,只要有一个Sentinel实例运行正常,就能保证被监控的Redis实例运行正常(类似Zookeeper,通过多个Zookeeper来提高系统可用性);
本文不涉及Sentinel的实现细节和工作原理,读者可以阅读其他文章了解;
Redis HA方案
HA的关键在于避免单点故障及故障恢复,在Redis Cluster未发布之前,Redis一般以主/从方式部署(这里讨论的应用从实例主要用于备份,主实例提供读写,有不少应用是读写分离的,读写操作需要取不同的Redis实例,该方案也可用于此种应用,原理都是相通的,区别在于数据操作层如何封装),该方式要实现HA主要有如下几种方案:1,keepalived:通过keepalived的虚拟IP,提供主从的统一访问,在主出现问题时,通过keepalived运行脚本将从提升为主,待主恢复后先同步后自动变为主,该方案的好处是主从切换后,应用程序不需要知道(因为访问的虚拟IP不变),坏处是引入keepalived增加部署复杂性;
2,zookeeper:通过zookeeper来监控主从实例,维护最新有效的IP,应用通过zookeeper取得IP,对Redis进行访问;
3,sentinel:通过Sentinel监控主从实例,自动进行故障恢复,该方案有个缺陷:因为主从实例地址(IP&PORT)是不同的,当故障发生进行主从切换后,应用程序无法知道新地址,故在Jedis2.2.2中新增了对Sentinel的支持,应用通过redis.clients.jedis.JedisSentinelPool.getResource()取得的Jedis实例会及时更新到新的主实例地址。
笔者所在的公司先使用了方案1一段时间后,发现keepalived在有些情况下会导致数据丢失,keepalived通过shell脚本进行主从切换,配置复杂,而且keepalived成为新的单点,后来选用了方案3,使用Redis官方解决方案;(方案2需要编写大量的监控代码,没有方案3简便,网上有人使用方案2读者可自行查看)
选用Sentinel出现的问题
Sentinel&Jedis看上去是个完美的解决方案,这句话只说对了一半,在无分片的情况是这样,但我们的应用使用了数据分片-sharing,数据被平均分布到4个不同的实例上,每个实例以主从结构部署,Jedis没有提供基于Sentinel的ShardedJedisPool,也就是说在4个分片中,如果其中一个分片发生主从切换,应用所使用的ShardedJedisPool无法获得通知,所有对那个分片的操作将会失败。 本文提供一个基于Sentinel的ShardedJedisPool,能及时感知所有分片主从切换行为,进行连接池重建,源码见ShardedJedisSentinelPool.java
ShardedJedisSentinelPool实现分析
构造函数
类似之前的Jedis Pool的构造方法,需要参数poolConfig提供诸如maxIdle,maxTotal之类的配置,masters是一个List,用来保存所有分片Master在Sentinel中配置的名字(注意master的顺序不能改变,因为Shard算法是依据分片位置进行计算,如果顺序错误将导致数据存储混乱),sentinels是一个Set,其中存放所有Sentinel的地址(格式:IP:PORT,如127.0.0.1:26379),顺序无关;
初始化连接池
在构造函数中,通过方法取得当前所有分片的master地址(IP&PORT),对每个分片,通过顺次连接Sentinel实例,获取该分片的master地址,如果无法获得,即所有Sentinel都无法连接,将休眠1秒后继续重试,直到取得所有分片的master地址,代码块如下:
通过
初始化连接池,到此连接池中的所有连接都指向分片的master;
监控每个Sentinel
在方法最后,会为每个Sentinel启动一个Thread来监控Sentinel做出的更改:
该线程的run方法通过Jedis Pub/Sub API(实现JedisPubSub接口,并通过jedis.subscribe进行订阅)向Sentinel实例订阅“+switch-master”频道,当Sentinel进行主从切换时,该线程会得到新Master地址的通知,通过master name判断哪个分片进行了切换,将新master地址替换原来位置的地址,并调用initPool(List masters)进行Jedis连接池重建;后续所有通过该连接池取得的连接都指向新Master地址,对应用程序透明;
应用示例
maven:
<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency> <groupId>commons-pool</groupId> <artifactId>commons-pool</artifactId> <version>1.6</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.0</version> <type>jar</type> <scope>compile</scope> </dependency>
代码使用如下:
GenericObjectPoolConfig config = new GenericObjectPoolConfig(); config.setMaxTotal(100); config.setMaxIdle(10); List<String> masters = new ArrayList<String>(); masters.add("master-1");//sentinel.conf文件中的名字 masters.add("master-2"); Set<String> sentinels = new HashSet<String>(); sentinels.add("192.168.248.127:63792"); sentinels.add("192.168.248.128:63792"); ShardedJedisSentinelPool pool = new ShardedJedisSentinelPool(masters, sentinels, config, 60000); ShardedJedis j = null; for (int i = 11; i < 15; i++) { try { j = pool.getResource(); j.set("KEY: " + i, "" + i); pool.returnResource(j); } catch (JedisConnectionException e) { e.printStackTrace(); } } pool.destroy();
ShardedJedisSentinelPool文件内容如下:
/** * 2017/4/30. */ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.atomic.AtomicBoolean; import java.util.logging.Logger; import java.util.regex.Pattern; import org.apache.commons.pool2.PooledObject; import org.apache.commons.pool2.PooledObjectFactory; import org.apache.commons.pool2.impl.DefaultPooledObject; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import redis.clients.jedis.*; import redis.clients.jedis.exceptions.JedisConnectionException; import redis.clients.util.Hashing; import redis.clients.util.Pool; public class ShardedJedisSentinelPool extends Pool<ShardedJedis> { public static final int MAX_RETRY_SENTINEL = 10; protected final Logger log = Logger.getLogger(getClass().getName()); protected GenericObjectPoolConfig poolConfig; protected int timeout = Protocol.DEFAULT_TIMEOUT; private int sentinelRetry = 0; protected String password; protected int database = Protocol.DEFAULT_DATABASE; protected Set<MasterListener> masterListeners = new HashSet<MasterListener>(); private volatile List<HostAndPort> currentHostMasters; public ShardedJedisSentinelPool(List<String> masters, Set<String> sentinels) { this(masters, sentinels, new GenericObjectPoolConfig(), Protocol.DEFAULT_TIMEOUT, null, Protocol.DEFAULT_DATABASE); } public ShardedJedisSentinelPool(List<String> masters, Set<String> sentinels, String password) { this(masters, sentinels, new GenericObjectPoolConfig(), Protocol.DEFAULT_TIMEOUT, password); } public ShardedJedisSentinelPool(final GenericObjectPoolConfig poolConfig, List<String> masters, Set<String> sentinels) { this(masters, sentinels, poolConfig, Protocol.DEFAULT_TIMEOUT, null, Protocol.DEFAULT_DATABASE); } public ShardedJedisSentinelPool(List<String> masters, Set<String> sentinels, final GenericObjectPoolConfig poolConfig, int timeout, final String password) { this(masters, sentinels, poolConfig, timeout, password, Protocol.DEFAULT_DATABASE); } public ShardedJedisSentinelPool(List<String> masters, Set<String> sentinels, final GenericObjectPoolConfig poolConfig, final int timeout) { this(masters, sentinels, poolConfig, timeout, null, Protocol.DEFAULT_DATABASE); } public ShardedJedisSentinelPool(List<String> masters, Set<String> sentinels, final GenericObjectPoolConfig poolConfig, final String password) { this(masters, sentinels, poolConfig, Protocol.DEFAULT_TIMEOUT, password); } public ShardedJedisSentinelPool(List<String> masters, Set<String> sentinels, final GenericObjectPoolConfig poolConfig, int timeout, final String password, final int database) { this.poolConfig = poolConfig; this.timeout = timeout; this.password = password; this.database = database; List<HostAndPort> masterList = initSentinels(sentinels, masters); initPool(masterList); } public void destroy() { for (MasterListener m : masterListeners) { m.shutdown(); } super.destroy(); } public List<HostAndPort> getCurrentHostMaster() { return currentHostMasters; } private void initPool(List<HostAndPort> masters) { if (!equals(currentHostMasters, masters)) { StringBuffer sb = new StringBuffer(); for (HostAndPort master : masters) { sb.append(master.toString()); sb.append(" "); } log.info("Created ShardedJedisPool to master at [" + sb.toString() + "]"); List<JedisShardInfo> shardMasters = makeShardInfoList(masters); initPool(poolConfig, new ShardedJedisFactory(shardMasters, Hashing.MURMUR_HASH, null)); currentHostMasters = masters; } } private boolean equals(List<HostAndPort> currentShardMasters, List<HostAndPort> shardMasters) { if (currentShardMasters != null && shardMasters != null) { if (currentShardMasters.size() == shardMasters.size()) { for (int i = 0; i < currentShardMasters.size(); i++) { if (!currentShardMasters.get(i).equals(shardMasters.get(i))) return false; } return true; } } return false; } private List<JedisShardInfo> makeShardInfoList(List<HostAndPort> masters) { List<JedisShardInfo> shardMasters = new ArrayList<JedisShardInfo>(); for (HostAndPort master : masters) { JedisShardInfo jedisShardInfo = new JedisShardInfo(master.getHost(), master.getPort(), timeout); jedisShardInfo.setPassword(password); shardMasters.add(jedisShardInfo); } return shardMasters; } private List<HostAndPort> initSentinels(Set<String> sentinels, final List<String> masters) { Map<String, HostAndPort> masterMap = new HashMap<String, HostAndPort>(); List<HostAndPort> shardMasters = new ArrayList<HostAndPort>(); log.info("Trying to find all master from available Sentinels..."); for (String masterName : masters) { HostAndPort master = null; boolean fetched = false; while (!fetched && sentinelRetry < MAX_RETRY_SENTINEL) { for (String sentinel : sentinels) { final HostAndPort hap = toHostAndPort(Arrays.asList(sentinel.split(":"))); log.fine("Connecting to Sentinel " + hap); try { Jedis jedis = new Jedis(hap.getHost(), hap.getPort()); master = masterMap.get(masterName); if (master == null) { List<String> hostAndPort = jedis.sentinelGetMasterAddrByName(masterName); if (hostAndPort != null && hostAndPort.size() > 0) { master = toHostAndPort(hostAndPort); log.fine("Found Redis master at " + master); shardMasters.add(master); masterMap.put(masterName, master); fetched = true; jedis.disconnect(); break; } } } catch (JedisConnectionException e) { log.warning("Cannot connect to sentinel running @ " + hap + ". Trying next one."); } } if (null == master) { try { log.severe("All sentinels down, cannot determine where is " + masterName + " master is running... sleeping 1000ms, Will try again."); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } fetched = false; sentinelRetry++; } } // Try MAX_RETRY_SENTINEL times. if (!fetched && sentinelRetry >= MAX_RETRY_SENTINEL) { log.severe("All sentinels down and try " + MAX_RETRY_SENTINEL + " times, Abort."); throw new JedisConnectionException("Cannot connect all sentinels, Abort."); } } // All shards master must been accessed. if (masters.size() != 0 && masters.size() == shardMasters.size()) { log.info("Starting Sentinel listeners..."); for (String sentinel : sentinels) { final HostAndPort hap = toHostAndPort(Arrays.asList(sentinel.split(":"))); MasterListener masterListener = new MasterListener(masters, hap.getHost(), hap.getPort()); masterListeners.add(masterListener); masterListener.start(); } } return shardMasters; } private HostAndPort toHostAndPort(List<String> getMasterAddrByNameResult) { String host = getMasterAddrByNameResult.get(0); int port = Integer.parseInt(getMasterAddrByNameResult.get(1)); return new HostAndPort(host, port); } /** * PoolableObjectFactory custom impl. */ protected static class ShardedJedisFactory implements PooledObjectFactory<ShardedJedis> { private List<JedisShardInfo> shards; private Hashing algo; private Pattern keyTagPattern; public ShardedJedisFactory(List<JedisShardInfo> shards, Hashing algo, Pattern keyTagPattern) { this.shards = shards; this.algo = algo; this.keyTagPattern = keyTagPattern; } public PooledObject<ShardedJedis> makeObject() throws Exception { ShardedJedis jedis = new ShardedJedis(shards, algo, keyTagPattern); return new DefaultPooledObject<ShardedJedis>(jedis); } public void destroyObject(PooledObject<ShardedJedis> pooledShardedJedis) throws Exception { final ShardedJedis shardedJedis = pooledShardedJedis.getObject(); for (Jedis jedis : shardedJedis.getAllShards()) { try { try { jedis.quit(); } catch (Exception e) { } jedis.disconnect(); } catch (Exception e) { } } } public boolean validateObject(PooledObject<ShardedJedis> pooledShardedJedis) { try { ShardedJedis jedis = pooledShardedJedis.getObject(); for (Jedis shard : jedis.getAllShards()) { if (!shard.ping().equals("PONG")) { return false; } } return true; } catch (Exception ex) { return false; } } public void activateObject(PooledObject<ShardedJedis> p) throws Exception { } public void passivateObject(PooledObject<ShardedJedis> p) throws Exception { } } protected class JedisPubSubAdapter extends JedisPubSub { @Override public void onMessage(String channel, String message) { } @Override public void onPMessage(String pattern, String channel, String message) { } @Override public void onPSubscribe(String pattern, int subscribedChannels) { } @Override public void onPUnsubscribe(String pattern, int subscribedChannels) { } @Override public void onSubscribe(String channel, int subscribedChannels) { } @Override public void onUnsubscribe(String channel, int subscribedChannels) { } } protected class MasterListener extends Thread { protected List<String> masters; protected String host; protected int port; protected long subscribeRetryWaitTimeMillis = 5000; protected Jedis jedis; protected AtomicBoolean running = new AtomicBoolean(false); protected MasterListener() { } public MasterListener(List<String> masters, String host, int port) { this.masters = masters; this.host = host; this.port = port; } public MasterListener(List<String> masters, String host, int port, long subscribeRetryWaitTimeMillis) { this(masters, host, port); this.subscribeRetryWaitTimeMillis = subscribeRetryWaitTimeMillis; } public void run() { running.set(true); while (running.get()) { jedis = new Jedis(host, port); try { jedis.subscribe(new JedisPubSubAdapter() { @Override public void onMessage(String channel, String message) { log.fine("Sentinel " + host + ":" + port + " published: " + message + "."); String[] switchMasterMsg = message.split(" "); if (switchMasterMsg.length > 3) { int index = masters.indexOf(switchMasterMsg[0]); if (index >= 0) { HostAndPort newHostMaster = toHostAndPort(Arrays.asList(switchMasterMsg[3], switchMasterMsg[4])); List<HostAndPort> newHostMasters = new ArrayList<HostAndPort>(); for (int i = 0; i < masters.size(); i++) { newHostMasters.add(null); } Collections.copy(newHostMasters, currentHostMasters); newHostMasters.set(index, newHostMaster); initPool(newHostMasters); } else { StringBuffer sb = new StringBuffer(); for (String masterName : masters) { sb.append(masterName); sb.append(","); } log.fine("Ignoring message on +switch-master for master name " + switchMasterMsg[0] + ", our monitor master name are [" + sb + "]"); } } else { log.severe("Invalid message received on Sentinel " + host + ":" + port + " on channel +switch-master: " + message); } } }, "+switch-master"); } catch (JedisConnectionException e) { if (running.get()) { log.severe("Lost connection to Sentinel at " + host + ":" + port + ". Sleeping 5000ms and retrying."); try { Thread.sleep(subscribeRetryWaitTimeMillis); } catch (InterruptedException e1) { e1.printStackTrace(); } } else { log.fine("Unsubscribing from Sentinel at " + host + ":" + port); } } } } public void shutdown() { try { log.fine("Shutting down listener on " + host + ":" + port); running.set(false); // This isn't good, the Jedis object is not thread safe jedis.disconnect(); } catch (Exception e) { log.severe("Caught exception while shutting down: " + e.getMessage()); } } } }
总结
本文通过现实中遇到的问题,即在Redis数据分片的情况下,在使用Sentinel做HA时,如何做到主从的切换对应用程序透明,通过Jedis的Pub/Sub功能,能同时监控多个分片的主从切换情况,并通过监听到的新地址重新构造连接池,后续从连接池中取得的所有连接都指向新地址。该方案的关键是:使用sentinel做HA,Jedis版本必须2.2.2及以上,所有访问Redis实例的连接都必须从连接池中获取;
该项目的GitHub主页: https://github.com/warmbreeze/sharded-jedis-sentinel-pool
==================================以下有代验证==============================================
==================================以下有代验证==============================================
连接泄露Bug
循环时发现ShardedJedisSentinelPool连接池有时竟然满了!毕竟默认是8个连接,但为什么会这样?查了下代码,果然是这个原因!这个新扩展的pool没有为getResource()出来的ShardedJedis设置DataSource,所以关闭ShardedJedis时没法正常还回到连接池中。补丁很简单,就是参照Jedis的ShardedJedisPool,覆写一些资源管理的方法。
@Override public ShardedJedis getResource() { ShardedJedis jedis = super.getResource(); jedis.setDataSource(this); return jedis; } @Override public void returnBrokenResource(final ShardedJedis resource) { if (resource != null) { returnBrokenResourceObject(resource); } } @Override public void returnResource(final ShardedJedis resource) { if (resource != null) { resource.resetState(); returnResourceObject(resource); } }
相关文章推荐
- 基于Redis Sentinel的Redis集群(主从Sharding)高可用方案(转)
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- redis的安装配置及其基于sentinel的redis集群高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案【收藏】
- Sentinel-Redis高可用方案(二):主从切换
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- Sentinel-Redis高可用方案(二):主从切换
- 基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- Sentinel-Redis高可用方案(二):主从切换
- (转)基于Redis Sentinel的Redis集群(主从&Sharding)高可用方案
- Sentinel-Redis高可用方案(二):主从切换