玩转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性能趋势

阿里云CloudDBA性能趋势Keys

查看全局节点的实时性能

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

阿里云CloudDBA全局节点实时性能

云数据库Redis监控指标说明

监控指标 单位 说明
Keys Counts Key总数量,实例存储的一级Key总数
Expires Counts 实例中设置了过期时间的键值对数量,该指标展示的是采集数据时的瞬时值
ExpiredKeys Counts 历史累计淘汰的Key总数
EvictedKeys Counts 历史累计驱逐的Key总数
ExpiredKeysPerSecond Counts/s 每秒被淘汰的Key数量
EvictedKeysPerSecond Counts/s 每秒被驱逐的Key数量

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

使用Redis命令行查看

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

1
2
3
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中。

1
2
3
4
5
6
7
[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授予执行权限:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#!/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版本的休眠时间更长,但是性能却提升了很多。同样你也可以使用其他可维护连接池的语言执行。

1
2
3
4
5
6
7
8
9
[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后再执行上面的命令即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
# 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 是钉子户,然后干掉它。

1
2
3
4
5
6
7
# deletedata.txt 数据示例:

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

考虑到大key,更推荐使用UNLINK

  • DEL:阻塞式操作
  • UNLINK:并不总是 阻塞,如果值很小,和 DEL 相同效果将直接删除,如果值较大,key将被放入列表中,被另一个线程释放
1
2
3
4
5
6
7
# deletedata.txt 数据示例:

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

由于 UNLINK 支持多参数(DEL 也支持),所以我们还可以做进一步优化:

1
2
3
4
5
# 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
...

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

1
2
3
# 使用管道删除

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

Powered by AppBlog.CN     浙ICP备14037229号

Copyright © 2012 - 2021 APP开发技术博客 All Rights Reserved.

访客数 : | 访问量 :