Redis 大 Key 分析利器：支持 TOP N、批量分析与从节点优先 ...

我爱普洱茶 · 5 天前

背景

Redis 大 key 分析工具主要分为两类：
1. 离线分析
基于 RDB 文件举行解析，常用工具是 redis-rdb-tools（https://github.com/sripathikrishnan/redis-rdb-tools）。
不过这个工具已近 5 年未更新，不支持 Redis 7，而且由于使用 Python 开发，解析速度较慢。
目前较为活泼的替代工具是 https://github.com/HDT3213/rdb ，该工具支持 Redis 7，并使用 Go 开发。
2. 在线分析
常用工具是 redis-cli，提供两种分析方式：

--bigkeys：Redis 3.0.0 引入，统计的是 key 中元素的数量。
--memkeys：Redis 6.0.0 引入，通过MEMORY USAGE命令统计 key 的内存占用。

这两种方式的优缺点如下：

离线分析：基于 RDB 文件举行解析，不会对线上实例产生影响，不足的是操作相对复杂，尤其是对于很多 Redis 云服务，由于禁用了 SYNC 命令，无法直接通过 redis-cli --rdb 下载 RDB 文件，只能手动从控制台下载。
在线分析：操作简单，只要有实例的访问权限，即可直接举行分析，不足的是分析过程中可能会对线上实例的性能产生一定影响。

本文要介绍的工具（redis-find-big-key）也是一个在线分析工具，其实现思路与redis-cli --memkeys类似，但功能更为强大实用。主要体如今：

支持 TOP N 功能
该工具可以或许输出内存占用最多的前 N 个 key，而 redis-cli 只能输出每种类型中占用最多的单个 key。
支持批量分析
该工具可以或许同时分析多个 Redis 节点，特别是对于 Redis Cluster，启用集群模式（-cluster-mode）后，会自动分析每个分片。而 redis-cli 只能针对单个节点举行分析。
自动选择从节点举行分析
为了减少对实例性能的影响，工具会自动选择从节点举行分析。只有在没有从节点时，才会选择主节点举行分析。而 redis-cli 只能分析主节点。

测试时间对比

测试环境：Redis 6.2.17，单实例，used_memory_human 为 9.75G，key 数量 100w，RDB 文件大小 3GB。
以下是上面提到的四个工具在获取内存占用最多的 100 个 key 时的耗时情况：
工具耗时redis-rdb-tools25m38.68shttps://github.com/HDT3213/rdb50.68sredis-cli --memkeys40.22sredis-find-big-key29.12s工具效果

# ./redis-find-big-key -addr 10.0.1.76:6379 -cluster-mode
Log file not specified, using default: /tmp/10.0.1.76:6379_20250222_043832.txt
Scanning keys from node: 10.0.1.76:6380 (slave)
Node: 10.0.1.76:6380
-------- Summary --------
Sampled 8 keys in the keyspace!
Total key length in bytes is 2.96 MB (avg len 379.43 KB)
Top biggest keys:
+------------------------------+--------+-----------+---------------------+
| Key | Type | Size | Number of elements |
+------------------------------+--------+-----------+---------------------+
| mysortedset_20250222043729:1 | zset | 739.6 KB | 8027 members |
| myhash_20250222043741:2 | hash | 648.12 KB | 9490 fields |
| mysortedset_20250222043741:1 | zset | 536.44 KB | 5608 members |
| myset_20250222043729:1 | set | 399.66 KB | 8027 members |
| myset_20250222043741:1 | set | 328.36 KB | 5608 members |
| myhash_20250222043729:2 | hash | 222.65 KB | 3917 fields |
| mylist_20250222043729:1 | list | 160.54 KB | 8027 items |
| mykey_20250222043729:2 | string | 73 bytes | 7 bytes (value len) |
+------------------------------+--------+-----------+---------------------+
Scanning keys from node: 10.0.1.202:6380 (slave)
Node: 10.0.1.202:6380
-------- Summary --------
Sampled 8 keys in the keyspace!
Total key length in bytes is 3.11 MB (avg len 398.23 KB)
Top biggest keys:
+------------------------------+--------+------------+---------------------+
| Key | Type | Size | Number of elements |
+------------------------------+--------+------------+---------------------+
| mysortedset_20250222043741:2 | zset | 1020.13 KB | 9490 members |
| myset_20250222043741:2 | set | 588.81 KB | 9490 members |
| myhash_20250222043729:1 | hash | 456.1 KB | 8027 fields |
| mysortedset_20250222043729:2 | zset | 404.5 KB | 3917 members |
| myhash_20250222043741:1 | hash | 335.79 KB | 5608 fields |
| myset_20250222043729:2 | set | 195.87 KB | 3917 members |
| mylist_20250222043741:2 | list | 184.55 KB | 9490 items |
| mykey_20250222043741:1 | string | 73 bytes | 7 bytes (value len) |
+------------------------------+--------+------------+---------------------+
Scanning keys from node: 10.0.1.147:6380 (slave)
Node: 10.0.1.147:6380
-------- Summary --------
Sampled 4 keys in the keyspace!
Total key length in bytes is 192.9 KB (avg len 48.22 KB)
Top biggest keys:
+-------------------------+--------+-----------+---------------------+
| Key | Type | Size | Number of elements |
+-------------------------+--------+-----------+---------------------+
| mylist_20250222043741:1 | list | 112.45 KB | 5608 items |
| mylist_20250222043729:2 | list | 80.31 KB | 3917 items |
| mykey_20250222043729:1 | string | 73 bytes | 7 bytes (value len) |
| mykey_20250222043741:2 | string | 73 bytes | 7 bytes (value len) |
+-------------------------+--------+-----------+---------------------+

复制代码

工具地址

项目地址：https://github.com/slowtech/redis-find-big-key
可直接下载二进制包，也可举行源码编译。
直接下载二进制包

# wget https://github.com/slowtech/redis-find-big-key/releases/download/v1.0.0/redis-find-big-key-linux-amd64.tar.gz
# tar xvf redis-find-big-key-linux-amd64.tar.gz

复制代码

解压后，会在当前目录生成一个名为redis-find-big-key的可执行文件。
源码编译

# wget https://github.com/slowtech/redis-find-big-key/archive/refs/tags/v1.0.0.tar.gz
# tar xvf v1.0.0.tar.gz
# cd redis-find-big-key-1.0.0
# go build

复制代码

编译完成后，会在当前目录生成一个名为redis-find-big-key的可执行文件。
参数解析

# ./redis-find-big-key --help
Usage of ./redis-find-big-key:
-addr string
Redis server address in the format <hostname>:<port>
-cluster-mode
Enable cluster mode to get keys from all shards in the Redis cluster
-concurrency int
Maximum number of nodes to process concurrently (default 1)
-direct
Perform operation on the specified node. If not specified, the operation will default to executing on the slave node
-log-file string
Log file for saving progress and intermediate result
-master-yes
Execute even if the Redis role is master
-password string
Redis password
-samples uint
Samples for memory usage (default 5)
-skip-lazyfree-check
Skip check lazyfree-lazy-expire
-sleep float
Sleep duration (in seconds) after processing each batch
-tls
Enable TLS for Redis connection
-top int
Maximum number of biggest keys to display (default 100)

复制代码

各个参数的具体寄义如下：

-addr：指定 Redis 实例的地址，格式为:，例如 10.0.0.108:6379。注意，
- 如果不启用集群模式（-cluster-mode），可以指定多个地址，地址之间用逗号分隔，例如 10.0.0.108:6379,10.0.0.108:6380。
- 如果启用集群模式，只能指定一个地址，工具会自动发现集群中的其它节点。
-cluster-mode：开启集群模式。工具会自动分析 Redis Cluster 中的每个分片，并优先选择从节点，只有在对应分片没有从节点时，才会选择主节点举行分析。
-concurrency：设置并发度，默认值为 1，即逐个节点举行分析。如果要分析的节点比较多，可以增长并发度来提升分析速度。
-direct：在 -addr 指定的节点上直接举行分析，这样会跳过自动选择从节点这个默认逻辑。
-log-file：指定日志文件路径，用于记录分析过程中的进度信息和中间过程信息。不指定则默认是/tmp/_.txt，例如 /tmp/10.0.0.108:6379_20250218_125955.txt。
-master-yes：如果待分析的节点中存在主节点（常见原因：从节点不存在；通过 -direct 参数指定要在主节点上分析），工具会提示以下错误：

Error: nodes 10.0.1.76:6379 are master. To execute, you must specify --master-yes

如果确定可以在主节点上举行分析，可指定 -master-yes 跳过检测。
-password：指定 Redis 实例的密码。
-samples：设置MEMORY USAGE key [SAMPLES count]命令中的采样数量。对于包含多个元素的数据结构（如 LIST、SET、ZSET、HASH、STREAM 等），采样数量过低可能导致内存占用估算不准确，而过高则会增长计算时间和资源消耗。SAMPLES 不指定的话，默认为 5。
-skip-lazyfree-check：如果是在主节点上举行分析，需要特别注意过期大 key。因为扫描操作会触发过期 key 的删除，如果未开启惰性删除（lazyfree-lazy-expire），删除操作将在主线程中执行，此时，删除大 key 可能会导致阻塞，影响正常的业务哀求。
因此，当工具在主节点上举行分析时，会自动查抄该节点是否启用了惰性删除。如果未启用，工具将提示以下错误并终止操作，以避免对线上业务造成影响：

Error: nodes 10.0.1.76:6379 are master and lazyfree-lazy-expire is set to 'no'. Scanning might trigger large key expiration, which could block the main thread. Please set lazyfree-lazy-expire to 'yes' for better performance. To skip this check, you must specify --skip-lazyfree-check

在这种情况下，建议通过CONFIG SET lazyfree-lazy-expire yes命令开启惰性删除。
如果确认没有过期大 key，可指定 -skip-lazyfree-check 跳过检测。
-sleep：设置每扫描完一批数据后的休眠时间。
-tls：启用 TLS 连接。
-top: 显示占用内存最多的前 N 个 key。默认是 100。

常见用法

分析单个节点

./redis-find-big-key -addr 10.0.1.76:6379
Scanning keys from node: 10.0.1.202:6380 (slave)

复制代码

注意，在上面的示例中，指定的节点和实际扫描的节点并不相同。这是因为 10.0.1.76:6379 是主节点，而该工具默认会选择从库举行分析。只有当指定的主节点没有从库时，工具才会直接扫描该主节点。
分析单个 Redis 集群

./redis-find-big-key -addr 10.0.1.76:6379 -cluster-mode

复制代码

只需提供集群中任意一个节点的地址，工具会自动获取集群中其它节点的地址。同时，工具会优先选择从节点举行分析，只有在某个分片没有从节点时，才会选择该分片的主节点举行分析。
分析多个节点

./redis-find-big-key -addr 10.0.1.76:6379,10.0.1.202:6379,10.0.1.147:6379

复制代码

节点之间是相互独立的，可以来自同一个集群，也可以来自不同的集群。注意，如果 -addr 参数指定了多个节点地址，则不能再使用 -cluster-mode 参数。
对主节点举行分析

如果需要对主节点举行分析，可指定主节点并使用-direct参数。

./redis-find-big-key -addr 10.0.1.76:6379 -direct -master-yes

复制代码

注意事项

1. 该工具仅实用于 Redis 4.0 及以上版本，因为MEMORY USAGE和lazyfree-lazy-expire是从 Redis 4.0 开始支持的。
2. 同一个 key 在 redis-find-big-key 和 redis-cli 中显示的大小可能不一致，这是正常现象。原因在于，redis-find-big-key 默认选择从库举行分析，因此通常显示的是从库中的 key 大小，而 redis-cli 只能对主库举行分析，显示的是主库中的 key 大小。看下面这个示例。

# ./redis-find-big-key -addr 10.0.1.76:6379 -top 1
Scanning keys from node: 10.0.1.202:6380 (slave)
...
Top biggest keys:
+------------------------------+------+------------+--------------------+
| Key | Type | Size | Number of elements |
+------------------------------+------+------------+--------------------+
| mysortedset_20250222043741:2 | zset | 1020.13 KB | 9490 members |
+------------------------------+------+------------+--------------------+
# redis-cli -h 10.0.1.76 -p 6379 -c MEMORY USAGE mysortedset_20250222043741:2
(integer) 1014242
# echo "scale=2; 1014242 / 1024" | bc
990.47

复制代码

一个是 1020.13 KB，一个是 990.47 KB。
如果直接通过 redis-find-big-key 查看主库中该 key 的大小，结果与 redis-cli 完全一致：

# ./redis-find-big-key -addr 10.0.1.76:6379 -direct --master-yes -top 1 --skip-lazyfree-check
Scanning keys from node: 10.0.1.76:6379 (master)
...
Top biggest keys:
+------------------------------+------+-----------+--------------------+
| Key | Type | Size | Number of elements |
+------------------------------+------+-----------+--------------------+
| mysortedset_20250222043741:2 | zset | 990.47 KB | 9490 members |
+------------------------------+------+-----------+--------------------+

复制代码

实现原理

该工具是参考redis-cli --memkeys实现的。
实际上，无论是redis-cli --bigkeys照旧redis-cli --memkeys，调用的都是findBigKeys函数，只不过传入的参数不一样。

/* Find big keys */
if (config.bigkeys) {
if (cliConnect(0) == REDIS_ERR) exit(1);
findBigKeys(0, 0);
}
/* Find large keys */
if (config.memkeys) {
if (cliConnect(0) == REDIS_ERR) exit(1);
findBigKeys(1, config.memkeys_samples);
}

复制代码

接下来，我们看一下这个函数的具体实现逻辑。

static void findBigKeys(int memkeys, unsigned memkeys_samples) {
...
// 通过 DBSIZE 命令获取 key 的总数量
total_keys = getDbSize();
/* Status message */
printf("\n# Scanning the entire keyspace to find biggest keys as well as\n");
printf("# average sizes per key type. You can use -i 0.1 to sleep 0.1 sec\n");
printf("# per 100 SCAN commands (not usually needed).\n\n");
/* SCAN loop */
do {
/* Calculate approximate percentage completion */
pct = 100 * (double)sampled/total_keys;
// 通过 SCAN 命令扫描 key
reply = sendScan(&it);
scan_loops++;
// 获取当前批次的 key 名称。
keys = reply->element[1];
...
// 使用 pipeline 技术批量发送 TYPE 命令，获取每个 key 的类型
getKeyTypes(types_dict, keys, types);
// 使用 pipeline 技术批量发送相应命令获取每个 key 的大小
getKeySizes(keys, types, sizes, memkeys, memkeys_samples);
// 逐个处理 key，更新统计信息
for(i=0;i<keys->elements;i++) {
typeinfo *type = types[i];
/* Skip keys that disappeared between SCAN and TYPE */
if(!type)
continue;
type->totalsize += sizes[i]; // 累计每个类型 key 的总大小
type->count++; // 累计每个类型 key 的数量
totlen += keys->element[i]->len; // 累计 key 的长度
sampled++; // 累计扫描的 key 的数量
// 如果当前 key 的大小超过该类型的最大值，则会更新该类型的最大键大小，并打印统计信息。
if(type->biggest<sizes[i]) {
if (type->biggest_key)
sdsfree(type->biggest_key);
type->biggest_key = sdscatrepr(sdsempty(), keys->element[i]->str, keys->element[i]->len);
...
printf(
"[%05.2f%%] Biggest %-6s found so far '%s' with %llu %s\n",
pct, type->name, type->biggest_key, sizes[i],
!memkeys? type->sizeunit: "bytes");
type->biggest = sizes[i];
}
// 每扫描 100 万个 key，还会输出当前进度和扫描的 key 数量。
if(sampled % 1000000 == 0) {
printf("[%05.2f%%] Sampled %llu keys so far\n", pct, sampled);
}
}
// 如果设置了 interval，则每执行 100 次 SCAN 命令，都会 sleep 一段时间。
if (config.interval && (scan_loops % 100) == 0) {
usleep(config.interval);
}
freeReplyObject(reply);
} while(force_cancel_loop == 0 && it != 0);
..
// 输出总的统计信息
printf("\n-------- summary -------\n\n");
if (force_cancel_loop) printf("[%05.2f%%] ", pct); // 如果循环被取消，则显示进度百分比
printf("Sampled %llu keys in the keyspace!\n", sampled); // 打印已经扫描的 key 的数量
printf("Total key length in bytes is %llu (avg len %.2f)\n\n",
totlen, totlen ? (double)totlen/sampled : 0); // 打印 key 名的总长度及平均长度
// 输出每种类型最大键的信息
di = dictGetIterator(types_dict);
while ((de = dictNext(di))) {
typeinfo *type = dictGetVal(de);
if(type->biggest_key) {
printf("Biggest %6s found '%s' has %llu %s\n", type->name, type->biggest_key,
type->biggest, !memkeys? type->sizeunit: "bytes");
} // type->name 是 key 的类型名称，type->biggest_key 是最大键的名称
} // type->biggest 是最大键的大小，!memkeys? type->sizeunit: "bytes" 是大小单位。
..
// 输出每种类型的统计信息
di = dictGetIterator(types_dict);
while ((de = dictNext(di))) {
typeinfo *type = dictGetVal(de);
printf("%llu %ss with %llu %s (%05.2f%% of keys, avg size %.2f)\n",
type->count, type->name, type->totalsize, !memkeys? type->sizeunit: "bytes",
sampled ? 100 * (double)type->count/sampled : 0,
type->count ? (double)type->totalsize/type->count : 0);
} // sampled ? 100 * (double)type->count/sampled : 0 是当前类型的 key 的数量在总扫描的 key 数量中的百分比。
..
exit(0);
}

复制代码

该函数的实现逻辑如下：

使用 DBSIZE 命令获取 Redis 数据库中的 key 总数。
使用 SCAN 命令批量扫描 key，并获取当前批次的 key 名称。
使用 pipeline 批量发送 TYPE 命令，获取每个 key 的类型。
使用 pipeline 批量发送相应命令获取每个 key 的大小：
- 若指定了 --bigkeys，根据 key 的类型使用对应命令获取大小：STRLEN（string 类型）、LLEN（list 类型）、SCARD（set 类型）、HLEN（hash 类型）、ZCARD（zset 类型）、XLEN（stream 类型）。
- 若指定了 --memkeys，使用 MEMORY USAGE 命令获取 key 的内存占用。
逐个处理 key，更新统计信息：若某个 key 的大小凌驾该类型的最大值，则更新最大值并打印相关统计信息。
输出总结信息，展示每种 key 类型的最大 key 及其相关统计数据。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

Redis 大 Key 分析利器：支持 TOP N、批量分析与从节点优先 ...

0 个回复

快速回复

楼主热帖

标签云