Sur cette page
Votre équipe consulte INFO server, INFO clients, INFO memory : tout paraît normal. Le CPU est bas. La mémoire reste dans les limites. Rien dans le slow log. Et pourtant, votre application continue de lever des exceptions de timeout Redis, et les services qui dépendent de Redis se dégradent ou tombent.
C'est un mode de défaillance à la fois très courant et très déroutant, car le réflexe est de regarder d'abord le serveur. Dans les cas que nous avons traités, le problème ne se trouve presque jamais sur le serveur.
Où chercher vraiment quand Redis tombe en timeout alors que le serveur va bien ?
À trois endroits, par ordre de probabilité :
- La configuration du client : plus précisément les valeurs de timeout, le dimensionnement du pool de connexions et le comportement des retries.
- Le chemin réseau : pare-feu, load balancers ou équipements NAT placés entre votre application et Redis, qui coupent silencieusement les connexions inactives.
- Les grosses clés ou les commandes bloquantes : des opérations qui bloquent la boucle d'événements monothread de Redis assez longtemps pour provoquer des timeouts côté client, alors que le serveur ne « tombe » jamais.
Un cas réel en production rend cela concret : une mission client portait entièrement sur un timeout client de 10 secondes qui perturbait des microservices. L'investigation a confirmé que les erreurs se produisaient côté client, et non sur les serveurs Redis : le serveur n'avait enregistré aucune erreur ni aucun ralentissement équivalent. Trouver la cause profonde a exigé une analyse approfondie des schémas d'épuisement des ressources côté client et applicatif, pas de l'instance Redis elle-même.
Mes connexions tombent sans cesse pendant une fenêtre de maintenance précise : que se passe-t-il ?
C'est un symptôme de la couche réseau, et il est plus fréquent que les équipes ne l'imaginent dans les environnements cloud et les réseaux d'entreprise soumis à une maintenance planifiée des pare-feu.
Dans un cas, des opérations de maintenance du pare-feu ont fait tomber simultanément toutes les connexions TCP vers le cluster Redis ; la fenêtre de maintenance elle-même durait trois à cinq minutes et provoquait une coupure réseau complète qui obligeait à redémarrer manuellement les applications. Ce n'était pas du tout un problème Redis : c'était l'infrastructure placée sur le chemin réseau entre l'application et Redis qui coupait silencieusement les connexions établies pendant une mise à niveau de routine du pare-feu.
Comment confirmer que c'est votre problème :
- Vérifiez si vos incidents de timeout suivent un calendrier récurrent (chaque nuit, chaque semaine) plutôt que les variations de charge
- Demandez directement à votre équipe réseau s'il existe des fenêtres de maintenance planifiées pour le pare-feu, le load balancer ou la passerelle NAT
- Capturez le trafic pendant la fenêtre si vous le pouvez : un TCP RST net ou une coupure silencieuse de connexion, sans aucune entrée correspondante dans les logs du serveur Redis, confirme que c'est la couche réseau, et non Redis, qui est en cause
Quels réglages côté client corrigent vraiment les timeouts Redis ?
Deux paramètres comptent plus que tout, et ce sont précisément ceux qui ont été corrigés lors d'une remédiation réelle : le TCP keepalive et le réglage des retries et timeouts au niveau du client.
TCP keepalive. Sans keepalive, les connexions inactives situées derrière un pare-feu ou un équipement NAT sont les candidates idéales à une coupure silencieuse : la pile TCP de l'OS ne sait pas que la connexion a été coupée tant qu'elle n'essaie pas de l'utiliser, et à ce moment-là vous obtenez un timeout au lieu d'une reconnexion propre. Activer le TCP keepalive à un intervalle assez agressif (nettement inférieur au délai d'inactivité de votre pare-feu ou de votre NAT) maintient la connexion en vie grâce à des paquets périodiques sans effet, ou la fait échouer assez vite pour que votre pool de connexions recycle la connexion morte avant que votre application ne tente de l'utiliser.
Configuration des retries et des timeouts de la bibliothèque cliente. Pour les applications Java qui utilisent le client Redis Lettuce (courant avec Spring Data Redis), cela signifie configurer explicitement :
- Le timeout de commande (combien de temps attendre une réponse de Redis avant d'abandonner)
- Les options de keepalive au niveau du socket dans la bibliothèque cliente, pas seulement au niveau de l'OS
- La politique de retry pour les échecs de connexion transitoires, en distinguant « connection refused » (échouer vite) de « connection reset » (retry sans risque)
Une mission de remédiation en production a ainsi produit un rapport de synthèse recommandant des réglages de TCP keepalive et de retry côté serveur comme côté client, suivi de recommandations concrètes de configuration pour le cluster Redis du client et pour les paramètres de timeout et de retry du client Lettuce.
Et si c'étaient plutôt les grosses clés qui provoquaient les timeouts ?
Oui, et cela vaut la peine de l'écarter même si vous avez déjà trouvé un facteur réseau ou côté client, car les grosses clés peuvent aggraver le problème.
Redis exécute les commandes sur un seul thread. Une commande qui opère sur une très grosse clé (un hash énorme, un sorted set gigantesque, une longue chaîne) peut bloquer la boucle d'événements assez longtemps pour que les commandes des autres clients s'accumulent et finissent par tomber en timeout, alors même que le serveur « semble » sain au vu des métriques agrégées de CPU et de mémoire.
L'investigation menée sur ce schéma a précisément exploré des techniques de compression pour les grosses clés Redis comme piste d'optimisation des performances, en plus des corrections de la couche réseau : dans les déploiements réels, la cause profonde des timeouts n'est souvent pas un facteur unique, mais la combinaison d'une fiabilité réseau limite et d'opérations ponctuelles sur de grosses clés qui font passer la latence au-dessus du seuil de timeout du client.
Comment vérifier : lancez redis-cli --bigkeys pendant une période de trafic représentative, ou utilisez MEMORY USAGE <key> sur les grosses clés suspectes. Si vous trouvez des clés de plusieurs mégaoctets lues avec des commandes comme HGETALL, SMEMBERS ou LRANGE sans limite, vous tenez un facteur probable.
Quelle est la méthode systématique pour diagnostiquer, plutôt que de deviner ?
Procédez dans cet ordre :
- Confirmez que le problème est côté client. Cherchez dans les logs du serveur Redis et dans la sortie
INFOtout ce qui coïncide avec la fenêtre du timeout. Si le serveur ne montre rien, vous avez confirmé que le problème se situe en amont de Redis lui-même. - Cherchez une corrélation avec un calendrier. Le problème survient-il à une heure précise de la journée ou un jour précis de la semaine ? Cela désigne une maintenance de l'infrastructure réseau.
- Passez en revue la configuration du client. Timeout de commande, taille du pool de connexions, réglages de TCP keepalive : comparez-les à la tolérance aux connexions inactives de votre chemin réseau réel.
- Écartez les grosses clés et les commandes bloquantes. Lancez
--bigkeyset examinez vos schémas de commandes à la recherche de tout ce qui opère sur des collections non bornées. - Capturez des preuves au niveau des paquets si les étapes précédentes ne suffisent pas. Une capture de trafic pendant une fenêtre de reproduction vous montrera de façon définitive si la connexion est réinitialisée par un équipement réseau ou si elle expire côté client.
Une équipe d'infrastructure généraliste peut-elle diagnostiquer ce problème, ou faut-il une expertise Redis spécifique ?
Une expertise Redis spécifique est un vrai plus, principalement parce que le symptôme (le timeout) a exactement la même apparence que sa cause soit côté Redis, côté client ou côté réseau, et que les équipes sans solide expérience de l'exploitation de Redis commencent souvent par régler la mauvaise couche : généralement le serveur, puisque c'est le composant qui porte le nom « Redis ».
Les deux cas de production cités dans cet article ont tous deux exigé une coordination entre équipes (les équipes applicatives et DevOps aux côtés d'experts Redis et, dans le cas du pare-feu, directement l'équipe réseau et sécurité) pour isoler la couche réellement responsable. C'est précisément dans ce type de diagnostic transverse qu'une évaluation Redis structurée prend toute sa valeur : elle ne part pas du principe que la réponse est « régler Redis », mais remonte la défaillance jusqu'à l'endroit où elle se trouve réellement.
Un diagnostic des timeouts Redis en dix minutes
Voici l'ordre dans lequel nous lançons les commandes, et ce que chaque réponse confirme ou écarte. Tout cela s'applique aussi à Valkey.
redis-cli --latencydepuis l'hôte client, puis depuis l'hôte serveur. Lancez--latency-historysur les deux pendant quelques minutes. Des pics uniquement sur l'hôte client désignent le chemin réseau ou la machine cliente ; rien dans Redis n'y changera quoi que ce soit. Des pics sur les deux signifient que le serveur se bloque : continuez la liste.
SLOWLOG GET 25etINFO commandstats. Le slowlog montre les commandes individuelles qui ont dépasséslowlog-log-slower-than(10 ms par défaut). Commandstats indiqueusec_per_callpar type de commande, ce qui permet de repérer unKEYSà 40 ms en moyenne même quand aucun appel isolé n'a atteint le slowlog. Les coupables habituels sontKEYS,SMEMBERSsur un grand ensemble,HGETALLsur un hash très large, les opérations ensemblistes du typeSUNIONet les scripts Lua qui bouclent. Chacun bloque tous les autres clients pendant toute sa durée.
INFO clients. Unblocked_clientssupérieur à zéro est normal avecBLPOPou les streams ; sinon, quelque chose attend une clé qui n'arrive jamais. Comparezclient_recent_max_output_bufferàCONFIG GET client-output-buffer-limit: un abonné ou un réplica lent remplit son buffer, la limite se déclenche et le serveur coupe la connexion, ce que le client signale comme un timeout.
INFO persistence. Comparezrdb_bgsave_in_progress,aof_rewrite_in_progressetlatest_fork_usecaux horodatages de vos timeouts. Un fork sur un gros jeu de données met en pause le thread principal pendant des centaines de millisecondes, et le copy-on-write qui suit ralentit chaque écriture. Des timeouts à la même minute de chaque heure correspondent presque toujours à unBGSAVEplanifié.
INFO stats. Un bond deevicted_keyssignifie que vous avez atteintmaxmemoryet que le serveur passe son temps à choisir des victimes ; un bond deexpired_keyssignale une falaise de TTL où de nombreuses clés expirent dans la même seconde. Dans les deux cas, la boucle d'événements se bloque. Notre guide sur la mémoire Redis et la FAQ sur la mémoire qui augmente sans hausse du nombre de clés présentent les correctifs.
CLIENT LIST. Comptez les connexions paraddret parname. Un pool bloqué à son plafond pendant que les requêtes s'accumulent signifie que le « timeout » est du temps passé à attendre une connexion libre, pas une réponse lente. Unqbufou unomemélevé sur une entrée désigne un seul client défaillant.
- L'hôte. Sur une VM, un
vmstat 1dont la colonne steal n'est pas nulle signifie que l'hyperviseur vous prend du CPU.cat /sys/kernel/mm/transparent_hugepage/enableddoit renvoyernever; Redis et Valkey le signalent au démarrage, car THP allonge les pauses de fork. Toute utilisation du swap sur un hôte Redis est un constat à part entière.
- Les réglages du client en dernier. C'est seulement maintenant qu'il faut regarder la taille du pool, le timeout de socket et la politique de retry. Commencez par là et vous augmenterez le timeout, masquerez le symptôme et reviendrez dans un mois.
Dans nos missions de support, l'étape 2 trouve la cause plus souvent que toutes les autres réunies, suivie de loin par l'étape 4. Les causes réseau sont moins fréquentes qu'on ne le pense, c'est pourquoi l'étape 1 tranche la question en deux minutes. Pour un runbook plus complet, consultez le dépannage de Redis.
Les erreurs de timeout propres à chaque client et ce qu'elles signifient généralement
- Jedis.
JedisConnectionException: Could not get a resource from the poolsignale un épuisement du pool : des connexions non rendues (close()ou try-with-resources manquant), ou unmaxTotaltrop bas pour le nombre de threads. UneJedisConnectionExceptionqui encapsuleSocketTimeoutException: Read timed outest un timeout de lecture, souvent la valeur par défaut de 2 000 ms atteinte par une seule commande lente de l'étape 2. - Lettuce.
RedisCommandTimeoutException: Command timed out after 1 minute(s)correspond à la valeur par défaut de 60 secondes, ce qui explique que les requêtes Lettuce restent suspendues au lieu d'échouer vite. Lettuce multiplexe les commandes sur une seule connexion : une seule commande lente bloque la file pour toutes celles qui la suivent. Pendant une reconnexion, les commandes s'accumulent en mémoire puis expirent en rafale. - StackExchange.Redis.
RedisTimeoutException: Timeout performing GET (5000ms), inst: 0, qu: 0, qs: 12, aw: False, in: 65536, ...se lit ainsi :qscorrespond aux commandes envoyées en attente de réponse,quaux commandes pas encore écrites,inaux octets déjà reçus mais pas encore traités, etmgrindique l'état du gestionnaire de sockets. Uninélevé avec unqsélevé signifie que la réponse est arrivée mais que le client n'a pas pu la lire : c'est une famine du pool de threads, généralement due à un blocage sur.Resultou.Wait()dans le code de traitement des requêtes web. Regardez la ligneWORKERdu même message : un nombre de threads occupés supérieur au minimum en est la confirmation. - node-redis et ioredis. Les deux séparent le timeout de connexion du comportement des commandes. ioredis dispose de
connectTimeout,commandTimeoutetmaxRetriesPerRequest(20 par défaut) :MaxRetriesPerRequestErrorsignifie donc que la boucle de reconnexion a abandonné, pas que Redis était lent. UneretryStrategyqui renvoie indéfiniment un délai court inonde les logs et ne fait jamais remonter la véritable erreur. node-redis utilisereconnectStrategyet, dans ses anciennes versions, n'a pas de timeout par commande : un serveur bloqué produit alors des promesses suspendues plutôt que des erreurs. - redis-py.
socket_connect_timeoutborne la poignée de main TCP ;socket_timeoutborne chaque lecture et n'a pas de valeur par défaut, si bien qu'un appel bloqué attend indéfiniment.TimeoutError: Timeout reading from socketcorrespond à ce second cas.health_check_intervalenvoie unPINGavant de réutiliser une connexion inactive, ce qui corrigeConnectionError: Connection closed by serveraprès qu'un pare-feu a coupé des sockets inactifs. - Clients Go.
context deadline exceededprovient du contexte de l'appelant, pas du timeout propre au client : vérifiez donc les deux.redis: connection pool timeoutsignifie que les goroutines sont plus nombreuses quePoolSizeet ont attendu une connexion libre au-delà dePoolTimeout; agrandissez le pool ou trouvez la fuite de goroutines.
Si vous préférez confier ce travail à des gens qui le font tous les jours, notre équipe de support Redis est d'astreinte 24/7 avec des objectifs de réponse à partir de 15 minutes, selon le plan, et notre conseil Redis corrige la conception sous-jacente.
Faites-vous aider sur les timeouts clients et les problèmes de connexion Redis
Vous subissez des timeouts Redis qui ne correspondent à rien de visible dans les métriques du serveur Redis ? C'est exactement le type de problème à plusieurs couches (client, réseau ou serveur) qu'une évaluation Redis structurée est conçue pour isoler plutôt que de deviner. AceMQ fournit un support Redis entreprise pour les parcs en production. Parlez à un ingénieur AceMQ.
Cet article est la quatrième des sept étapes du guide de fiabilité Redis, qui traite les problèmes dans l'ordre où ils surviennent sur un parc en production.
Questions fréquentes
Où chercher quand Redis tombe en timeout alors que les métriques serveur semblent saines ?
À trois endroits, par ordre de probabilité : la configuration du client (valeurs de timeout, dimensionnement du pool de connexions, comportement des retries), le chemin réseau (pare-feu, load balancers ou équipements NAT qui coupent silencieusement les connexions inactives), et les grosses clés ou commandes bloquantes qui figent la boucle d'événements monothread. Dans un cas réel en production, un timeout client de 10 secondes a été entièrement attribué à un épuisement des ressources côté client, sans aucune erreur ni ralentissement correspondant côté serveur.
Pourquoi mes connexions Redis tombent-elles pendant une fenêtre de maintenance précise ?
C'est presque toujours un symptôme de la couche réseau, pas un problème Redis. Une maintenance planifiée du pare-feu, du load balancer ou de la passerelle NAT peut couper silencieusement les connexions TCP établies vers votre cluster Redis. Pour le confirmer, vérifiez si les incidents suivent un calendrier récurrent plutôt que la charge, et interrogez directement votre équipe réseau sur les fenêtres de maintenance.
Quels réglages côté client corrigent vraiment les timeouts Redis ?
Le TCP keepalive et le réglage des retries et timeouts au niveau du client sont les deux paramètres qui comptent le plus. Activer le TCP keepalive à un intervalle inférieur au délai d'inactivité de votre pare-feu ou de votre NAT empêche les coupures silencieuses de connexion, et configurer le timeout de commande, le keepalive au niveau du socket et la politique de retry dans la bibliothèque cliente (par exemple Lettuce pour Java/Spring) comble le reste de l'écart.
Les grosses clés peuvent-elles provoquer des timeouts Redis ?
Oui. Redis exécute les commandes sur un seul thread : une commande sur un très gros hash, un très gros sorted set ou une très longue chaîne peut bloquer la boucle d'événements assez longtemps pour que les commandes des autres clients s'accumulent et tombent en timeout. Lancez redis-cli --bigkeys ou MEMORY USAGE <key> pour vérifier, et surveillez les HGETALL, SMEMBERS ou LRANGE utilisés sans limite sur des clés de plusieurs mégaoctets.
Quelle est la méthode systématique pour diagnostiquer un timeout client Redis ?
Confirmez que le problème est côté client en cherchant dans les logs du serveur Redis et la sortie INFO tout ce qui coïncide avec la fenêtre du timeout. Vérifiez ensuite s'il existe une corrélation avec un calendrier, comparez la configuration du client à la tolérance aux connexions inactives de votre chemin réseau, écartez les grosses clés et les commandes bloquantes, et capturez des preuves au niveau des paquets si le problème persiste.
Faut-il une expertise Redis spécifique pour diagnostiquer les timeouts Redis ?
C'est un vrai plus, car un timeout a exactement la même apparence que sa cause soit côté Redis, côté client ou côté réseau, et les équipes sans expérience de Redis commencent souvent par régler le serveur. Les deux cas de production cités dans cet article ont exigé une coordination entre les équipes applicatives, DevOps et réseau pour isoler la couche réellement responsable.