熬了一个通宵，终于把Reids的7千万个Key删完了，今天脑子都嗡嗡响！

前言

由于有一条业务线不理想，高层决定下架业务。对于我们技术团队而言，其对应的所有服务器资源和其他相关资源都要释放。释放了8台应用服务器；1台es服务器；删除分布式定时任务中心相关的业务任务；备份并删除MySQL数据库；删除Redis中相关的业务缓存数据。CTO指名点姓让我带头冲锋，才扣了我绩效……好吧，冲~

其他都还好，不多时就解决了。唯独这删除Redis中的数据，害得我又熬了一个通宵，真是折煞我也！

难点分析

共用Redis服务集群

由于这条业务线的数据在Redis大概在3G左右，完全没必要单独建一个Redis服务集群，本着能节约就节约的态度，当初就决定和其他项目共享一个集群（这个集群配置：16个节点，128G内存，还算豪华吧~）集群配置如下：

在这种共用集群的情况下，导致无法简单粗暴的释放。因此只能选择删除Key的方式。

Key命名不规范

要删除Key，首先就要精准的定位出哪些Key需要删除，如果勿删Key，会影响到其他服务正常运转！如果Key本身设置了过期时间，但有些数据需是持久化的。然而那该死的项目经理一直催项目进度，导致开发人员在开发过程中很多地方都没有设计到位，比如Redis Key散落在项目代码的每个角落；比如命名不是很规范。真不知道是怎么review代码！哦，想必是没有时间review，那该死的项目经理……

我随便截个支付服务中的Key命名：

怎么样？是不是觉得我们开发人员写的代码很low~别笑，在实际工作中，还有比这更low的！希望你别遇到，不然真的很痛苦~

解决思路

经过以上的分析，我们简单归纳如下：

  •  我们真正关心的是那些未设置过期时间的Key
  •  不能误删除Key，否则下个月绩效也没了
  •  由于Key的命名及使用及其不规范，导致Key的定位难度很大

看来，通过scan命令扫描匹配Key的方式行不通了。只能通过人肉搜索了~

幸而Idea的搜索大法好，这个项目中使用的是spring-boot-starter-data-redis.因此我通过搜索RedisTemplate和StringRedisTemplate定位所有操作redis的代码，具体步骤如下：

1、通过这些代码统计出Key的前缀并录入到文本中；

2、通过python脚本把载入文中中的的Key并在后面加上“*”通配符；

3、通过python脚本通过scan命令扫描出这些key；

4、为了便于检查，我们并没有直接使用del命令删除key，在删除key之前，先通过debug object key的方式得到其序列化的长度，再执行删除并返回序列化长度。这样，我们就可以统计出所有key的序列化长度来得到我们释放的空间大小。关键代码如下：  

 
 
 
 
    
  
  
  
  
  1. def get_key(rdbConn,start):  
    2.   
  
  
  
  2.        try:  
    3.   
  
  
  
  3.        keys_list = rdbConn.scan(start,count=2000)  
    4.   
  
  
  
  4.        return keys_list  
    5.   
  
  
  
  5.        exceptException,e:  
    6.   
  
  
  
  6.        print e  
    7.   
  
  
  
  7.    ''' Redis DEBUG OBJECT command got key info '''  
    8.   
  
  
  
  8.    def get_key_info(rdbConn,keyName):  
    9.   
  
  
  
  9.        try:  
    10.   
  
  
  
  10.        rpiple = rdbConn.pipeline()  
    11.   
  
  
  
  11.        rpiple.type(keyName)  
    12.   
  
  
  
  12.        rpiple.debug_object(keyName)  
    13.   
  
  
  
  13.        rpiple.ttl(keyName)  
    14.   
  
  
  
  14.        key_info_list = rpiple.execute()  
    15.   
  
  
  
  15.        return key_info_list  
    16.   
  
  
  
  16.        exceptException,e:  
    17.   
  
  
  
  17.        print"INFO : ",e  
    18.   
  
  
  
  18.    def redis_key_static(key_info_list):  
    19.   
  
  
  
  19.        keyType = key_info_list[0]  
    20.   
  
  
  
  20.        keySize = key_info_list[1]['serializedlength']  
    21.   
  
  
  
  21.        keyTtl = key_info_list[2]  
    22.   
  
  
  
  22.        key_size_static(keyType,keySize,keyTtl) 
    23.

通过以上方式，能够统计出究竟释放了多少内存了。

由于这个集群是有这么接近7千万个key：

因此，等到了第二天天亮，我睡眼朦胧的看了一下，终于删除完毕了，时间07:13...早高峰即将来临……

知耻而后勇

从来没有经历过因业务下线而清除资源的经验。这次事情真心让我觉得细微之处见真功夫的道理。如果一开始我们就能够遵循开发规范来使用和设计redis key，也不至于浪费这么多时间。为了让key的命名和使用更加规范，以及今后避免再次遇到这种情况，下午睡醒之后，我就在redis公共组件库里面添加了一个配置和自定义了key序列化，代码如下：

 
 
 
 
    
  
  
  
  
  1. @ConfigurationProperties(prefix = "spring.redis.prefix")  
    2.   
  
  
  
  2. publicclassRedisKeyPrefixProperties{  
    3.   
  
  
  
  3.     privateBoolean enable = Boolean.TRUE;  
    4.   
  
  
  
  4.     privateString key;  
    5.   
  
  
  
  5.     publicBoolean getEnable() { 
    6.   
  
  
  
  6.          return enable;  
    7.   
  
  
  
  7.     }  
    8.   
  
  
  
  8.     publicvoid setEnable(Boolean enable) {  
    9.   
  
  
  
  9.         this.enable = enable;  
    10.   
  
  
  
  10.     }  
    11.   
  
  
  
  11.     publicString getKey() {  
    12.   
  
  
  
  12.         return key;  
    13.   
  
  
  
  13.     }  
    14.   
  
  
  
  14.     publicvoid setKey(String key) {  
    15.   
  
  
  
  15.         this.key = key;  
    16.   
  
  
  
  16.     }  
    17.   
  
  
  
  17. }  
    18.  
 
 
 
 
 
 
 
    
  
  
  
  
  1. /**  
    2.   
  
  
  
  2.  * @desc 对字符串序列化新增前缀  
    3.   
  
  
  
  3.  * @author create by liming sun on 2020-07-21 14:09:51  
    4.   
  
  
  
  4.  */  
    5.   
  
  
  
  5. publicclassPrefixStringKeySerializerextendsStringRedisSerializer{  
    6.   
  
  
  
  6.     privateCharset charset = StandardCharsets.UTF_8; 
    7.   
  
  
  
  7.      privateRedisKeyPrefixProperties prefix;  
    8.   
  
  
  
  8.     publicPrefixStringKeySerializer(RedisKeyPrefixProperties prefix) {  
    9.   
  
  
  
  9.         super(); 
    10.   
  
  
  
  10.          this.prefix = prefix;  
    11.   
  
  
  
  11.     }  
    12.   
  
  
  
  12.     @Override  
    13.   
  
  
  
  13.     publicString deserialize(@Nullablebyte[] bytes) {  
    14.   
  
  
  
  14.         String saveKey = newString(bytes, charset);  
    15.   
  
  
  
  15.         if(prefix.getEnable() != null&& prefix.getEnable()) {  
    16.   
  
  
  
  16.             String prefixKey = spliceKey(prefix.getKey());  
    17.   
  
  
  
  17.             int indexOf = saveKey.indexOf(prefixKey);  
    18.   
  
  
  
  18.             if(indexOf > 0) {  
    19.   
  
  
  
  19.                 saveKeysaveKey = saveKey.substring(indexOf);  
    20.   
  
  
  
  20.             }  
    21.   
  
  
  
  21.         }  
    22.   
  
  
  
  22.         return(saveKey.getBytes() == null? null: saveKey);  
    23.   
  
  
  
  23.     }  
    24.   
  
  
  
  24.     @Override  
    25.   
  
  
  
  25.     publicbyte[] serialize(@NullableString key) {  
    26.   
  
  
  
  26.         if(prefix.getEnable() != null&& prefix.getEnable()) {  
    27.   
  
  
  
  27.             key = spliceKey(prefix.getKey()) + key;  
    28.   
  
  
  
  28.         }  
    29.   
  
  
  
  29.         return(key == null? null: key.getBytes(charset));  
    30.   
  
  
  
  30.     }  
    31.   
  
  
  
  31.     privateString spliceKey(String prefixKey) {  
    32.   
  
  
  
  32.         if(StringUtils.isNotBlank(prefixKey) && !prefixKey.endsWith(":")) {  
    33.   
  
  
  
  33.             prefixKeyprefixKey = prefixKey + "::";  
    34.   
  
  
  
  34.         }  
    35.   
  
  
  
  35.         return prefixKey;  
    36.   
  
  
  
  36.     }  
    37.   
  
  
  
  37. } 
    38.

使用效果

为了避免再次发生这种工作低效而又不得不做的事情，我们在开发规范中规定，新项目中redis的使用必须设置此配置，前缀就设置为：项目编号。另外，一个模块中的key必须统一定义在二方库的RedisKeyConstant类中。配置如下：

 
 
 
 
    
  
  
  
  
  1. spring:  
    2.   
  
  
  
  2.     redis:  
    3.   
  
  
  
  3.         prefix:  
    4.   
  
  
  
  4.             enable: true  
    5.   
  
  
  
  5.             key: E00P01    
    6.  
 
 
 
 
 
 
 
    
  
  
  
  
  1. @Bean  
    2.   
  
  
  
  2.    publicRedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {  
    3.   
  
  
  
  3.        RedisTemplate redisTemplate = newRedisTemplate<>();  
    4.   
  
  
  
  4.        redisTemplate.setConnectionFactory(redisConnectionFactory);  
    5.   
  
  
  
  5.        // 支持key前缀设置的key Serializer  
    6.   
  
  
  
  6.        redisTemplate.setKeySerializer(newPrefixStringKeySerializer());  
    7.   
  
  
  
  7.        redisTemplate.setValueSerializer(newGenericJackson2JsonRedisSerializer());  
    8.   
  
  
  
  8.        return redisTemplate;  
    9.   
  
  
  
  9.    } 
    10.

通过以上方式，我们至少可以从项目维度来区分出key，避免了多个项目之间共用同一个集群时而导致重复key的问题。从项目维度对key进行了划分。更方便管理和运维。如果对于key的管理粒度要求更细，我们甚至可以细化到具体业务维度。我们在测试环境进行了压测，增加key前缀对redis性能几乎没有影响。性能方面能接受。

当前题目：熬了一个通宵，终于把Reids的7千万个Key删完了，今天脑子都嗡嗡响！
本文URL：http://www.shufengxianlan.com/qtweb/news30/422130.html

成都网站建设公司_创新互联，为您提供App开发、企业建站、网站设计、企业网站制作、python、软件开发

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站建设知识

分类信息网

成都微信二次开发　　 　成都橡塑保温管　　 　网站建设　　 　广安网站建设　　 　做移动网站　　 　四川柴油发电机　　 　腾讯香港免备案空间　　 　成都标牌标识牌制作公司　　 　边坡防护网厂家　　 　达州博佩科技　　 　成都网站设计　　 　四川内江电信机房　　 　app网站建设　　 　重庆做网站　　 　一带一路　　 　成都ssl证书认证　　 　网站制作价格　　 　成都棕树电信机房　　 　重庆电商网站建设　　 　绵阳梓潼做网站