Sur cette page
La plupart des incidents Redis en production se ramènent à cinq causes : la mémoire qui atteint maxmemory, une commande O(N) qui bloque la boucle d'événements monothread, l'éviction qui supprime discrètement des clés dont l'application avait encore besoin, une réplication qui prend du retard et force une resynchronisation complète, ou des connexions qui épuisent la limite de clients. Vérifiez-les dans cet ordre avant d'ouvrir le moindre fichier journal.
Un dépannage Redis efficace consiste surtout à vérifier la bonne chose en premier. Voici les pannes que nous rencontrons le plus souvent sur les parcs d'entreprise, chacune avec la commande qui la confirme, plutôt qu'une description qu'il vous faudrait traduire en commande.
Le dépannage Redis commence par trois commandes
Le dépannage Redis tourne mal quand on se jette d'abord sur les journaux. Les journaux Redis sont volontairement succincts : la plupart des pannes ci-dessous ne laissent aucune ligne de log. L'état du serveur, lui, en garde la trace.
INFO # role, uptime, clients, persistence, replication
INFO memory # used_memory, maxmemory, fragmentation
SLOWLOG GET 25 # commands that exceeded the slow-log thresholdTrois questions, dans cet ordre :
- L'instance manque-t-elle de mémoire ? Un
used_memoryégal ou proche demaxmemoryexplique les écritures rejetées, les évictions et une bonne part des signalements « Redis est lent ». - Une commande a-t-elle bloqué le serveur ? Redis exécute les commandes sur un seul thread. Une commande lente bloque tous les clients, et le slow log est le seul endroit où ce fait est consigné.
- Ce nœud est-il dans l'état que vous croyez ? Un réplica qui a été promu, ou un primaire devenu discrètement réplica après un failover, produit des erreurs qui ne ressemblent en rien à leur cause.
Résistez à l'envie de redémarrer. Un redémarrage vide le slow log, remet à zéro les compteurs d'INFO et efface la série temporelle de latence : un problème diagnosticable devient une simple anecdote.
1. Pourquoi Redis renvoie-t-il « OOM command not allowed » ?
Problème. Les écritures échouent avec OOM command not allowed when used memory > 'maxmemory'. Les lectures fonctionnent toujours : la supervision indique que le service est disponible alors que l'application est à moitié cassée.
CONFIG GET maxmemory
CONFIG GET maxmemory-policySi maxmemory-policy vaut noeviction, Redis fait exactement ce qu'on lui a demandé : refuser les écritures plutôt que supprimer des données. Correct pour un datastore, inadapté pour un cache.
Correctif. Déterminez ce que vous exploitez réellement. Pour un cache, définissez une politique d'éviction et laissez Redis récupérer de l'espace : nous détaillons les huit options dans la politique d'éviction Redis. Pour un datastore, l'erreur est un signal de capacité ; augmenter maxmemory sur un hôte qui ne peut pas suivre transforme une erreur propre en arrêt brutal par l'OOM killer du noyau.
Un piège met fin à plus de sessions de dépannage Redis qu'il ne le devrait : maxmemory réglé à 0 signifie aucune limite. Un Redis non borné grossit jusqu'à ce que le noyau le tue, et le noyau n'envoie pas d'erreur polie auparavant.
2. Pourquoi Redis est-il lent alors que le CPU et la mémoire semblent normaux ?
Problème. Des pics de latence sans pression mémoire, sans swap, avec un CPU presque inactif. La cause est presque toujours la même : Redis traite les commandes sur un seul thread, donc une commande O(N) sur une grosse collection monopolise ce thread pendant que tous les autres clients attendent.
SLOWLOG GET 25
CONFIG GET slowlog-log-slower-than # microsecondsLe slow log n'enregistre que le temps d'exécution (il exclut le temps passé à échanger avec le client) : une entrée signifie donc que le serveur a réellement été bloqué aussi longtemps. Chaque entrée indique la durée en microsecondes, les arguments de la commande ainsi que l'adresse et le port du client, ce qui suffit en général à identifier le service fautif sans l'instrumenter.
Les coupables habituels : KEYS *, SMEMBERS sur un grand set, HGETALL sur un hash surdimensionné, un LRANGE key 0 -1 non borné et les longs scripts Lua, qui s'exécutent de manière atomique et bloquent pendant toute leur durée.
Correctif. Remplacez les lectures de collections entières par une itération par curseur (SCAN, SSCAN, HSCAN, ZSCAN), qui renvoie des blocs bornés au lieu d'un seul appel bloquant. Cherchez ensuite comment la collection a pu devenir aussi volumineuse :
redis-cli --bigkeys # biggest keys by element count
redis-cli --memkeys # biggest keys by bytesLes deux parcourent l'espace de clés avec SCAN, et non KEYS : ils sont donc sans danger en production. Ajoutez -i 0.01 pour les ralentir sur une instance chargée.
Avant d'aller plus loin, activez la supervision de la latence. latency-monitor-threshold vaut 0 par défaut, ce qui désactive entièrement le sous-système : LATENCY DOCTOR ne rapporte alors rien et l'on en conclut que l'outil est cassé. C'est l'impasse la plus fréquente du dépannage Redis.
CONFIG SET latency-monitor-threshold 100 # millisecondsRedis enregistre alors les pics par événement nommé : command, fork, expire-cycle, eviction-cycle, la famille aof-* et active-defrag-cycle. Quand l'incident se reproduit, LATENCY LATEST et LATENCY DOCTOR vous indiquent lequel. Un LATENCY LATEST qui désigne fork plutôt que command est la lecture la plus utile de cet article, car elle signifie que le problème vient de la persistance, pas de vos requêtes.
3. Pourquoi Redis se fige-t-il pendant les sauvegardes ?
Problème. Des pics de latence réguliers, rythmés, souvent corrélés à une fenêtre de sauvegarde.
INFO persistence # rdb_bgsave_in_progress, latest_fork_usec, rdb_last_bgsave_status
LATENCY HISTORY forkRedis réalise ses snapshots en forkant un processus enfant. C'est ce fork qui fige le serveur : fork(2) doit copier les tables de pages du processus, et la documentation Redis est explicite : cela « peut prendre du temps si le jeu de données est volumineux, et peut empêcher Redis de servir les clients pendant quelques millisecondes, voire pendant une seconde si le jeu de données est très volumineux et que les performances du CPU ne sont pas excellentes ». latest_fork_usec donne la durée du dernier fork. Si vous y lisez des centaines de milliers de microsecondes, vous tenez votre latence.
Correctif, par ordre de fréquence : déplacez les snapshots vers un réplica pour que le fork ait lieu sur un nœud que personne n'interroge ; vérifiez l'hôte, car le coût du fork dépend surtout de la taille des tables de pages et de l'hyperviseur ; ou supprimez complètement RDB sur une instance dont les données peuvent être reconstruites. La persistance répond à davantage de tickets de dépannage Redis que l'optimisation des requêtes.
Le fork a aussi une conséquence mémoire qui tue purement et simplement des instances. Le copy-on-write duplique chaque page modifiée pendant la sauvegarde : sous charge d'écriture, la mémoire du processus grimpe vers le double du jeu de données. Nous avons enquêté sur des crashs répétés sur le cluster d'un client dont l'utilisation affichée n'a jamais dépassé environ 60 % : le fork expliquait tout, et le correctif a consisté à régler l'overcommit mémoire du noyau, pas un paramètre Redis. Le même mécanisme est à l'origine des pannes décrites dans la haute disponibilité Redis.
Obtenez de l'aide sur la latence et les crashs Redis
Vous constatez une latence ou des crashs Redis que vos métriques n'expliquent pas ? La cause se situe généralement sous Redis : dans le comportement du fork, la fragmentation de l'allocateur ou l'hyperviseur, là où le dépannage Redis cesse d'être un exercice Redis. AceMQ mène des audits structurés qui les débusquent et fournit un support Redis entreprise pour les parcs de production. Parlez à un ingénieur AceMQ.
4. Pourquoi des clés disparaissent-elles avant leur TTL ?
Problème. Des clés disparaissent trop tôt, et l'application commence à accumuler du code défensif autour de ce qu'elle prend pour un bug d'intégrité des données.
INFO stats # evicted_keys, expired_keys, keyspace_hits, keyspace_missesUn evicted_keys qui grimpe signifie que l'instance est à sa limite et récupère de l'espace selon la politique configurée. Un expired_keys qui grimpe correspond au comportement normal des TTL : ce n'est pas la même chose.
Correctif. Des évictions en hausse signifient que l'instance est sous-dimensionnée, que la politique ne convient pas au schéma d'accès, ou qu'une politique volatile-* est appliquée à un espace de clés où aucune clé n'a de TTL : elle n'a alors aucune candidate à l'éviction et se comporte comme noeviction, alors que votre configuration dit le contraire.
Avant d'ajuster : redis-cli --hotkeys identifie les clés les plus sollicitées, mais ne fonctionne que si maxmemory-policy est une politique *-lfu, car il lit les compteurs LFU. Sur une instance en LRU, il ne vous donnera pas ce que vous cherchez.
5. Pourquoi mon réplica prend-il du retard ou se resynchronise-t-il ?
Problème. Les réplicas prennent du retard, puis effectuent une resynchronisation complète, qui fait forker le primaire et provoque un pic de latence au pire moment. Exécutez sur les deux nœuds :
INFO replication # role, master_link_status, master_repl_offset, connected_slavesComparez l'offset du réplica à master_repl_offset sur le primaire, et vérifiez que master_link_status vaut up.
Correctif. Les réplicas Redis se reconnectent et tentent une resynchronisation partielle, en rejouant uniquement le flux manqué, mais seulement tant que ces données se trouvent encore dans le backlog de réplication du primaire. Épuisez ce backlog par une longue déconnexion ou un réplica incapable de suivre, et Redis se rabat sur une resynchronisation complète : sauvegarde en arrière-plan, transfert de tout le jeu de données, rechargement.
Le levier, c'est donc le backlog. Dimensionnez repl-backlog-size pour la pire déconnexion à laquelle vous voulez survivre, pas pour la déconnexion moyenne. Sur un lien WAN ou inter-AZ, la valeur par défaut est souvent dix fois trop petite, et le symptôme est une tempête de resynchronisations qui ressemble à une panne réseau.
Deux détails piègent les équipes. Les réplicas ignorent maxmemory par défaut : c'est le primaire qui pilote l'éviction via des DEL répliqués, si bien qu'un réplica peut dépasser la limite du primaire et se retrouver réellement à court de mémoire. Et un réplica arrêté avec SHUTDOWN peut se resynchroniser partiellement ; un réplica tué, non.
6. Pourquoi les clients obtiennent-ils des erreurs de connexion ?
Problème. ERR max number of clients reached, ou des timeouts de connexion, face à un serveur apparemment en bonne santé.
INFO clients # connected_clients, blocked_clients
CONFIG GET maxclients # read it — do not assume the default
CLIENT LIST # per-connection age, idle time, last commandNe vous fiez pas à une valeur par défaut de maxclients retenue de mémoire. Redis l'abaisse au démarrage si la limite de descripteurs de fichiers du système d'exploitation ne permet pas d'atteindre la valeur configurée : sur un déploiement conteneurisé, la valeur effective est souvent bien inférieure à celle du fichier de configuration.
Correctif. CLIENT LIST distingue deux profils. Des milliers de connexions avec un age faible et un idle élevé signifient que l'application ouvre une connexion par requête et a besoin d'un pool : c'est un correctif applicatif, pas un correctif Redis. Quelques connexions avec un age énorme, dont une bloquée, signifient que quelque chose retient une connexion via BLPOP ou équivalent sans jamais la libérer.
Si Redis se trouve devant une charge de type file d'attente et que vous constatez un renouvellement intensif des connexions sous charge, la vraie question est de savoir si Redis a sa place sur ce chemin. Nous abordons ce compromis dans utiliser Redis et RabbitMQ ensemble.
7. Pourquoi mon Redis Cluster tombe-t-il après un resharding ?
Problème. CLUSTERDOWN Hash slot not served, ou des clients qui rebondissent entre des redirections MOVED et ASK après une migration de slots.
CLUSTER INFO # cluster_state, cluster_slots_assigned
CLUSTER SHARDS # slot ranges per shard
redis-cli --cluster check <host>:<port>cluster_state:ok exige que chacun des 16 384 hash slots soit assigné. Un resharding interrompu laisse des slots en cours de migration ou d'import, et le cluster refuse de servir plutôt que de servir de façon incohérente.
Correctif. Laissez --cluster check lister les slots ouverts avant de toucher à quoi que ce soit, et utilisez redis-cli --cluster fix pour terminer la migration plutôt que d'assigner les slots à la main. Un CLUSTER SETSLOT manuel sur un cluster que vous ne maîtrisez pas entièrement, c'est ainsi qu'un resharding bloqué se transforme en perte de données.
Vérifiez aussi que les clients utilisent le mode cluster (-c dans redis-cli). Un client non cluster fonctionne très bien avec un nœud du cluster jusqu'à ce que le premier resharding déplace un slot, puis échoue précisément sur les clés déplacées : un cas de dépannage Redis qui ressemble à une perte de données sans en être une.
8. Pourquoi l'application expire-t-elle alors que Redis est rapide ?
Parce que le timeout ne vient pas de Redis. Mesurez les deux moitiés séparément :
redis-cli --latency # round-trip PING latency
redis-cli --intrinsic-latency 5 # host scheduler latency — run ON the Redis server--intrinsic-latency ne sollicite pas Redis. Il mesure ce dont le noyau et l'hyperviseur sont capables, et doit s'exécuter sur la machine qui héberge Redis. Si la latence intrinsèque se compte déjà en millisecondes, aucun réglage de Redis ne vous fera descendre en dessous : le problème vient de l'hôte, et sur un déploiement virtualisé, cela signifie en général du CPU steal.
Si la latence aller-retour est inférieure à la milliseconde et que l'application expire quand même, l'attente se situe côté client : pool épuisé, appel synchrone dans une boucle d'événements, ou timeout client inférieur à la durée réelle de la commande.
Quand escalader un cas de dépannage Redis
L'essentiel du dépannage Redis se fait en interne : réglage de l'éviction, chasse aux commandes lentes, pooling des connexions, dimensionnement du backlog, planification des snapshots.
Escaladez quand une mauvaise manœuvre coûte plus cher qu'un second avis :
- Des crashs répétés que rien dans
INFOni dans les journaux n'explique - Un cluster avec des slots non assignés après un resharding raté
- Des réplicas qui n'arrivent pas à terminer une synchronisation, quel que soit le nombre de tentatives
- Une mémoire qui continue de croître après
FLUSHALL: un problème de buffer ou d'allocateur, pas d'espace de clés - Tout incident où vous vous apprêtez à forcer un changement d'état sans savoir quel nœud détient les données qui font foi
Ces cas ont un point commun : l'étape suivante évidente détruit les preuves. AceMQ fournit un support Redis entreprise pour les parcs de production : réponse aux incidents, audits de clusters, analyses forensiques de la mémoire et de la latence, et planification des mises à niveau pour Redis open source, Redis Enterprise et les services cloud managés.
Ce qui se passe une fois l'escalade lancée est décrit dans la réponse aux incidents Redis 24/7, et ce qu'une escalade couvre contractuellement dans ce que couvre réellement le support Redis.
Deux analyses approfondies des causes derrière la plupart de ces cas : bien dimensionner la mémoire Redis et utiliser Redis comme file d'attente de messages.
Cet article est la sixième des sept étapes du guide de fiabilité Redis, qui traite les problèmes dans l'ordre où ils surviennent sur un parc de production.
FAQ
Par où commencer le dépannage de Redis ?
Le dépannage de Redis commence par INFO, puis INFO memory et SLOWLOG GET 25. Ces trois commandes indiquent si l'instance manque de mémoire, si elle évince des clés et si une commande a bloqué la boucle d'événements. La plupart des incidents se résolvent à ce stade.
Pourquoi Redis renvoie-t-il « OOM command not allowed » ?
La limite maxmemory est atteinte et maxmemory-policy vaut noeviction : Redis rejette donc les écritures plutôt que de supprimer des données. Les lectures continuent de fonctionner, d'où l'impression d'une application à moitié vivante. Vérifiez avec CONFIG GET maxmemory et CONFIG GET maxmemory-policy.
Pourquoi Redis est-il lent alors que le CPU et la mémoire semblent normaux ?
Presque toujours à cause d'une commande O(N) qui monopolise la boucle de commandes monothread. KEYS *, SMEMBERS sur un grand set, HGETALL sur un hash énorme et un LRANGE non borné bloquent tous les autres clients jusqu'à leur fin. SLOWLOG GET désigne le coupable.
Pourquoi LATENCY DOCTOR ne renvoie-t-il rien ?
Parce que la supervision de la latence est désactivée par défaut : latency-monitor-threshold vaut 0. Exécutez d'abord CONFIG SET latency-monitor-threshold 100, attendez que le problème se reproduise, puis lancez LATENCY DOCTOR. C'est l'impasse la plus fréquente du dépannage Redis.
Comment trouver sans risque les grosses clés dans Redis ?
redis-cli --bigkeys pour le nombre d'éléments et redis-cli --memkeys pour la taille en octets. Les deux utilisent SCAN et non KEYS : ils sont donc sans danger sur une instance de production chargée. Ajoutez -i 0.01 pour ralentir encore le parcours.
Comment vérifier le retard de réplication Redis ?
Avec INFO replication sur les deux nœuds. Comparez master_repl_offset sur le primaire à l'offset du réplica, et vérifiez que master_link_status vaut up. Un réplica qui prend assez de retard pour épuiser le backlog de réplication déclenche une resynchronisation complète, qui fait forker le primaire.
Pourquoi les clients obtiennent-ils des erreurs de connexion alors que Redis tourne ?
Soit la limite de clients est atteinte (INFO clients comparé à CONFIG GET maxclients), soit les connexions fuient parce que l'application ouvre un client par requête au lieu d'utiliser un pool. CLIENT LIST affiche l'âge, le temps d'inactivité et la dernière commande de chaque connexion.
Quand escalader plutôt que redémarrer ?
Quand un redémarrage détruirait les preuves : crashs répétés sans cause visible dans les métriques, cluster avec des slots non assignés, réplicas qui refusent de se synchroniser ou perte de données inexpliquée. Redémarrer d'abord, c'est ainsi qu'un incident récupérable devient définitif.
Le dépannage Redis est avant tout une affaire de discipline : confirmez la panne par une commande avant de modifier quoi que ce soit, et ne changez qu'une chose à la fois.
Sources
Parler à un ingénieur
Besoin d’un coup de main sur Redis ?
Des ingénieurs seniors qui l’exploitent en production. Demandez un devis ou une consultation gratuite, sans argumentaire commercial.
Guides, comparatifs et études

