Sur cette page
Vous consultez INFO memory et la mémoire utilisée ne cesse de grimper. Vous vérifiez le nombre de clés : il est stable, voire en baisse. C'est l'un des schémas de défaillance les plus déroutants de l'exploitation Redis : les calculs ne tombent pas juste, et les équipes passent souvent des jours à traquer le mauvais coupable avant de trouver le vrai.
Cet article retrace le diagnostic et le correctif à partir d'une investigation de production réelle menée sur plusieurs semaines, avec les commandes exactes et les seuils qui ont compté.
Si le nombre de clés est stable, pourquoi la mémoire continue-t-elle d'augmenter ?
Dans l'immense majorité des cas, la réponse est : ce ne sont pas vos clés, c'est votre index.
Si vous utilisez RediSearch (le module de recherche plein texte et d'index secondaires) ou tout autre module d'indexation similaire, l'index lui-même consomme de la mémoire indépendamment de votre keyspace principal. Un index qui croît sans limite, souvent parce qu'il est reconstruit ou mis à jour bien plus souvent que prévu, peut grimper jusqu'à votre limite maxmemory alors que DBSIZE n'affiche rien d'anormal.
C'est ce qui a été diagnostiqué directement lors d'un audit Redis en plusieurs sessions : l'équipe a confirmé qu'une fuite mémoire était liée au plugin d'indexation plein texte de Redis, avec une utilisation de la mémoire qui grimpait vers 60 % et provoquait des crashs pendant les opérations de réindexation. Justin Clark et Eugene Abovsky l'ont identifiée comme un bug logiciel du module d'indexation, et non comme un problème matériel ou de configuration, ni comme un phénomène se produisant dans le keyspace principal.
Première étape de diagnostic : exécutez FT.INFO <index_name> sur chacun de vos index de recherche et examinez l'empreinte mémoire indiquée pour l'index. Comparez-la au used_memory total renvoyé par INFO memory. Si l'index représente une part disproportionnée et croissante, vous avez trouvé la source de la fuite : non pas dans les données, mais dans la structure d'index qui les surplombe.
Qu'est-ce qui provoque précisément ce genre de fuite mémoire dans un index ?
La cause racine la plus fréquente est une réindexation excessive, provoquée par des mises à jour très fréquentes et de faible valeur.
Lors d'une investigation en production, l'équipe a relié la fuite aux mises à jour de heartbeat des équipements : chaque heartbeat déclenchait une réindexation complète du document associé, même lorsque le changement réel était insignifiant. Chacune de ces réindexations laissait derrière elle de la mémoire qui n'était pas récupérée, et comme les heartbeats se succédaient en continu, la fuite s'accumulait pendant des heures jusqu'au crash de l'instance.
Un second facteur aggravant identifié lors de la même investigation : l'indexation de champs qui n'ont pas besoin de l'être, comme des champs UUID. Indexer un champ à forte cardinalité comme un UUID gonfle considérablement l'empreinte mémoire de l'index pour un bénéfice minime en requêtes, car les UUID sont rarement la cible de requêtes par plage ou de recherches floues.
Questions de diagnostic à vous poser sur votre propre déploiement :
- Quels champs sont réellement indexés, et les requêtes les utilisent-elles tous ?
- Qu'est-ce qui déclenche la mise à jour d'un document : un changement d'état significatif, ou un signal très fréquent comme un heartbeat ou un tic d'horodatage ?
- Un job de réindexation planifié tourne-t-il, et se termine-t-il réellement en libérant de la mémoire, ou échoue-t-il silencieusement ?
Quel est le moyen le plus rapide de stabiliser une instance Redis qui fuit en ce moment même ?
Si vous êtes en plein incident, avec une mémoire qui grimpe vers la limite et un crash imminent, il existe une solution provisoire éprouvée : supprimer et reconstruire l'index concerné.
Cela ne corrige pas la cause racine, mais permet de récupérer de façon fiable la mémoire perdue en mitigation immédiate. Lors d'un incident, supprimer et reconstruire l'index a fait passer l'utilisation de la mémoire de 50 % à 36 % du maximum configuré, une marge suffisante pour stabiliser le système pendant la mise au point du correctif de fond.
La procédure provisoire :
- Confirmez quel index grossit de façon disproportionnée avec
FT.INFO - Planifiez la suppression/reconstruction sur une plage de faible trafic si possible : reconstruire un gros index n'est pas instantané et affecte brièvement la disponibilité des requêtes
FT.DROPINDEX <index_name>(sansDDsi vous voulez conserver les données hash/JSON sous-jacentes, puisque vous ne voulez supprimer que la structure d'index, pas vos clés)- Recréez l'index avec
FT.CREATE - Surveillez ensuite
FT.INFOetINFO memorypour confirmer que la mémoire récupérée le reste
Dans les environnements de production où le problème se reproduit, cette opération peut être automatisée sous forme de job planifié, mais traitez-la comme une mitigation, pas comme un correctif. Automatiser un contournement sans traiter le déclencheur de réindexation ne fait que repousser la fenêtre du crash.
Quels changements de configuration empêchent réellement le crash ?
Au-delà de la correction du déclencheur de réindexation lui-même, deux changements de configuration réduisent l'ampleur des dégâts pendant la mise au point du correctif de fond :
Définissez un maxmemory explicite avec une politique d'éviction adaptée. Lors d'un incident, l'équipe a mis en place un nouveau réglage de mémoire maximale associé à une politique d'éviction allkeys-lru, précisément pour protéger la stabilité du système pour des clients critiques : elle a accepté une certaine dégradation du taux de succès du cache en échange de la garantie que l'instance ne plante pas brutalement par épuisement de la mémoire. C'est un arbitrage délibéré en faveur de la stabilité au détriment des performances pendant l'investigation d'une fuite en cours, et pas nécessairement une position permanente.
Ajustez le comportement du garbage collection lorsque c'est possible. Dans des déploiements Redis faisant un large usage des modules, un tuning agressif du GC a été testé précisément pour améliorer la rétention de la mémoire ; cela vaut la peine d'être étudié si l'éditeur de votre module expose une configuration liée au GC.
Séparez les données très fréquentes et de faible valeur des clés indexées. Le correctif le plus durable identifié lors de l'investigation était d'ordre architectural : séparer complètement les données volatiles de type heartbeat des clés indexées, pour que les pings d'état de routine ne déclenchent plus du tout de réindexation. Si votre application met fréquemment à jour un petit sous-ensemble de champs d'un document par ailleurs stable, envisagez de stocker ces champs volatils dans une clé distincte, non indexée.
Faut-il mettre à niveau Redis pour corriger ce problème ?
Peut-être, mais validez d'abord le bug en question. Dans l'investigation évoquée tout au long de cet article, le diagnostic a notamment consisté à vérifier si la fuite mémoire était un problème connu et corrigé dans des versions ultérieures de Redis, l'environnement concerné tournant sur une version ancienne. Une analyse indépendante du code source du module de recherche a permis de déterminer si des versions correctives connues traitaient le schéma de fuite observé.
Avant de miser sur une mise à niveau comme correctif, vérifiez :
- Si la version précise du module que vous utilisez fait l'objet d'un correctif documenté de fuite mémoire dans une version ultérieure
- Si la fuite se situe réellement dans le module lui-même, ou dans votre schéma d'indexation (une mise à niveau ne corrigera pas un problème d'indexation d'UUID)
- Si vous disposez d'un plan de retour arrière testé, car les mises à niveau de version de Redis en production exigent le même soin que celles de tout service stateful
Est-ce une raison d'envisager une migration vers Valkey ?
Cela vaut la peine d'être évalué dans le cadre d'un plan de remédiation plus large, en particulier si vous pesez aussi des considérations de licence. Certaines équipes confrontées précisément à ce type d'instabilité liée aux modules ont profité de l'investigation pour tester en parallèle la compatibilité de Valkey, en vérifiant que leur code client et leurs schémas d'indexation existants se comportent à l'identique sur Valkey avant de s'engager dans un sens ou dans l'autre. Nous traitons cette décision plus en détail dans un article séparé.
À quoi doit ressembler la supervision continue une fois la situation stabilisée ?
Une fois le risque de crash immédiat écarté, mettez en place une supervision permanente pour que le problème ne revienne pas sans bruit :
- Suivez la mémoire des index comme une métrique distincte, et pas seulement le
used_memorytotal. Un panneau de tableau de bord affichant la mémoire remontée parFT.INFOà côté de la mémoire totale rend la prochaine fuite visible tôt, plutôt qu'à 60 % d'utilisation. - Créez des alertes sur la fréquence et la durée des jobs de réindexation. Si le rythme de réindexation change de façon inattendue (plus fréquent, ou des jobs qui échouent silencieusement), c'est votre signal d'alerte précoce.
- Vérifiez que votre politique d'éviction maxmemory correspond à votre tolérance réelle à la perte de données.
allkeys-lruprotège la stabilité mais évincera des données sous pression ; si ce n'est pas acceptable pour votre cas d'usage, le vrai correctif doit porter sur le déclencheur de réindexation, et non sur la politique d'éviction.
Se faire accompagner face aux fuites mémoire Redis et à la croissance des index
Vous constatez une mémoire Redis qui grimpe indépendamment du nombre de clés ? C'est un schéma que nous savons remonter jusqu'à sa véritable source : croissance des index, déclencheurs de réindexation et bugs de modules qu'un tuning d'infrastructure générique ne détectera pas. AceMQ fournit un support Redis pour les entreprises pour les parcs en production. Parlez à un ingénieur AceMQ.
Il s'agit de la troisième des sept étapes du guide de fiabilité Redis, qui aborde les problèmes dans l'ordre où ils se présentent sur un parc en production.
Questions fréquentes
Si le nombre de clés Redis est stable, pourquoi la mémoire continue-t-elle d'augmenter ?
Dans l'immense majorité des cas, la croissance vient d'un index, et non de votre keyspace. RediSearch et les modules d'indexation similaires consomment de la mémoire indépendamment de votre keyspace principal, et un index reconstruit ou mis à jour trop souvent peut grimper jusqu'à maxmemory alors que DBSIZE n'affiche rien d'anormal. Exécutez FT.INFO <index_name> sur chaque index de recherche et comparez son empreinte mémoire au used_memory total renvoyé par INFO memory pour le confirmer.
Qu'est-ce qui provoque ce genre de fuite mémoire dans un index Redis ?
La cause racine la plus fréquente est une réindexation excessive, provoquée par des mises à jour très fréquentes et de faible valeur : par exemple, un champ de heartbeat qui déclenche une réindexation complète du document à chaque ping. Un second facteur aggravant est l'indexation de champs qui n'ont pas besoin de l'être, comme des champs UUID à forte cardinalité, qui gonflent l'empreinte mémoire de l'index pour un bénéfice minime en requêtes.
Quel est le moyen le plus rapide de stabiliser une instance Redis qui fuit en ce moment même ?
Supprimez et reconstruisez l'index concerné. Cela ne corrige pas la cause racine, mais permet de récupérer de façon fiable la mémoire perdue en mitigation immédiate : lors d'un incident, l'utilisation est ainsi passée de 50 % à 36 % du maximum configuré. Planifiez l'opération sur une plage de faible trafic, confirmez l'index qui grossit avec FT.INFO, puis exécutez FT.DROPINDEX (sans DD pour conserver vos données) et recréez l'index avec FT.CREATE.
Quels changements de configuration empêchent réellement un crash dû à une fuite mémoire Redis ?
Définissez un maxmemory explicite avec une politique d'éviction allkeys-lru pour que l'instance ne puisse pas planter brutalement par épuisement de la mémoire, quitte à dégrader un peu le taux de succès du cache. Ajustez le comportement du garbage collection si l'éditeur de votre module l'expose. Solution la plus durable : séparez les données très fréquentes et de faible valeur, comme les heartbeats, de vos clés indexées, pour que les mises à jour de routine ne déclenchent plus du tout de réindexation.
Faut-il mettre à niveau Redis pour corriger une fuite mémoire ?
Peut-être, mais validez d'abord le bug en question. Vérifiez si la version du module que vous utilisez fait l'objet d'un correctif documenté de fuite mémoire dans une version ultérieure, si la fuite se trouve réellement dans le module ou dans votre schéma d'indexation, et si vous disposez d'un plan de retour arrière testé avant de vous engager dans une mise à niveau.
Une fuite mémoire Redis est-elle une raison d'envisager une migration vers Valkey ?
Cela vaut la peine d'être évalué dans le cadre d'un plan de remédiation plus large, surtout si vous pesez aussi des considérations de licence. Tester la compatibilité de Valkey en parallèle, en vérifiant que votre code client et vos schémas d'indexation se comportent à l'identique, vous permet d'évaluer cette option sans vous y engager d'emblée.
À quoi doit ressembler la supervision continue après la stabilisation d'une fuite mémoire Redis ?
Suivez la mémoire des index comme une métrique distincte, à côté du used_memory total, plutôt que de vous fier aux seuls chiffres agrégés. Créez des alertes sur la fréquence et la durée des jobs de réindexation pour détecter tôt tout changement inattendu. Vérifiez que votre politique d'éviction maxmemory correspond bien à votre tolérance à la perte de données, car allkeys-lru protège la stabilité mais évincera des données sous pression.