Redis集群方案及实现

青旅半醒 2022-07-16 11:28 238阅读 0赞

之前做了一个Redis的集群方案，跑了小半年，线上运行的很稳定  
差不多可以跟大家分享下经验，前面写了一篇文章[ 数据在线服务的一些探索经验][Link 1]，可以做为背景阅读

### 应用 ###

我们的Redis集群主要承担了以下服务：  
1. 实时推荐  
2. 用户画像  
3. 诚信分值服务

### 集群状况 ###

集群峰值QPS 1W左右，RW响应时间999线在1ms左右  
整个集群：  
1. Redis节点： 8台物理机;每台128G内存;每台机器上8个instance  
2. Sentienl：3台虚拟机

### 集群方案 ###

![SouthEast][]  
Redis Node由一组Redis Instance组成，一组Redis Instatnce可以有一个Master Instance，多个Slave Instance  
  
Redis官方的cluster还在beta版本，参看 [Redis cluster tutorial][]  
在做调研的时候，曾经特别关注过KeepAlived+VIP 和 Twemproxy  
不过最后还是决定基于Redis Sentinel实现一套，整个项目大概在1人/1个半月

### 整体设计 ###

1. 数据Hash分布在不同的Redis Instatnce上  
2. M/S的切换采用Sentinel  
3. 写：只会写master Instance，从sentinel获取当前的master Instane  
4. 读：从Redis Node中基于权重选取一个Redis Instance读取，失败/超时则轮询其他Instance  
5. 通过RPC服务访问，RPC server端封装了Redis客户端，客户端基于jedis开发  
6. 批量写/删除：不保证事务

### RedisKey ###

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** RedisKey **implements** Serializable\{  
2.      **private** **static** **final** **long** serialVersionUID = 1L;  
3.        
4.      //每个业务不同的family  
5.      **private** String family;  
6.        
7.      **private** String key;  
8.            
9.      ......    
10.     //物理保存在Redis上的key为经过MurmurHash之后的值  
11.     **private** String makeRedisHashKey()\{  
12.         **return** String.valueOf(MurmurHash.hash64(makeRedisKeyString()));  
13.     \}  
14.       
15.     //ReidsKey由family.key组成  
16.     **private** String makeRedisKeyString()\{  
17.         **return** family +":"\+ key;  
18.     \}  
19.   
20.     //返回用户的经过Hash之后RedisKey  
21.     **public** String getRedisKey()\{  
22.         **return** makeRedisHashKey();  
23.     \}  
24.     .....  
25. \}

Family的存在时为了避免多个业务key冲突，给每个业务定义自己独立的Faimily  
出于性能考虑，参考Redis存储设计，实际保存在Redis上的key为经过hash之后的值

### 接口 ###

目前支持的接口包括：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **interface** RedisUseInterface\{  
2.      /\*\* 
3.       \* 通过RedisKey获取value 
4.       \*  
5.       \* @param redisKey 
6.       \*           redis中的key 
7.       \* @return  
8.       \*           成功返回value,查询不到返回NULL 
9.       \*/  
10.     **public** String get(**final** RedisKey redisKey) **throws** Exception;  
11.       
12.     /\*\* 
13.      \* 插入<k,v>数据到Redis 
14.      \*  
15.      \* @param redisKey 
16.      \*           the redis key 
17.      \* @param value 
18.      \*           the redis value 
19.      \* @return  
20.      \*           成功返回"OK",插入失败返回NULL 
21.      \*/  
22.     **public** String set(**final** RedisKey redisKey, **final** String value) **throws** Exception;  
23.       
24.     /\*\* 
25.      \* 批量写入数据到Redis 
26.      \*  
27.      \* @param redisKeys 
28.      \*           the redis key list 
29.      \* @param values 
30.      \*           the redis value list 
31.      \* @return  
32.      \*           成功返回"OK",插入失败返回NULL 
33.      \*/  
34.     **public** String mset(**final** ArrayList<RedisKey> redisKeys, **final** ArrayList<String> values) **throws** Exception;  
35.       
36.       
37.     /\*\* 
38.      \* 从Redis中删除一条数据 
39.      \*  
40.      \* @param redisKey 
41.      \*           the redis key 
42.      \* @return  
43.      \*           an integer greater than 0 if one or more keys were removed 0 if none of the specified key existed 
44.      \*/  
45.     **public** Long del(RedisKey redisKey) **throws** Exception;  
46.       
47.     /\*\* 
48.      \* 从Redis中批量删除数据 
49.      \*  
50.      \* @param redisKey 
51.      \*           the redis key 
52.      \* @return  
53.      \*           返回成功删除的数据条数 
54.      \*/  
55.     **public** Long del(ArrayList<RedisKey> redisKeys) **throws** Exception;  
56.       
57.     /\*\* 
58.      \* 插入<k,v>数据到Redis 
59.      \*  
60.      \* @param redisKey 
61.      \*           the redis key 
62.      \* @param value 
63.      \*           the redis value 
64.      \* @return  
65.      \*           成功返回"OK",插入失败返回NULL 
66.      \*/  
67.     **public** String setByte(**final** RedisKey redisKey, **final** **byte**\[\] value) **throws** Exception;  
68.       
69.     /\*\* 
70.      \* 插入<k,v>数据到Redis 
71.      \*  
72.      \* @param redisKey 
73.      \*           the redis key 
74.      \* @param value 
75.      \*           the redis value 
76.      \* @return  
77.      \*           成功返回"OK",插入失败返回NULL 
78.      \*/  
79.     **public** String setByte(**final** String redisKey, **final** **byte**\[\] value) **throws** Exception;  
80.       
81.     /\*\* 
82.      \* 通过RedisKey获取value 
83.      \*  
84.      \* @param redisKey 
85.      \*           redis中的key 
86.      \* @return  
87.      \*           成功返回value,查询不到返回NULL 
88.      \*/  
89.     **public** **byte**\[\] getByte(**final** RedisKey redisKey) **throws** Exception;  
90.       
91.     /\*\* 
92.      \* 在指定key上设置超时时间 
93.      \*  
94.      \* @param redisKey 
95.      \*           the redis key 
96.      \* @param seconds 
97.      \*           the expire seconds 
98.      \* @return  
99.      \*           1:success, 0:failed 
100.      \*/  
101.     **public** Long expire(RedisKey redisKey, **int** seconds) **throws** Exception;  
102. \}

### 写Redis流程 ###

1. 计算Redis Key Hash值  
2. 根据Hash值获取Redis Node编号  
3. 从sentinel获取Redis Node的Master  
4.  写数据到Redis

**\[java\]**  [view plain][]   [copy][view plain]

1.  //获取写哪个Redis Node  
2.  **int** slot = getSlot(keyHash);  
3.  RedisDataNode redisNode =  rdList.get(slot);  
4.    
5.  //写Master  
6.  JedisSentinelPool jp = redisNode.getSentinelPool();  
7.  Jedis je = **null**;  
8.  **boolean** success = **true**;  
9.  **try** \{  
10.     je = jp.getResource();  
11.     **return** je.set(key, value);  
12. \} **catch** (Exception e) \{  
13.     log.error("Maybe master is down", e);  
14.     e.printStackTrace();  
15.     success = **false**;  
16.     **if** (je != **null**)  
17.         jp.returnBrokenResource(je);  
18.     **throw** e;  
19. \} **finally** \{  
20.     **if** (success && je != **null**) \{  
21.         jp.returnResource(je);  
22.     \}  
23. \}

### 读流程 ###

1. 计算Redis Key Hash值  
2. 根据Hash值获取Redis Node编号  
3. 根据权重选取一个Redis Instatnce  
4.  轮询读

**\[java\]**  [view plain][]   [copy][view plain]

1.  //获取读哪个Redis Node  
2.  **int** slot = getSlot(keyHash);  
3.  RedisDataNode redisNode =  rdList.get(slot);  
4.    
5.  //根据权重选取一个工作Instatnce  
6.  **int** rn = redisNode.getWorkInstance();  
7.    
8.  //轮询  
9.  **int** cursor = rn;  
10. **do** \{              
11.     **try** \{  
12.         JedisPool jp = redisNode.getInstance(cursor).getJp();  
13.         **return** getImpl(jp, key);  
14.     \} **catch** (Exception e) \{  
15.         log.error("Maybe a redis instance is down, slot : \[" + slot + "\]" + e);  
16.         e.printStackTrace();  
17.         cursor = (cursor + 1) % redisNode.getInstanceCount();  
18.         **if**(cursor == rn)\{  
19.             **throw** e;  
20.         \}  
21.     \}  
22. \} **while** (cursor != rn);

### 权重计算 ###

初始化的时候，会给每个Redis Instatnce赋一个权重值weight  
根据权重获取Redis Instance的代码：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **int** getWorkInstance() \{  
2.      //没有定义weight，则完全随机选取一个redis instance  
3.      **if**(maxWeight == 0)\{  
4.          **return** (**int**) (Math.random() \* RANDOM\_SIZE % redisInstanceList.size());  
5.      \}  
6.        
7.      //获取随机数  
8.      **int** rand = (**int**) (Math.random() \* RANDOM\_SIZE % maxWeight);  
9.      **int** sum = 0;  
10.   
11.     //选取Redis Instance  
12.     **for** (**int** i = 0; i < redisInstanceList.size(); i++) \{  
13.         sum += redisInstanceList.get(i).getWeight();  
14.         **if** (rand < sum) \{  
15.             **return** i;  
16.         \}  
17.     \}  
18.       
19.     **return** 0;  
20. \}

[Link 1]: http://blog.csdn.net/yfkiss/article/details/25688153
[SouthEast]: /images/20220716/1a2c32388f3940e58dd677382c413001.png
[Redis cluster tutorial]: http://redis.io/topics/cluster-tutorial
[view plain]: http://blog.csdn.net/yfkiss/article/details/38944179#

发表评论取消回复

表情：

评论列表（有 0 条评论，238人围观）

还没有评论，来说两句吧...

相关阅读

相关集群系列：Redis集群方案及新版实战

![format_png][] 一.集群概述 1、为什么需要集群 1. 提高系统性能在单台服务器的情况下，随着用户量的增加和数据量的增大，系统的响应时

墨蓝/ 2024年03月22日 10:33/ 0 赞/ 74 阅读

相关 70、redis集群方案

redis集群方案主从哨兵模式: sentinel，哨兵是 redis 集群中非常重要的一个组件，主要有以下功能: 集群监控：负责监控 redis ma

╰半夏微凉°/ 2024年03月17日 21:26/ 0 赞/ 88 阅读

相关 redis：redis集群方案

由于redis出众的性能，其在众多的移动互联网企业中得到广泛的应用。redis在3.0版本前只支持单实例模式，虽然现在的服务器内存可以到100GB、200GB的规模，但是单实例

迈不过友情╰/ 2022年08月28日 09:56/ 0 赞/ 265 阅读

相关 Redis 集群方案

根据一些测试整理出来的一份方案： 1. Redis 性能 > 对于redis 的一些简单测试，仅供参考： > > 测试环境：Redhat6.2 , Xeon E552

Dear 丶/ 2022年08月18日 03:16/ 0 赞/ 253 阅读

相关 Redis?集群方案

由于Redis出众的性能，其在众多的移动互联网企业中得到广泛的应用。Redis在3.0版本前只支持单实例模式，虽然现在的服务器内存可以到100GB、200GB的规模，但

悠悠/ 2022年07月17日 04:22/ 0 赞/ 253 阅读

相关 Redis集群方案及实现

之前做了一个Redis的集群方案，跑了小半年，线上运行的很稳定差不多可以跟大家分享下经验，前面写了一篇文章[ 数据在线服务的一些探索经验][Link 1]，可以做为背景阅

青旅半醒/ 2022年07月16日 11:28/ 0 赞/ 239 阅读

相关 Redis集群方案all

由于Redis出众的性能，其在众多的移动互联网企业中得到广泛的应用。Redis在3.0版本前只支持单实例模式，虽然现在的服务器内存可以到100GB、200GB的规模，但是单实例

浅浅的花香味﹌/ 2022年07月15日 14:09/ 0 赞/ 234 阅读

相关 Redis集群方案及框架

redis集群分为服务端集群和客户端分片，redis3.0以上版本实现了集群机制，即服务端集群，3.0以下使用客户端分片（Sharding）。通常，为了

柔光的暖阳◎/ 2022年05月29日 02:45/ 0 赞/ 287 阅读

相关 redies集群方案

为什么需要集群 Redis单线程特性，多请求顺序执行，单个耗时的操作会阻塞后续的操作单机内存有限某些特殊业务，带宽压力较大单点问题，缺乏高可

矫情吗；*/ 2022年02月20日 07:45/ 0 赞/ 444 阅读

相关 Redis 集群方案与实现

客户端分片基于代理的分片路由查询客户端分片由客户端决定 key 写入或者读取的节点包括 Jedis 在内的一些客户端，实现了客户端分片机制

小灰灰/ 2020年05月01日 19:51/ 0 赞/ 905 阅读