玩转Redis-干掉钉子户-没有设置过期时间的key

背景

前段时间公司有新业务需要使用Redis，于是查看了生产一Redis集群的使用情况，用于评估是否能直接接入新业务。此Redis集群购买的阿里云集群社区版，8节点32G；

不看不知道，一看吓一跳。Redis实例共计 450W key，其中 230W 设置了过期时间，也就是说足足有 220W key没有设置过期时间。 What !!! 接近 50% 的数据没有过期时间，完全不符合常理，严重浪费。

不把这些钉子户揪出来，“誓不为猿”。

如何查询Redis中未设置过期时间的key数量

使用阿里云【云数据库Redis版管理控制台】查看

如果Redis集群是云厂商提供的，厂商一般会提供管理控制台的。阿里云控制台搜索“云数据库Redis版”即可进入【云数据库Redis版管理控制台】。

查看集群或节点的Key变化情况

（1）进入【性能监控】，默认选择【数据节点聚合指标】，此处是区间折线图

• 聚合指标可查看整个集群的数据情况
• 可通过调整“查询时间”扩大数据分析范围
• 亦可选择【数据节点】查看指定节点的数据情况

进入【CloudDBA】，进入【性能趋势】，可查看区间折线图

• [Keys]一栏，可查看 key总量、设置过期时间key数量、已过期key数量 的变化信息

查看全局节点的实时性能

• 进入【CloudDBA】，进入【实时性能】，选择【全局节点实时性能】
• 默认勾选“自动刷新(5秒)”，即可查看各节点的实时性能

云数据库Redis监控指标说明

参考地址：https://help.aliyun.com/document_detail/43887.html

使用Redis命令行查看

执行info Keyspace指令即可，其中 keys 表示 集群中 key 的总量（大约 455W），expires 表示 设置了过期时间的key的总量（大约 240W）

127.0.0.1:6379> info Keyspace
# Keyspace
db0:keys=4551001,expires=2405155,avg_ttl=219009799007

使用命令行查看的缺点是：无法查阅数据一段时间的变化情况（当然运维可以自行搭建监控体系，普罗米修斯、ELK都是不错的选择），所以云厂商给我们提供了很大的方便

导出Redis中没有设置过期时间的key

一想着快 50% 的资源浪费了就无比痛心，So 必须导出这些钉子户分析罪魁祸首，然后干掉他。

原本想着阿里云应该有类似的功能，结果在官网查看以及询问阿里云技术支持，发现阿里云并未提供此功能，只能自己捣鼓了。

由于是生产环境，所以【安全性、稳定性】尤其重要，绝不能影响生产环境的正常使用。网上查询了相关资料，最终形成如下2种脚本解决方案：

• 使用shell脚本导出数据
• • 无长连接，相对较慢，大量连接对Redis有一定影响
• • 数据量较大时注意合理配置休眠时间
• 使用python脚本导出数据

使用shell脚本导出数据

脚本部分参数可配置，可按需修改以下参数：

• db_ip：Redis连接地址
• db_port：Redis连接端口，可作为参数传入
• password：Redis连接密码，可作为参数传入
• cursor：第一次 scan 迭代游标，默认0，首次使用不建议修改
• cnt：每次 scan 迭代的数量，默认1000，可根据生产情况调整优化

需要注意的是：

• 脚本默认每scan(ttl) 1000 个key即休眠0.1秒
• shell 脚本无法维护长连接，所以每次ttl都将创建连接，性能有一定影响
• 有想法使用lua脚本批量 ttl 提升性能，有兴趣的同学可以实现一下，欢迎分享反馈

脚本执行：

测试 Redis 单机版 共 30W key，按照默认的休眠频率（scan 1K 个key休眠0.1秒）总计耗时12分钟（可自行优化调整），扫描结果的 key 保存在 当前目录的no_ttlkey.log中。

[redis@xxx redis]$ time ./checknottl.sh 6378 password
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
scan_num: 0

real    12m14.810s
user    4m14.343s
sys    5m41.646s

脚本如下，将以下脚本内容保存为checknottl.sh，再执行chmod u+x *.sh授予执行权限：

#!/bin/bash
# 查询没有设置过期时间的key
# 脚本地址：https://github.com/zxiaofan/OpenSource_Study/tree/master/redis_scripts；
# 需在redis-cli 目录执行，或者修改脚本中的路径
# checknottl.sh，默认每scan(ttl) 1000 个key即休眠0.1秒
# 脚本参考网络，已做一定调整优化，更多Redis系列文章可前往：https://blog.csdn.net/u010887744/category_9356949.html；
# Note: 
#    shell 脚本无法维护长连接，所以每次ttl都将创建连接，性能有一定影响
#     有想法使用lua脚本批量 ttl 提升性能，有兴趣的同学可以实现一下，欢迎分享反馈

db_ip=127.0.0.1      # Redis ip
db_port=$1           # Redis 端口
password=$2          # Redis 密码
cursor=0             # 第一次游标
cnt=1000             # 每次迭代的数量
new_cursor=0         # 下一次游标
scan_num=0           # 已scan的key数量

./redis-cli -h $db_ip -p $db_port -a $password scan $cursor count $cnt > scan_tmp_result
new_cursor=`sed -n '1p' scan_tmp_result`             # 获取下一次游标
sed -n '2,$p' scan_tmp_result > scan_result          # 获取 keys

cat scan_result |while read line                     # 循环遍历所有 keys

# 2>/dev/null，将标准错误丢弃，Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
do
    ttl_result=`./redis-cli -h $db_ip -p $db_port -a $password ttl $line 2>/dev/null`      # 使用 ttl 指令获取 key 过期时间
    # $scan_num +=1;
    if [[ $ttl_result == -1 ]];then                  # 判断过期时间，-1 是不过期
        echo $line >> no_ttlkey.log                     # 追加到指定文件
    fi
done

echo 'scan_num: '$scan_num
while [ $cursor -ne $new_cursor ]    # 若 游标 不为 0 ，则证明没有迭代完所有的 key，继续执行
do
    ./redis-cli -h $db_ip -p $db_port -a $password scan $new_cursor count $cnt 2>/dev/null> scan_tmp_result
    new_cursor=`sed -n '1p' scan_tmp_result`
    sed -n '2,$p' scan_tmp_result > scan_result
    cat scan_result |while read line
    do
        ttl_result=`./redis-cli -h $db_ip -p $db_port -a $password ttl $line 2>/dev/null`
        # $scan_num +=1;
        if [[ $ttl_result == -1 ]];then
            echo $line >> no_ttlkey.log
        fi

        #if [ $scan_num % 1000 == 0 ];then
        #    sleep 0.5
        #fi
    done
    sleep 0.1
done
rm -f scan_tmp_result
rm -f scan_result

使用python脚本导出数据

为什么要使用python，其实上面已经提到，shell无法维护长连接，在Redis数据量较大的情况下，大量的 ttl 将创建 海量连接，对性能以及Redis的稳定性都有一定影响。

脚本部分参数可通过指令传入，可按需修改脚本：

• -host：Redis连接地址，默认127.0.0.1
• -p：Redis连接端口
• -d：需要扫描的db，默认仅扫描0库
• -a：Redis连接密码
• -sn：sacn指定数量的key后便休眠1秒

脚本执行：

测试 Redis 单机版 共 30W key，按照默认的休眠频率（scan 1K 个key休眠0.5秒）总计耗时4分钟（可自行优化调整），扫描结果的 key 保存在 当前目录的{port}_{db}_no_ttl_keys.txt中。

可以看到，虽然Python版本的休眠时间更长，但是性能却提升了很多。同样你也可以使用其他可维护连接池的语言执行。

[redis@xxx redis]$ python checknottl.py -p 6378 -d 0 -a password
there are 300005 keys in db[0] 
startTime of db[0] is ：2020-12-06 10:40:09
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]100.00%
done
endTime of db[0] is ：2020-12-06 10:44:24
It takes 254.684270859 seconds :
no ttl keys number is : 300002
the file of keys with no ttl: ./6378_0_no_ttl_keys.txt

将以下脚本内容保存到checknottl.py，安装Python后再执行上面的命令即可

# encoding: utf-8
"""
modify: zxiaofan
date: 2020-12-05
func: 查找Redis中没有设置ttl的 key
脚本参考网络（auther杨奇龙），已做一定调整优化，更多Redis系列文章可前往：https://blog.csdn.net/u010887744/category_9356949.html
脚本地址：https://github.com/zxiaofan/OpenSource_Study/tree/master/redis_scripts；
Note:
    如果提示没有Redis模块“ImportError: No module named redis”
    请执行“python -m pip install redis”安装Redis模块
    默认每扫描1000个key即休眠0.5秒
"""
import redis
import argparse
import time
import sys

class ShowProcess:
    """
    显示处理进度的类
    调用该类相关函数即可实现处理进度的显示
    """
    i = 0 # 当前的处理进度
    max_steps = 0 # 总共需要处理的次数
    max_arrow = 50 # 进度条的长度

    # 初始化函数，需要知道总共的处理次数
    def __init__(self, max_steps):
        self.max_steps = max_steps
        self.i = 0

    # 显示函数，根据当前的处理进度i显示进度
    # 效果为[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]100.00%
    def show_process(self, i = None):
        if i is not None:
            self.i = i
        else:
            self.i += 1
        num_arrow = int(self.i * self.max_arrow / self.max_steps) # 计算显示多少个'>'
        num_line = self.max_arrow - num_arrow # 计算显示多少个'-'
        percent = self.i * 100.0 / self.max_steps # 计算完成进度，格式为xx.xx%
        process_bar = '[' + '>' * num_arrow + ' ' * num_line + ']'\
                      + '%.2f' % percent + '%' + '\r' # 带输出的字符串，'\r'表示不换行回到最左边
        sys.stdout.write(process_bar) # 这两句打印字符到终端
        sys.stdout.flush()

    def close(self, words='done'):
        print ''
        print words
        self.i = 0

def check_ttl(redis_conn, no_ttl_file, dbindex, scannum_thensleep):
    start_time = time.time()
    no_ttl_num = 0
    scan_num = 0
    keys_num = redis_conn.dbsize()
    print "there are {num} keys in db[{index}] ".format(num=keys_num, index=dbindex)
    # 打印扫描db开始时间
    print "startTime of db[{index}] is ：{start_time}".format(index=dbindex, start_time=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
    process_bar = ShowProcess(keys_num)
    with open(no_ttl_file, 'a') as f:

        for key in redis_conn.scan_iter(count=1000):
            process_bar.show_process()
            if redis_conn.ttl(key) == -1:
                no_ttl_num += 1
                if no_ttl_num < 1000:
                    f.write(key+'\n')
            else:
                continue

            scan_num +=1;
            if(scan_num % scannum_thensleep == 0): # scan指定数量后即休眠
                time.sleep(0.5);

    process_bar.close()
    # 打印扫db描结束时间
    print "endTime of db[{index}] is ：{end_time}".format(index=dbindex, end_time=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
    print "It takes {sec} seconds :".format(sec=(time.time() - start_time))
    print "no ttl keys number is :", no_ttl_num
    print "the file of keys with no ttl: %s" % no_ttl_file

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-p', type=int, dest='port', action='store', help='port of redis ')
    parser.add_argument('-d', type=str, dest='db_list', action='store', default=0,
                        help='ex : -d all or -d 1,2,3,4 ')
    parser.add_argument('-host', type=str, dest='host', action='store', default='127.0.0.1',
                        help=' Redis host') # 20201205，支持连接远程Redis
    parser.add_argument('-a', type=str, dest='password', action='store', default= None,
                        help=' Redis Password') # 20201205，支持传入Redis密码
    parser.add_argument('-sn', type=str, dest='scannum_thensleep', action='store', default=2000,
                        help='After the number of scanning keys reaches [scannum_thensleep], sleep for 1 second ') # 20201205，支持sacn指定数量的key后变休眠1秒
    args = parser.parse_args()
    port = args.port
    host = args.host
    password = args.password
    scannum_thensleep = int(args.scannum_thensleep)

    if args.db_list == 'all':
        db_list = [i for i in xrange(0, 16)]
    else:
        db_list = [int(i) for i in args.db_list.split(',')]
    db_list = list(set(db_list)) # 20201205，去重，避免用户重复输入db序号；

    for index in db_list:
        try:
            pool = redis.ConnectionPool(host=host, port=port, db=index, password=password) # 20201205，支持传入Redis密码
            r = redis.StrictRedis(connection_pool=pool)
        except redis.exceptions.ConnectionError as e:
            print e
        else:
            no_ttl_keys_file = "./{port}_{db}_no_ttl_keys.txt".format(port=port, db=index)
            check_ttl(r, no_ttl_keys_file, index, scannum_thensleep)

if __name__ == '__main__':
    main()

安全删除Redis中没有设置过期时间的key

利用前面提到的2种方式我们已经可以拿到没有设置过期时间的 key 了。接下来我们要做的就是数据分析，明确哪些 key 是钉子户，然后干掉它。

# deletedata.txt 数据示例：

del key-0
del key-1
del key-2
del key-3
...

考虑到大key，更推荐使用UNLINK：

• DEL：阻塞式操作
• UNLINK：并不总是 阻塞，如果值很小，和 DEL 相同效果将直接删除，如果值较大，key将被放入列表中，被另一个线程释放

# deletedata.txt 数据示例：

UNLINK key-0
UNLINK key-1
UNLINK key-2
UNLINK key-3
...

由于 UNLINK 支持多参数（DEL 也支持），所以我们还可以做进一步优化：

# deletedata.txt 数据示例：

UNLINK key-0 key-1 key-2 key-3 key-4 key-5
UNLINK key-6 key-7 key-8 key-9 key-10 key-11
...

最后我们再使用管道删除即可，如果数据量实在较大，建议分批删除

# 使用管道删除

cat deletedata.txt | redis-cli -c --pipe

转载至：https://zxiaofan.blog.csdn.net/article/details/110739644
最新脚本：https://github.com/zxiaofan/OpenSource_Study/tree/master/redis_scripts