BlogRedis

Problèmes de mémoire Redis : pourquoi l'instance plante et comment la dimensionner

Scott Sternloff

Par Scott Sternloff, Architecte d’entreprise senior

LinkedIn · Mis à jour le · Lecture : 12 min

Problèmes de mémoire Redis : pourquoi l'instance plante et comment la dimensionner
Sur cette page

Redis plante par manque de mémoire pour des raisons que la métrique used_memory ne montre pas : le fork RDB peut presque doubler la mémoire résidente sous charge d'écriture, la fragmentation de l'allocateur gonfle le RSS au-delà des données, et maxmemory ne régit que l'espace de clés, pas les buffers de réplication, les buffers clients ni le fork. Dimensionnez pour le pic plus le surcoût, pas pour le jeu de données.

Le schéma est assez constant pour constituer une signature. Une instance affiche un taux d'utilisation apparemment confortable, aucune alerte ne se déclenche, puis elle tombe. Personne n'arrive à reproduire le problème, car la métrique mémoire Redis que tout le monde surveille n'a jamais mesuré ce qui l'a fait tomber.

Que limite réellement maxmemory ?

Moins que ce que la plupart des équipes supposent. La documentation de Redis le dit sans détour : pour stocker les clés utilisateur, « Redis alloue au maximum autant de mémoire que le permet le paramètre maxmemory (de petites allocations supplémentaires restent toutefois possibles) ».

Cette phrase en dit long. maxmemory borne l'espace de clés, qui n'est qu'une partie de la mémoire totale de Redis. Il ne borne pas :

  • Le fork. Une sauvegarde en arrière-plan duplique les pages au fur et à mesure qu'elles sont modifiées. Rien dans maxmemory ne contraint ce phénomène.
  • Les buffers de sortie des clients. Un consommateur lent, une session MONITOR ou une large diffusion pub/sub accumulent côté serveur des données en attente d'envoi.
  • Le backlog de réplication. Conservé sur le primaire pour permettre aux réplicas une resynchronisation partielle, et dimensionné indépendamment.
  • Le surcoût de l'allocateur. Les pages que l'allocateur conserve mais que Redis n'utilise pas actuellement.

Lisez vos limites réelles plutôt que de vous fier aux valeurs par défaut dont vous croyez vous souvenir : elles varient selon la version et la manière dont l'instance a été provisionnée.

CONFIG GET maxmemory
CONFIG GET maxmemory-policy
CONFIG GET client-output-buffer-limit
CONFIG GET repl-backlog-size

Conséquence pratique : une instance dont maxmemory est réglé sur la totalité de la RAM de l'hôte n'est pas protégée. Elle est configurée pour tomber.

Comment maxmemory et l'éviction interagissent-ils ?

Deux paramètres, dont l'un désactive silencieusement l'autre.

maxmemory fixe le plafond. maxmemory-policy décide de ce qui se passe une fois ce plafond atteint. Si la politique est noeviction, Redis rejette les écritures avec OOM command not allowed when used memory > 'maxmemory' et continue de servir les lectures : une défaillance volontairement bruyante, adaptée à un datastore et inadaptée à un cache.

Le piège, c'est la famille volatile-*. Ces politiques ne prennent en compte que les clés dotées d'un TTL. Réglez volatile-lru sur un espace de clés où rien n'expire, et Redis n'a plus aucune candidate à l'éviction : il se comporte exactement comme noeviction, alors que votre configuration dit le contraire. Nous passons en revue toutes les options dans Politique d'éviction Redis.

Une asymétrie à connaître avant de dimensionner un ensemble de réplicas : par défaut, les réplicas ignorent maxmemory. L'éviction est pilotée par le primaire, qui propage des DEL au fil des évictions. La documentation de Redis avertit elle-même qu'un réplica « peut finir par utiliser plus de mémoire que ce qui est défini via maxmemory » et vous demande de vous assurer que les réplicas « disposent d'assez de mémoire pour ne jamais se retrouver réellement à court de mémoire avant que le maître n'atteigne le paramètre maxmemory configuré ». Un réplica dimensionné à l'identique de son primaire est sous-dimensionné.

Pourquoi used_memory_rss est-il tellement plus élevé que used_memory ?

À cause de la fragmentation. Le ratio mémoire de Redis qui vous intéresse ici relève de l'arithmétique simple :

INFO memory
# used_memory              — bytes Redis has allocated for data
# used_memory_rss          — resident set size: pages the OS has actually given the process
# mem_fragmentation_ratio  — used_memory_rss / used_memory

Un ratio proche de 1,0 est sain. Nettement au-dessus de 1, il signifie que l'allocateur conserve des pages qui ne contiennent pas de données. Cela tient au fait que, comme l'indique la documentation de Redis, « Redis ne libère pas (ne rend pas) toujours la mémoire au système d'exploitation lorsque des clés sont supprimées. Ce n'est pas une particularité de Redis : c'est ainsi que fonctionnent la plupart des implémentations de malloc() ». Supprimez 2 Go d'une instance de 5 Go, et le RSS affichera probablement toujours près de 5 Go.

Deux conséquences en découlent, et c'est la seconde qui échappe à la plupart :

  • Provisionnez pour le pic. La documentation est explicite : « vous devez provisionner la mémoire en fonction de votre pic d'utilisation mémoire. Si votre charge de travail exige de temps en temps 10 Go, même si 5 Go suffisent la plupart du temps, vous devez provisionner 10 Go. »
  • Le ratio ment après un pic. Redis le dit clairement : « le ratio de fragmentation n'est pas fiable lorsque votre utilisation mémoire au pic a été bien supérieure à la mémoire actuellement utilisée », car le RSS reflète le pic tandis que used_memory reflète l'instant présent. Un ratio de 3,0 sur une instance qui vient de se délester de la majeure partie de son espace de clés est un comportement attendu, pas une anomalie. S'acharner à le corriger par défragmentation est peine perdue.

Lorsque la fragmentation est réellement persistante sous charge stable, la défragmentation active existe :

CONFIG GET activedefrag
MEMORY PURGE

Activez-la en connaissance de cause et surveillez l'événement active-defrag-cycle dans LATENCY LATEST : la défragmentation consomme du CPU sur l'unique thread de commandes, elle échange donc de la mémoire contre de la latence.

Pourquoi Redis tombe-t-il pendant une sauvegarde ?

C'est la défaillance qui produit le fameux « ça a planté et les métriques ne montrent rien ».

Redis prend ses snapshots en forkant. Le processus enfant écrit le fichier RDB pendant que le parent continue de servir, et tous deux partagent la mémoire via le copy-on-write. Chaque page que le parent modifie pendant la sauvegarde est dupliquée. Sous une charge d'écriture soutenue, la mémoire totale du processus grimpe vers le double du jeu de données, et rien de tout cela n'apparaît dans used_memory, puisqu'il ne s'agit pas de l'espace de clés. C'est, de loin, le plus gros écart entre la consommation mémoire de Redis affichée et la consommation réelle.

INFO persistence
# rdb_bgsave_in_progress   — is a save running right now
# latest_fork_usec         — how long the last fork() blocked the server
# rdb_last_bgsave_status   — ok, or the save is failing

Nous avons enquêté sur des plantages répétés du cluster Redis d'un client dont l'utilisation affichée n'avait jamais dépassé 60 % environ. Rien dans les métriques Redis ne l'expliquait, et aucun seuil d'alerte n'avait été franchi. La cause était le comportement du fork pendant les sauvegardes, et le correctif a consisté à régler l'overcommit mémoire au niveau du noyau, pas un paramètre Redis. Le même mécanisme est à l'origine de plusieurs des défaillances de disponibilité décrites dans Haute disponibilité Redis.

Le fork a aussi un coût en latence, indépendamment de la mémoire. La documentation de Redis sur la persistance note que fork() « peut prendre du temps si le jeu de données est volumineux, et peut conduire Redis à cesser de servir les clients pendant quelques millisecondes, voire une seconde si le jeu de données est très volumineux et que le CPU n'est pas très performant ». latest_fork_usec vous donne cette valeur pour la dernière sauvegarde.

Cas terrain : des plantages à 61 % dus à une réindexation permanente

Ce cas mérite d'être détaillé, car c'est la variante du problème qu'aucun réglage de Redis n'aurait corrigée.

Lors d'une mission AceMQ, un client subissait des plantages répétés autour d'un seuil de 61 % d'utilisation mémoire. Même signature que ci-dessus : beaucoup de marge sur le papier, une instance à terre dans les faits. Mais le fork n'expliquait qu'une partie du problème. Voici ce que nous avons trouvé dans la charge de travail :

  • Chaque heartbeat d'appareil déclenchait la réindexation complète du document. L'application stockait des documents d'appareils et les indexait pour les requêtes. Un heartbeat mettait à jour un champ anodin, un horodatage, et le chemin d'écriture réindexait le document entier au lieu de l'attribut modifié. À l'échelle de la flotte, un simple signal de vie se transformait en brassage continu de l'index, avec le profil mémoire d'un rechargement massif tournant en permanence.
  • D'anciens index traînaient. Les structures d'index remplacées n'étaient pas récupérées proprement, si bien que la mémoire imputable à l'indexation augmentait avec le temps, indépendamment du volume de données. L'espace de clés paraissait stable ; le processus, lui, ne l'était pas.
  • Des champs UUID étaient indexés sans raison. Des identifiants opaques à forte cardinalité qu'aucune requête n'utilisait, chacun ajoutant une structure d'index que la charge de travail ne lisait jamais.

Cumulez ces trois facteurs et vous obtenez une instance dont la demande réelle en mémoire est dominée par la maintenance des index, avec des pics exactement au moment des pics de trafic en écriture, c'est-à-dire aussi quand un snapshot coûte le plus cher. Le chiffre de 61 % n'avait rien d'un seuil au sens propre. C'était simplement le niveau de base au moment où survenait la prochaine coïncidence entre réindexation et fork.

La remédiation que nous avons menée avec eux était d'ordre architectural, pas de configuration :

  • Séparer les données de heartbeat du document indexé. Les mises à jour de signal de vie ne doivent pas toucher une structure qui doit être réindexée. Isolez les champs volatils dans leur propre clé, avec leur propre cycle de vie.
  • Supprimer et recréer périodiquement les index plutôt que de compter sur une récupération incrémentale pour suivre le rythme du brassage. Une reconstruction planifiée restitue de la mémoire que le garbage collection incrémental n'aurait jamais atteinte à ce rythme d'écriture.
  • Régler le garbage collection des index pour que la récupération suive le rythme des écritures au lieu de prendre un retard permanent.
  • Déplacer les tâches de réindexation hors des heures de pointe, pour que l'indexation massive et le trafic d'écriture de pointe cessent de se disputer la même marge.
  • Ne plus indexer les champs qu'aucune requête n'utilise. Les UUID ont été retirés.

Rien de tout cela ne se découvre avec INFO memory. Si votre instance Redis fait tourner un moteur de requêtes sur des documents bien plus souvent écrits que structurellement modifiés, c'est le premier endroit à examiner, bien avant de toucher à maxmemory.

Faites évaluer la mémoire de votre Redis

Redis tombe à un taux d'utilisation que vos métriques jugent sûr ? Le surcoût du fork, la fragmentation et le brassage des index sont tous invisibles pour used_memory. AceMQ réalise des évaluations structurées de la mémoire Redis qui les mettent au jour, et assure un support Redis pour les entreprises sur les environnements de production. Parlez à un ingénieur AceMQ.

Comment savoir ce qui consomme réellement la mémoire Redis ?

Commencez large, puis affinez. Toutes ces commandes peuvent être lancées sans risque sur une instance de production chargée, car elles itèrent avec SCAN au lieu de bloquer sur KEYS.

MEMORY DOCTOR              # Redis's own read on whether memory looks unhealthy
MEMORY STATS               # breakdown by category: dataset, replication backlog, clients, overhead
redis-cli --memkeys        # biggest keys by bytes consumed
redis-cli --bigkeys        # biggest keys by element count, per type
redis-cli --keystats       # both, plus size distribution and a top-N list
MEMORY USAGE <key>         # exact bytes for one key

--bigkeys et --memkeys répondent à des questions différentes, et on les confond souvent. Un set de dix millions de petits entiers est énorme en nombre d'éléments et modeste en octets ; une seule chaîne contenant un blob sérialisé de 200 Mo, c'est l'inverse. Le premier est un problème de latence : toute commande en O(N) sur cette clé bloque le serveur. Le second est un problème de mémoire. Il vous faut les deux mesures.

Bridez l'une ou l'autre avec -i 0.01 pour marquer une pause entre les lots SCAN sur une instance chargée.

Un schéma mérite d'être nommé : l'amplification d'écriture due aux valeurs surdimensionnées. Stocker un objet entier et le réécrire pour modifier un seul champ, c'est payer la taille sérialisée complète à chaque mise à jour, en brassage d'allocations et, si l'instance persiste ses données, en pages copy-on-write. Les hashes mis à jour champ par champ évitent entièrement ce problème. C'est la même forme que le cas de réindexation ci-dessus, une couche plus bas.

Comment dimensionner la mémoire Redis ?

Des règles pratiques pour dimensionner la mémoire Redis, par ordre d'importance :

  1. Dimensionnez pour le pic, pas pour le régime établi. Le RSS suit le niveau maximal atteint, car l'allocateur ne rend pas facilement les pages.
  2. Sur une instance qui prend des snapshots sous charge d'écriture, maintenez le jeu de données autour de 50 à 60 % de la RAM. Le reste sert de marge pour le fork. Pas 80 %, et certainement pas 100.
  3. Si une instance n'a pas besoin de snapshots, désactivez-les. Un cache reconstructible n'a pas besoin de RDB, et supprimer le fork supprime toute cette catégorie de défaillances. Persistez plutôt sur un réplica.
  4. Alertez sur le RSS du processus, pas seulement sur used_memory. La métrique qui vous fait tomber n'est pas celle que Redis affiche.
  5. Dimensionnez les réplicas indépendamment. Par défaut, ils ignorent maxmemory et peuvent dépasser leur primaire.
  6. Laissez maxmemory nettement en dessous de la RAM de l'hôte. Le régler sur la totalité de la machine, c'est laisser l'OOM killer du noyau, et non Redis, décider de la suite.

Si vous utilisez Redis comme file d'attente et que la pression mémoire de Redis suit la profondeur de la file, la question du dimensionnement est en réalité une question d'architecture : un broker avec des files adossées au disque ne connaît pas ce mode de défaillance. Nous détaillons ce compromis dans utiliser Redis et RabbitMQ ensemble.

Pour le diagnostic plus large de ces symptômes (commandes lentes, blocages de réplication, limites de connexions), consultez notre guide de dépannage Redis.

Cet article constitue l'étape deux sur sept du guide de fiabilité Redis, qui aborde les problèmes dans l'ordre où ils surviennent sur un environnement de production.

FAQ

Pourquoi Redis plante-t-il alors que l'utilisation de la mémoire semble normale ?

Parce que used_memory mesure l'espace de clés, pas le processus. Pendant une sauvegarde en arrière-plan, le copy-on-write du fork peut porter la mémoire totale du processus vers le double du jeu de données : une instance qui affiche 60 % d'utilisation peut donc épuiser la RAM en pleine sauvegarde.

Que limite réellement maxmemory dans Redis ?

La mémoire que Redis alloue aux données utilisateur, plus de petites allocations supplémentaires. Elle ne couvre pas le fork pendant un snapshot, et les buffers peuvent pousser la mémoire résidente bien au-delà. Considérez maxmemory comme un plafond pour l'espace de clés, pas pour le processus.

Quel est un ratio de fragmentation mémoire sain pour Redis ?

Entre 1,0 et 1,5 environ sur une instance stable. Le ratio correspond à used_memory_rss divisé par used_memory : une valeur nettement supérieure à 1 signifie que l'allocateur conserve des pages que Redis n'utilise pas. Redis précise lui-même que ce ratio n'est pas fiable après un pic important dont la mémoire a depuis été libérée.

Comment savoir ce qui consomme la mémoire Redis ?

redis-cli --memkeys pour les plus grosses clés en octets et --bigkeys pour les plus grosses en nombre d'éléments. Les deux utilisent SCAN et peuvent donc être lancés en production. MEMORY USAGE <key> donne la valeur exacte pour une clé, et MEMORY STATS ventile la mémoire totale de Redis par catégorie.

De combien de RAM une instance Redis a-t-elle besoin ?

Provisionnez pour le pic, pas pour la moyenne : Redis ne rend pas de façon fiable la mémoire libérée au système d'exploitation, et le RSS suit donc le niveau maximal atteint. Sur une instance qui prend des snapshots sous charge d'écriture, maintenir le jeu de données autour de 50 à 60 % de la RAM laisse de la place pour le surcoût du fork.

Redis libère-t-il de la mémoire quand je supprime des clés ?

Pas nécessairement au profit du système d'exploitation. L'allocateur réutilise généralement l'espace libéré pour de nouvelles clés, si bien que la mémoire résidente reste stable au lieu de baisser. C'est le comportement normal de l'allocateur, pas une fuite de Redis.

Les réplicas Redis respectent-ils maxmemory ?

Par défaut, non. Les réplicas ignorent maxmemory et laissent le primaire piloter l'éviction via des commandes DEL répliquées : un réplica peut donc dépasser la limite du primaire et se retrouver réellement à court de mémoire. Surveillez la mémoire des réplicas séparément.

Pourquoi la mémoire continue-t-elle d'augmenter alors que l'espace de clés ne grossit pas ?

Regardez en dehors de l'espace de clés : les buffers de sortie des clients lents, le backlog de réplication, la fragmentation de l'allocateur et, sur les instances qui utilisent le moteur de requêtes, les structures d'index et leurs résidus, qui ne sont pas comptabilisés comme on s'y attend.

Sources

Scott Sternloff

Auteur

Scott SternloffArchitecte d’entreprise senior

Architecte d’entreprise senior chez AceMQ. Il signe ici les contenus techniques : architecture RabbitMQ, Kafka et Redis, clustering et migrations.

Consultation gratuite

Un regard expert sur votre déploiement Redis

Que vous deviez résoudre un incident de production, planifier une migration ou obtenir un second avis sur votre architecture, notre équipe est prête. Pas d’argumentaire commercial, seulement des réponses.

Nous écrire