Quels sont les dépannages et les solutions pour BigKey dans Redis ?

Abstract

Redis est une base de données en mémoire avec de fortes performances, mais lors de l'utilisation, nous pouvons rencontrer des problèmes de Big Key Ce problème est Redis La valeur de. une certaine clé est trop grande, donc Le problème Big Key est essentiellement un problème de grande valeur, entraînant une baisse ou un crash des performances de Redis.

Introduction au problème Big Key

Dans Redis, chaque clé a une valeur correspondante Si la valeur d'une clé est trop grande, cela entraînera une diminution des performances de Redis. Ou un crash, qui est plus métaphysique que métaphysique, Parce que Redis doit charger toutes les grosses clés en mémoire, ce qui occupera beaucoup d'espace mémoire et réduira la vitesse de réponse de Redis. Ce problème est appelé le problème Big Key#. 🎜🎜#. Ne sous-estimez pas ce problème, cela peut transformer instantanément votre Redis en « tortue ». En raison de la nature monothread de Redis, l'utilisation de Big Key prend généralement du temps, ce qui signifie que la possibilité de bloquer Redis est plus grande, ce qui est plus important. entraînera le blocage du client ou provoquera un basculement, ce qui peut entraîner une « requête lente ».

De manière générale, les deux situations suivantes sont appelées grosses clés :

• Clé de type chaîne correspondant à une valeur supérieure à 10 Mo.

• Liste, set, hash, zset et autres types de collection, le nombre d'éléments de collection dépasse 5000.

Les critères ci-dessus pour juger Big Key ne sont pas les seuls, juste une norme approximative. Il faut évaluer en fonction du scénario d'application spécifique s'il s'agit d'une grande clé du développement commercial réel. Si le fonctionnement d'une certaine clé entraîne un ralentissement du temps de réponse à la demande, la clé peut être déterminée comme une grande clé.

Dans Redis, les grandes clés sont généralement causées par les raisons suivantes  :

#🎜 🎜#Le la taille de l'objet après la sérialisation est trop grande
Conteneurs qui stockent de grandes quantités de données, telles que des ensembles, des listes, etc.

• # 🎜🎜## 🎜🎜#Grandes structures de données, telles que bitmap, hyperloglog, etc.

• Si ces grosses clés ne sont pas traitées à temps, elles consommeront progressivement le ressources mémoire du serveur Redis et éventuellement provoquer le crash de Redis.

Dépannage des problèmes de grande clé

Lorsque les performances de Redis diminuent fortement, cela est probablement dû à l'existence d'une grande clé. Lors du dépannage de gros problèmes de clé, vous pouvez envisager les méthodes suivantes :

Utilisez la commande BIGKEYS

La commande BIGKEYS fournie avec Redis peut interroger les informations de toutes les clés du fichier actuel. Redis. Effectuez une analyse statistique sur la taille des paires clé-valeur dans l'ensemble de la base de données, par exemple, comptez le nombre et la taille moyenne des paires clé-valeur pour chaque type de données. De plus, une fois cette commande exécutée, les informations du plus grand bigkey dans chaque type de données seront affichées. Pour le type String, la longueur en octets du plus grand bigkey sera affichée. Pour le type de collection, le nombre d'éléments du. la plus grande clé sera affichée.# 🎜🎜#

La commande BIGKEYS analysera toute la base de données. Cette commande elle-même bloquera Redis, trouvera toutes les grandes clés et les renverra au client dans. la forme d'une liste.

Le format de la commande est le suivant :

$ redis-cli --bigkeys

L'exemple de retour est le suivant :

# Scanning the entire keyspace to find biggest keys as well as
# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
# per 100 SCAN commands (not usually needed).

[00.00%] Biggest string found so far 'a' with 3 bytes
[05.14%] Biggest list   found so far 'b' with 100004 items
[35.77%] Biggest string found so far 'c' with 6 bytes
[73.91%] Biggest hash   found so far 'd' with 3 fields

-------- summary -------

Sampled 506 keys in the keyspace!
Total key length in bytes is 3452 (avg len 6.82)

Biggest string found 'c' has 6 bytes
Biggest   list found 'b' has 100004 items
Biggest   hash found 'd' has 3 fields

504 strings with 1403 bytes (99.60% of keys, avg size 2.78)
1 lists with 100004 items (00.20% of keys, avg size 100004.00)
0 sets with 0 members (00.00% of keys, avg size 0.00)
1 hashs with 3 fields (00.20% of keys, avg size 3.00)
0 zsets with 0 members (00.00% of keys, avg size 0.00)

BIGKEYS命令会扫描整个数据库，这个命令本身会阻塞Redis，找出所有的大键，并将其以一个列表的形式返回给客户端。

命令格式如下：

redis 127.0.0.1:6379> DEBUG OBJECT key
Value at:0xb6838d20 refcount:1 encoding:raw serializedlength:9 lru:283790 lru_seconds_idle:150

redis 127.0.0.1:6379> DEBUG OBJECT key
(error) ERR no such key

返回示例如下：

127.0.0.1:6379> set k1 value1
OK
127.0.0.1:6379> memory usage k1    //这里k1 value占用57字节内存
(integer) 57
127.0.0.1:6379> memory usage aaa  // aaa键不存在，返回nil.
(nil)

需要注意的是，由于BIGKEYS命令需要扫描整个数据库，所以它可能会对Redis实例造成一定的负担。在执行这个命令之前，请确保您的Redis实例有足够的资源来处理它，建议在从节点执行。

Debug Object

如果我们找到了Big Key，就需要对其进行进一步的分析。我们可以使用命令debug object keyIl est à noter que car le La commande BIGKEYS nécessite d'analyser l'intégralité de la base de données, elle peut donc imposer une certaine charge à l'instance Redis.

Avant d'exécuter cette commande, veuillez vous assurer que votre instance Redis dispose de suffisamment de ressources pour la gérer. Il est recommandé d'exécuter

sur le nœud esclave.

Debug Object

Si nous trouvons la grande clé, nous devons l'analyser plus en détail. Nous pouvons utiliser la commande debug object key pour afficher les informations détaillées d'une clé, y compris la taille de la valeur de la clé, etc. À ce stade, vous pouvez « jeter un œil » à l’intérieur de Redis pour voir quelle clé est trop volumineuse.

Lorsque la clé existe, la commande Debug Object fournit des informations sur la clé et est une commande de débogage. Lorsque la clé n'existe pas, une erreur est renvoyée.

127.0.0.1:6379> hlen hkey    // hkey有100w个字段，每个字段的value长度介于1~1024个字节
(integer) 1000000
127.0.0.1:6379> MEMORY usage hkey   //默认SAMPLES为5，分析hkey键内存占用521588753字节
(integer) 521588753
127.0.0.1:6379> MEMORY usage hkey SAMPLES  1000 //指定SAMPLES为1000，分析hkey键内存占用617977753字节
(integer) 617977753
127.0.0.1:6379> MEMORY usage hkey SAMPLES  10000 //指定SAMPLES为10000，分析hkey键内存占用624950853字节
(integer) 624950853

serializedlength représente le nombre d'octets après sérialisation de la valeur correspondant à la clé

utilisation de la mémoire

Avant Redis 4.0, cela ne pouvait être effectué via DEBUG La commande OBJECT estime l'utilisation de la mémoire de la clé (champ sérialisélongueur), mais la commande DEBUG OBJECT contient des erreurs.

Pour la version 4.0 et supérieure, nous pouvons utiliser la commande memory usag.

La commande d'utilisation de la mémoire est très simple à utiliser, il suffit d'appuyer directement sur le nom de la clé d'utilisation de la mémoire ; si la clé actuelle existe, l'estimation réelle de l'utilisation de la mémoire de la valeur de la clé est renvoyée ; n'existe pas, nul est renvoyé.

pip install rdbtools

Pour les types autres que le type String, la commande d'utilisation de la mémoire adopte la méthode d'échantillonnage. Par défaut, 5 éléments sont échantillonnés, le calcul est donc une valeur approximative. Nous pouvons également spécifier le nombre d'échantillons.

Exemple de description : Générez une clé de hachage de 1 million de champs : hkey La longueur de la valeur de chaque champ est une valeur aléatoire de 1 à 1024 octets.

rdb -c memory dump.rdb > memory.csv

Pour obtenir une valeur de mémoire de clé plus précise, spécifiez un nombre d'échantillonnage plus grand. Cependant, plus le nombre d’échantillons est grand, plus le temps CPU est occupé.

redis-rdb-tools

redis-rdb-tools est un outil python pour analyser les fichiers rdb lors de l'analyse de la mémoire, nous l'utilisons principalement pour générer des instantanés de mémoire. Vous pouvez convertir le fichier d'instantané rdb en fichier CSV ou JSON et l'importer dans MySQL pour générer des rapports d'analyse.

#🎜🎜#Installer avec PYPI#🎜🎜#

CREATE TABLE `memory` (
     `database` int(128) DEFAULT NULL,
     `type` varchar(128) DEFAULT NULL,
     `KEY` varchar(128),
     `size_in_bytes` bigint(20) DEFAULT NULL,
     `encoding` varchar(128) DEFAULT NULL,
     `num_elements` bigint(20) DEFAULT NULL,
     `len_largest_element` varchar(128) DEFAULT NULL,
     PRIMARY KEY (`KEY`)
 );

#🎜🎜#Générer un instantané de mémoire#🎜🎜#

mysql> SELECT * FROM memory ORDER BY size_in_bytes DESC LIMIT 3;
+----------+------+-----+---------------+-----------+--------------+---------------------+
| database | type | key | size_in_bytes | encoding  | num_elements | len_largest_element |
+----------+------+-----+---------------+-----------+--------------+---------------------+
|        0 | set  | k1  |        624550 | hashtable |        50000 | 10                  |
|        0 | set  | k2  |        420191 | hashtable |        46000 | 10                  |
|        0 | set  | k3  |        325465 | hashtable |        38000 | 10                  |
+----------+------+-----+---------------+-----------+--------------+---------------------+
3 rows in set (0.12 sec)

#🎜🎜#Dans le fichier CSV généré, il y a les colonnes suivantes : #🎜🎜#

• database key在Redis的db

• type key类型

• key key值

• size_in_bytes key的内存大小

• encoding value的存储编码形式

• num_elements key中的value的个数

• len_largest_element key中的value的长度

可以在MySQL中新建表然后导入进行分析，然后可以直接通过SQL语句进行查询分析。

CREATE TABLE `memory` (
     `database` int(128) DEFAULT NULL,
     `type` varchar(128) DEFAULT NULL,
     `KEY` varchar(128),
     `size_in_bytes` bigint(20) DEFAULT NULL,
     `encoding` varchar(128) DEFAULT NULL,
     `num_elements` bigint(20) DEFAULT NULL,
     `len_largest_element` varchar(128) DEFAULT NULL,
     PRIMARY KEY (`KEY`)
 );

例子：查询内存占用最高的3个 key

mysql> SELECT * FROM memory ORDER BY size_in_bytes DESC LIMIT 3;
+----------+------+-----+---------------+-----------+--------------+---------------------+
| database | type | key | size_in_bytes | encoding  | num_elements | len_largest_element |
+----------+------+-----+---------------+-----------+--------------+---------------------+
|        0 | set  | k1  |        624550 | hashtable |        50000 | 10                  |
|        0 | set  | k2  |        420191 | hashtable |        46000 | 10                  |
|        0 | set  | k3  |        325465 | hashtable |        38000 | 10                  |
+----------+------+-----+---------------+-----------+--------------+---------------------+
3 rows in set (0.12 sec)

Big Key问题解决思路

当发现存在大key问题时，我们需要及时采取措施来解决这个问题。下面列出几种可行的解决思路：

分割大key

将Big Key拆分成多个小的key。这个方法比较简单，但是需要修改应用程序的代码。虽然有些费力，但将一个大蛋糕切成小蛋糕可以解决问题。

或者尝试将Big Key转换成Redis的数据结构。例如，可以使用哈希表、列表或集合等数据结构将“Big Key”进行转换。

对象压缩

若大key的大小源于对象序列化后的体积巨大，我们可思考运用压缩算法来缩小对象的尺寸。Redis自身支持多种压缩算法，例如LZF、Snappy等。

直接删除

如果你所用的Redis版本是4.0或更高版本，你可以使用unlink命令进行异步删除。4.0以下的版本 可以考虑使用 scan ,分批次删除。

无论采用哪种方法，都需要注意以下几点：

• 避免使用过大的value。如果需要存储大量的数据，可以将其拆分成多个小的value。就像是吃饭一样，一口一口的吃，不要贪多嚼不烂。

• 避免使用不必要的数据结构。如果只需要保存一个字符串，应该避免使用像Hash或List这样的数据结构。

• 定期清理过期的key。当Redis中存在大量过期的key时，会导致Redis性能下降。就像是家里的垃圾，需要定期清理。

• 对象压缩

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!