BlogRedis

Politique d'éviction Redis : laquelle choisir et comment la configurer

Scott Sternloff

Par Scott Sternloff, Architecte d’entreprise senior

LinkedIn · Mis à jour le · Lecture : 16 min

Politique d'éviction Redis : laquelle choisir et comment la configurer
Sur cette page

Redis évince des clés lorsque l'utilisation mémoire atteint la limite configurée, et la politique d'éviction détermine quelles clés partent. Il existe dix politiques à partir de Redis 8.6, et huit sur les versions plus anciennes de Redis et sur Valkey. Par défaut, c'est noeviction, qui n'évince rien du tout : Redis se met à rejeter les écritures avec une erreur OOM. Pour un cache, vous voulez presque toujours allkeys-lru. Pour un datastore qui contient des données que vous ne pouvez pas perdre, noeviction est le bon choix, et c'est le dimensionnement qui doit suivre la charge.

Qu'est-ce qui déclenche la politique d'éviction Redis ?

Deux conditions doivent être réunies, la première étant une limite mémoire. Redis est une base de données en mémoire : c'est la directive maxmemory qui fixe le plafond. Quand l'utilisation l'atteint, la politique s'applique, Redis décide quoi évincer et évince des clés pour libérer de la place pour les nouvelles données.

CONFIG GET maxmemory-policy

Si la limite mémoire est à 0 en production, c'est la première chose à corriger.

Les dix politiques d'éviction Redis (huit sur Valkey)

PolitiquePérimètreCritère de sélection
noeviction—N'évince rien ; les commandes d'écriture échouent avec une erreur OOM
allkeys-lruToutes les clésMoins récemment utilisée
allkeys-lfuToutes les clésMoins fréquemment utilisée
allkeys-randomToutes les clésAléatoire
volatile-lruClés avec TTLMoins récemment utilisée
volatile-lfuClés avec TTLMoins fréquemment utilisée
volatile-randomClés avec TTLAléatoire
volatile-ttlClés avec TTLDurée de vie restante la plus courte
allkeys-lrmToutes les clésMoins récemment modifiée (Redis 8.6+)
volatile-lrmClés avec TTLMoins récemment modifiée (Redis 8.6+)

Redis propose dix politiques d'éviction des clés à partir de Redis 8.6. Redis 8.6.0 (février 2026) a ajouté les deux politiques « least recently modified », allkeys-lrm et volatile-lrm ; Redis 8.4 et les versions antérieures, ainsi que Valkey, disposent des huit autres. Une configuration qui nomme une politique LRM sera rejetée par un Redis plus ancien ou par Valkey : vérifiez donc INFO server avant de copier une configuration d'un environnement à l'autre. Le comportement par défaut est noeviction, ce qui surprend quiconque suppose qu'un cache évince automatiquement : il ne le fait pas tant qu'on ne le lui demande pas. allkeys-lru est le bon réglage par défaut pour un cache. Ces politiques se répartissent en deux familles.

Tableau des huit politiques d'éviction Redis classiques indiquant le périmètre, le critère de sélection et le cas d'usage type

Politiques d'éviction Redis volatile ou allkeys

Les politiques volatile-* ne prennent en compte que les clés dotées d'un TTL. Cela paraît plus sûr (n'évincer que ce qui est jetable), mais il y a un piège.

Si aucune clé n'a d'expiration, une politique volatile n'a rien à évincer et se comporte exactement comme noeviction. La mémoire se remplit, les écritures commencent à échouer, et la politique que vous avez configurée semble n'avoir rien fait. Elle a fait exactement ce qu'on lui demandait.

Il en va de même pour la base principale. N'utilisez une option volatile que si vous mélangez délibérément des données de cache (avec TTL) et des données persistantes (sans TTL) dans une même instance Redis, et seulement si la partie cache est assez volumineuse pour qu'on puisse y récupérer de la place. Sinon, utilisez une politique allkeys, ou séparez les charges : dans un cluster Redis, cela permet aussi de garder des stratégies d'éviction indépendantes par shard.

Comment fonctionnent réellement les algorithmes LRU et LFU

Aucun des deux n'est exact, et comprendre pourquoi est important pour le réglage.

La sélection par ancienneté d'accès est approximative. Un véritable algorithme LRU devrait suivre l'ordre des accès sur l'ensemble du keyspace, ce qui coûte du temps. Redis échantillonne donc des clés candidates et supprime la moins récemment utilisée parmi elles ; le nombre d'échantillons examinés est configurable :

maxmemory-samples 5

La valeur par défaut est cinq. L'augmenter améliore la précision au prix d'un peu de CPU ; la réduire à 3 est plus rapide, mais nettement moins bon. C'est l'échantillonnage qui explique qu'une clé très sollicitée soit parfois supprimée : elle ne figurait simplement pas parmi les candidates de ce tour.

L'option basée sur la fréquence suit la fréquence d'utilisation d'une clé plutôt que le moment de son dernier accès. Elle utilise un compteur probabiliste qui décroît avec le temps, si bien que les clés souvent utilisées conservent plus de chances de rester. Deux paramètres de réglage :

lfu-log-factor 10      # how fast the counter saturates for frequently accessed keys
lfu-decay-time 1       # minutes before an unused counter decays

C'est la meilleure politique de cache lorsque les accès sont déséquilibrés : quelques clés très sollicitées au milieu de nombreuses clés froides. Elle empêche une rafale de lectures ponctuelles de chasser les données populaires, ce que fera la sélection par ancienneté. Avec une longue traîne de clés rarement utilisées, elle offre de meilleures performances de cache.

Schéma montrant le LRU approximatif de Redis, qui échantillonne cinq clés candidates au lieu de parcourir tout le keyspace

allkeys-lrm et volatile-lrm : les politiques de Redis 8.6

La politique « least recently modified » (LRM) fonctionne comme LRU, à une différence près : l'horodatage que Redis utilise pour classer une clé n'est mis à jour que lors des écritures, pas lors des lectures. Avec LRU, une clé lue en permanence ne paraît jamais ancienne. Avec LRM, une clé lue en permanence mais qui n'a pas été écrite depuis longtemps est une bonne candidate à l'éviction.

Cela convient aux caches à forte lecture où la fraîcheur compte plus que la popularité : données de référence, fragments rendus ou payloads de fonctionnalités que l'application réécrit quand la source change. Des données qui ne sont plus rafraîchies sont généralement des données que la source a cessé de produire, et LRM les laisse vieillir et disparaître même si des lecteurs continuent d'y accéder. Comme LRU, l'algorithme est approximatif et utilise le même paramètre maxmemory-samples.

Ne l'utilisez pas pour un simple cache look-aside. Si les clés sont écrites une fois puis lues de nombreuses fois, LRM les classe uniquement selon l'âge de l'écriture et évincera une clé très sollicitée qui se trouve être ancienne. allkeys-lru ou allkeys-lfu reste alors le meilleur choix par défaut.

Comment configurer une politique d'éviction Redis

À chaud, sans redémarrage :

CONFIG SET maxmemory 4gb
CONFIG SET maxmemory-policy allkeys-lru

Inscrivez-la dans redis.conf pour qu'elle survive à un redémarrage :

maxmemory 4gb
maxmemory-policy allkeys-lru
maxmemory-samples 5

Comment surveiller le comportement de la politique d'éviction Redis

INFO memory       # used_memory, maxmemory, maxmemory_policy
INFO stats        # evicted_keys, expired_keys, keyspace_hits, keyspace_misses

Surveillez trois choses à chaque cycle d'éviction :

  • evicted_keys en hausse régulière : instance sous-dimensionnée pour le working set, ou mauvaise politique
  • Taux de hit en baisse pendant que le taux d'éviction grimpe : des clés récemment utilisées sont supprimées juste avant d'être de nouveau nécessaires
  • used_memory collé à la limite mémoire : normal pour un cache, alarmant pour un datastore

Éviction ou expiration dans Redis

On les confond parce que toutes deux font disparaître des clés. L'expiration s'applique clé par clé : une clé dotée d'un TTL est supprimée quand son délai arrive à échéance, que la mémoire soit sous tension ou non. L'éviction s'applique à l'instance : lorsque la mémoire utilisée dépasse maxmemory, Redis supprime des clés choisies selon maxmemory-policy jusqu'à repasser sous la limite, avec ou sans TTL.

Elles sont comptabilisées séparément dans INFO stats : expired_keys pour les expirations, evicted_keys pour les évictions. Si des clés disparaissent et que seul expired_keys augmente, les TTL sont trop courts et aucun changement de politique n'y fera rien. Si evicted_keys augmente sur une instance qui contient de l'état, l'instance est sous-dimensionnée ou utilise la mauvaise politique.

Pourquoi BullMQ exige la politique d'éviction noeviction

Si vous exécutez BullMQ sur un Redis qui sert aussi de cache, vous verrez au démarrage un avertissement du type IMPORTANT! Eviction policy is volatile-lru. It should be "noeviction". Ce n'est pas du bruit. Une file conserve les jobs, leurs verrous et les métadonnées de la file sous forme de clés Redis ordinaires, et une politique d'éviction les traite comme jetables. Sous pression mémoire, Redis peut supprimer un job en attente ou un verrou, avec pour résultat un job qui disparaît silencieusement ou s'exécute deux fois.

Le guide de mise en production de BullMQ indique explicitement que noeviction est le seul réglage qui garantit un fonctionnement correct des files. La solution consiste à exécuter CONFIG SET maxmemory-policy noeviction puis CONFIG REWRITE sur l'instance utilisée par la file. Sur un service managé, la modification se fait dans le groupe de paramètres ou la configuration plutôt qu'avec CONFIG SET. Si le même Redis sert aussi un cache qui a besoin d'éviction, séparez-les : une instance en noeviction pour la file, une autre en allkeys-lru pour le cache. Le même raisonnement s'applique à toute file de jobs, tout service de verrous ou tout magasin de sessions bâti sur Redis.

L'erreur de dimensionnement qui fait tomber la production

C'est le point sur lequel la documentation n'insiste pas, et nous le rencontrons régulièrement.

Un plafond configuré ne tient pas compte de ce dont Redis a besoin pendant une sauvegarde en arrière-plan. Quand Redis lance un fork pour écrire un snapshot, le processus enfant partage la mémoire avec le parent en copy-on-write. Chaque clé modifiée pendant la sauvegarde provoque la copie d'une page : sous charge d'écriture, la mémoire totale du processus grimpe donc jusqu'à approcher le double du dataset.

Nous avons enquêté chez un client qui subissait des plantages à répétition à environ 60 % d'utilisation mémoire. Rien dans les métriques Redis ne l'expliquait : l'utilisation restait nettement sous la limite et aucun seuil d'alerte n'avait été franchi. La cause était le comportement du fork pendant les sauvegardes, et la solution est passée par un réglage de l'overcommit au niveau du noyau, et non par un quelconque paramètre Redis.

Les règles pratiques qui en découlent :

  • Dimensionnez à environ 50 à 60 % de la RAM disponible sur une instance qui persiste ses données sous charge d'écriture. Pas 80 %, et certainement pas 100 %.
  • Alertez sur la mémoire totale du processus, et pas seulement sur used_memory. La métrique qui vous fait tomber n'est pas celle que Redis rapporte.
  • Si vous n'avez pas besoin de snapshots sur cette instance, désactivez-les : le problème disparaît complètement.

Une politique d'éviction Redis ne sert à rien si le processus meurt avant que l'éviction ne se déclenche.

Des plantages Redis que les métriques mémoire n'expliquent pas ? Leur cause se situe généralement sous Redis, dans

le comportement mémoire du noyau ou la configuration de la persistance. AceMQ mène des audits Redis structurés qui

permettent de les trouver. Parlez à un ingénieur AceMQ.

Graphique montrant la mémoire de Redis qui double pendant le fork d'une sauvegarde en arrière-plan et dépasse la RAM physique malgré le réglage de maxmemory

Bonnes pratiques de gestion de la mémoire

Définissez toujours une limite. Utilisez l'option basée sur l'ancienneté d'accès pour les caches et noeviction pour les datastores. Ne choisissez jamais une option volatile si les clés n'ont pas réellement de TTL. Laissez de la marge pour le surcoût du fork, et inscrivez la configuration dans le fichier plutôt que de vous contenter de CONFIG SET.

Toute application qui utilise Redis comme cache devrait avoir une politique d'éviction Redis choisie délibérément plutôt qu'héritée. Pour le volet disponibilité de ce même système, consultez la haute disponibilité de Redis, ou support et réponse aux incidents Redis si vous avez besoin d'aide sur un parc en production.

Politique d'éviction Redis : les réponses courtes

Voici le résumé que nous donnons à nos clients chez AceMQ avant même d'ouvrir leur configuration.

La politique d'éviction Redis par défaut est noeviction. Redis ne supprime rien de lui-même ; dès que used_memory atteint maxmemory, toute commande qui alloue de la mémoire échoue avec OOM command not allowed when used memory > 'maxmemory'. Les lectures fonctionnent toujours, les écritures non. C'est le bon choix pour un datastore, le mauvais pour un cache, et la plupart des instances que nous auditons n'ont jamais modifié ce réglage.

La règle de choix tient en quatre lignes :

  • Cache pur, toutes les clés peuvent être régénérées : allkeys-lru.
  • Certaines clés ne doivent jamais être évincées et vous posez délibérément des TTL sur les autres : volatile-lru, ou volatile-ttl si le TTL restant le plus court est le meilleur indicateur de ce qu'il faut supprimer en premier.
  • Un petit ensemble de clés très sollicitées domine le trafic et le reste est du bruit : allkeys-lfu.
  • Redis sert de datastore et perdre une clé est pire qu'une écriture refusée : noeviction, avec des alertes sur la mémoire pour agir avant d'atteindre la limite.

Deux faits qui piègent souvent. Le LRU de Redis est approximatif : il échantillonne maxmemory-samples clés (5 par défaut) et évince la meilleure candidate de cet échantillon ; passez donc à 10 si la qualité de l'éviction compte plus qu'un peu de CPU. Et la politique n'a d'effet que si maxmemory est défini ; avec maxmemory 0, Redis grossit jusqu'à ce que le noyau intervienne.

Définissez-la à chaud, puis rendez-la persistante :

CONFIG SET maxmemory 4gb
CONFIG SET maxmemory-policy allkeys-lru
CONFIG REWRITE
# or in redis.conf
maxmemory 4gb
maxmemory-policy allkeys-lru

Les mêmes paramètres et la même sémantique s'appliquent à Valkey, à ceci près que Valkey ne dispose pas des politiques LRM. Le dimensionnement de maxmemory est un problème à part entière ; consultez la mémoire Redis à ce sujet.

Les erreurs d'éviction pour lesquelles on nous appelle

Ces cinq schémas sont à l'origine de presque tous les incidents P1 liés à l'éviction que nous prenons en charge au support Redis : le symptôme qui a fait sonner l'astreinte, la cause et le correctif.

1. noeviction laissé sur un cache. Symptôme : les erreurs applicatives explosent aux heures de pointe, toutes des écritures rejetées pour OOM, alors que Redis lui-même semble en bonne santé. Cause : maxmemory a été défini à un moment donné, mais jamais la politique ; le cache s'est donc rempli et a commencé à refuser les nouvelles entrées précisément au moment où la charge était la plus forte. Correctif : CONFIG SET maxmemory-policy allkeys-lru, puis CONFIG REWRITE. Surveillez ensuite keyspace_misses pendant une semaine pour confirmer que le working set tient en mémoire.

2. allkeys-lru sur un datastore. Symptôme : des utilisateurs sont déconnectés au hasard, un verrou distribué est acquis deux fois, un rate limiter se réinitialise. Cause : des clés de session, de verrou ou de compteur cohabitent avec des données de cache dans la même instance sous une politique allkeys, et Redis les a évincées parce qu'elles étaient les moins récemment utilisées. Correctif : déplacez les clés à conserver vers une instance ou une base séparée en noeviction, ou passez en volatile-lru en vous assurant que seules les clés de cache portent un TTL. Un evicted_keys non nul sur une instance qui contient de l'état est le signe révélateur.

3. volatile-* sans aucun TTL. Symptôme : les écritures échouent pour OOM alors que la politique n'est pas noeviction. Cause : les politiques volatile ne prennent en compte que les clés dotées d'une expiration, et l'application n'en a jamais défini ; rien n'est donc évinçable et l'instance se comporte exactement comme en noeviction. Correctif : définissez un TTL sur chaque écriture de cache, ou passez à la politique allkeys-* correspondante. Commencez par vérifier INFO keyspace : si vous voyez expires=0 à côté d'un nombre élevé de keys=, c'est votre problème.

4. Un churn d'éviction qui masque une fuite mémoire. Symptôme : used_memory reste plaqué contre maxmemory, le taux de hit dérive vers le bas et evicted_keys grimpe plus vite chaque mois. Cause : quelque chose écrit des clés qui ne sont jamais relues (clés par utilisateur sans limite, payloads de jobs jamais expirés, liste qui ne fait que grandir), et l'éviction jette discrètement de vraies entrées de cache pour faire de la place à ces déchets. Correctif : échantillonnez le keyspace avec SCAN et MEMORY USAGE, identifiez le motif qui grossit et plafonnez-le à la source. L'éviction n'est pas la solution ici ; consultez mémoire qui augmente sans hausse du nombre de clés pour le cas voisin de la fragmentation.

5. Des clients en no-evict qui retiennent de la mémoire. Symptôme : l'éviction tourne mais used_memory refuse de baisser, ou une erreur OOM apparaît sur un client que vous pensiez protégé. Cause : depuis Redis 7, CLIENT NO-EVICT ON exempte une connexion de la limite maxmemory-clients, et les gros buffers de sortie de ces connexions comptent dans maxmemory sans pouvoir être récupérés par l'éviction de clés. Correctif : utilisez CLIENT LIST pour trouver les connexions exemptées et définissez client-output-buffer-limit pour qu'un consommateur lent ne puisse pas bloquer de la mémoire indéfiniment.

Ce qu'il faut surveiller sur chaque instance : evicted_keys (qui doit être à zéro sur un datastore, et stable plutôt qu'en accélération sur un cache), used_memory par rapport à maxmemory, et keyspace_hits par rapport à keyspace_misses. Un taux de hit inférieur à 80 % sur un cache en éviction active signifie que le working set ne tient pas en mémoire : la réponse est davantage de mémoire ou un dataset plus petit, pas une autre politique. Le reste de la checklist de diagnostic se trouve dans le dépannage Redis, et si vous voulez que nous relisions la configuration avant qu'elle ne vous réveille la nuit, c'est précisément le rôle du conseil Redis.

C'est l'étape deux sur sept du guide de fiabilité Redis, qui aborde les problèmes dans l'ordre où ils surviennent sur un parc en production.

FAQ

Quelle est la politique d'éviction par défaut de Redis ?

noeviction. Par défaut, Redis n'évince rien : une fois maxmemory atteint, les commandes d'écriture échouent avec une erreur de mémoire insuffisante (OOM), tandis que les lectures continuent de fonctionner.

Quelle politique d'éviction Redis choisir ?

allkeys-lru pour la plupart des caches. allkeys-lfu lorsqu'un petit ensemble de clés est beaucoup plus sollicité que le reste. noeviction lorsque les données ne sont pas jetables et que perdre une clé reviendrait à perdre des données.

Quelle est la différence entre LRU et LFU dans Redis ?

L'une évince selon l'ancienneté du dernier accès, l'autre selon la fréquence d'accès, à l'aide d'un compteur qui décroît avec le temps. L'option basée sur la fréquence résiste à une rafale de lectures ponctuelles qui chasserait les clés populaires, ce qui la rend plus adaptée aux accès très déséquilibrés.

Pourquoi ma politique d'éviction volatile n'évince-t-elle rien ?

Parce qu'aucune clé n'a de TTL. Les politiques volatile ne prennent en compte que les clés dotées d'une expiration : s'il n'y en a aucune, elles se comportent exactement comme noeviction.

L'éviction basée sur l'ancienneté d'accès est-elle exacte ?

Non. Elle échantillonne un nombre configurable de clés candidates (cinq par défaut, via maxmemory-samples) et évince la moins récemment utilisée parmi elles. Augmenter la taille de l'échantillon améliore la précision, au prix d'un peu de CPU.

Comment dimensionner maxmemory ?

Pour une instance qui prend des snapshots sous charge d'écriture, environ 50 à 60 % de la RAM disponible, afin de laisser de la place au surcoût du copy-on-write pendant un fork. Dimensionner à la quasi-totalité de la RAM disponible, c'est ainsi que des instances tombent à un taux d'utilisation qui paraît modéré.

Pourquoi Redis évince-t-il des clés alors que la mémoire n'est pas pleine ?

Généralement parce que maxmemory est plus bas que vous ne le pensez. Redis évince par rapport à son propre paramètre maxmemory, et non par rapport à la RAM du système : une instance sur un hôte de 32 Go configurée avec maxmemory 4gb commence donc à évincer à 4 Go. Vérifiez CONFIG GET maxmemory et comparez-le à used_memory dans INFO memory. L'autre cause fréquente est un surcoût qui compte dans la limite sans être des données de clés, comme les buffers de sortie des clients et le surcoût de l'allocateur. Les buffers de sortie des réplicas et le buffer AOF font exception : Redis les soustrait avant de comparer avec la limite et les signale sous mem_not_counted_for_evict. Si used_memory est proche de maxmemory mais que used_memory_dataset est bien plus faible, la limite est consommée par autre chose que les clés.

Combien de politiques d'éviction Redis propose-t-il ?

Dix à partir de Redis 8.6 : noeviction, allkeys-lru, allkeys-lrm, allkeys-lfu, allkeys-random, volatile-lru, volatile-lrm, volatile-lfu, volatile-random et volatile-ttl. Redis 8.4 et les versions antérieures, ainsi que Valkey, proposent les huit autres, sans les deux politiques LRM.

Quelle est la différence entre éviction et expiration dans Redis ?

L'expiration supprime une clé parce que son propre TTL est écoulé, quel que soit l'état de la mémoire. L'éviction supprime des clés parce que l'instance a atteint maxmemory, en les choisissant selon maxmemory-policy, qu'elles aient un TTL ou non. Elles apparaissent dans des compteurs distincts : expired_keys et evicted_keys dans INFO stats.

Pourquoi BullMQ exige-t-il la politique d'éviction noeviction ?

BullMQ stocke les jobs, les verrous et l'état des files sous forme de clés Redis, et toute éviction peut supprimer silencieusement un job ou un verrou. Son guide de mise en production indique que noeviction est le seul réglage qui garantit un fonctionnement correct des files ; BullMQ émet donc un avertissement au démarrage s'il trouve autre chose. Définissez maxmemory-policy noeviction sur l'instance de la file, ou donnez à la file sa propre instance si le même Redis sert aussi de cache.

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