Redis

Porque é que o meu cliente Redis dá timeout quando o servidor parece estar bem?

Scott Sternloff

Por Scott Sternloff, Arquiteto empresarial sénior

LinkedIn · Atualizado a

CLIENTappSERVERhealthy10s TIMEOUTClient Timeout, Server Fine
Nesta página

A sua equipa abre o INFO server, o INFO clients, o INFO memory — tudo parece normal. A CPU está baixa. A memória está dentro dos limites. Não há entradas no slow log. E, no entanto, a aplicação continua a lançar exceções de timeout do Redis, e os serviços que dependem do Redis estão a degradar-se ou a falhar.

É um modo de falha realmente comum e realmente confuso, porque o instinto é olhar primeiro para o servidor. Nos casos em que trabalhámos, o problema quase nunca está no servidor.

Onde devo procurar se o Redis dá timeouts mas o servidor está bem?

Em três sítios, por ordem de probabilidade:

  1. A configuração do cliente — em concreto, os valores de timeout, o dimensionamento do pool de ligações e o comportamento de retry.
  2. O caminho de rede — firewalls, load balancers ou dispositivos NAT entre a aplicação e o Redis que descartam silenciosamente as ligações inativas.
  3. Chaves grandes ou comandos bloqueantes — operações que bloqueiam o ciclo de eventos single-threaded do Redis tempo suficiente para provocar timeouts no cliente, mesmo que o servidor nunca "vá abaixo".

Um caso real em produção torna isto concreto: um projeto com um cliente foi definido inteiramente em torno de um timeout de cliente de 10 segundos que provocava perturbações em microsserviços. A investigação confirmou que os erros ocorriam do lado do cliente, e não nos servidores Redis — o servidor não registou nenhum erro nem abrandamento equivalente. A causa raiz exigiu uma análise mais aprofundada dos padrões de esgotamento de recursos do lado do cliente e da aplicação, e não da instância Redis em si.

As minhas ligações caem sempre durante uma janela de manutenção específica — o que se passa?

É um sintoma da camada de rede, e é mais comum do que as equipas esperam em ambientes de rede cloud e empresariais com manutenção agendada das firewalls.

Num dos casos, eventos de manutenção da firewall faziam cair em simultâneo todas as ligações TCP ao cluster Redis, com a própria janela de manutenção a durar três a cinco minutos e a resultar numa falha total da rede que obrigava a reiniciar manualmente as aplicações. Não era de todo um problema do Redis — era infraestrutura no caminho de rede entre a aplicação e o Redis que terminava silenciosamente as ligações estabelecidas durante uma atualização de rotina da firewall.

Como confirmar que é este o seu problema:

  • Verifique se os incidentes de timeout coincidem com um calendário recorrente (noturno, semanal) e não com padrões de carga
  • Pergunte diretamente à equipa de redes se existem janelas de manutenção agendadas de firewalls, load balancers ou gateways NAT
  • Se puder, capture o tráfego durante a janela — um TCP RST limpo ou uma queda silenciosa da ligação sem nenhuma entrada correspondente no registo do servidor Redis confirma que o responsável é a camada de rede, e não o Redis

Que definições do lado do cliente resolvem de facto os timeouts do Redis?

Há duas definições que importam mais, e foram a correção concreta aplicada numa remediação real: TCP keepalive e afinação de retry/timeout ao nível do cliente.

TCP keepalive. Sem o keepalive ativo, as ligações inativas atrás de uma firewall ou de um dispositivo NAT são candidatas privilegiadas a uma terminação silenciosa — a stack TCP do sistema operativo não sabe que a ligação caiu até tentar usá-la, e nesse momento obtém um timeout em vez de uma religação limpa. Ativar o TCP keepalive com um intervalo razoavelmente agressivo (bem abaixo do timeout de ligações inativas da firewall/NAT) mantém a ligação viva através de pacotes periódicos sem conteúdo, ou falha depressa o suficiente para que o pool de ligações recicle a ligação morta antes de a aplicação a tentar usar.

Configuração de retry e timeout na biblioteca cliente. Nas aplicações Java que usam o cliente Redis Lettuce (comum com o Spring Data Redis), isto significa configurar explicitamente:

  • O timeout dos comandos (quanto tempo esperar por uma resposta do Redis antes de desistir)
  • As opções de keepalive ao nível do socket na biblioteca cliente, e não apenas ao nível do sistema operativo
  • A política de retry para falhas de ligação transitórias, distinguindo entre "connection refused" (falhar depressa) e "connection reset" (seguro tentar de novo)

Um projeto de remediação em produção produziu especificamente um relatório de síntese com as definições de TCP keepalive e de retry recomendadas para o servidor e para o cliente, seguido de orientações diretas de afinação da configuração do cluster Redis do cliente e dos parâmetros de timeout e retry do cliente Lettuce.

Podem ser antes as chaves grandes a causar os timeouts?

Sim — e vale a pena excluir esta hipótese mesmo que já tenha encontrado um fator de rede ou do lado do cliente, porque as chaves grandes podem agravar o problema.

O Redis é single-threaded na execução de comandos. Um comando que opera sobre uma chave muito grande (um hash enorme, um sorted set gigante, uma string grande) pode bloquear o ciclo de eventos tempo suficiente para que os comandos de outros clientes fiquem em fila e acabem por dar timeout, mesmo que o servidor "pareça" saudável nas métricas agregadas de CPU e memória.

A investigação deste padrão explorou especificamente técnicas de compressão para chaves Redis grandes como possível otimização de desempenho, a par das correções na camada de rede — porque, em implementações reais, a causa raiz de um timeout raramente é um fator único, e sim uma combinação de uma fiabilidade de rede marginal com operações ocasionais sobre chaves grandes que empurram a latência para lá do limiar de timeout do cliente.

Como verificar: execute redis-cli --bigkeys durante um período de tráfego representativo, ou use MEMORY USAGE <key> nas chaves suspeitas. Se encontrar chaves com vários megabytes acedidas com comandos como HGETALL, SMEMBERS ou LRANGE sem limites, tem um possível fator contribuinte.

Qual é a forma sistemática de diagnosticar isto, em vez de adivinhar?

Siga esta ordem:

  1. Confirme que o problema está no cliente. Verifique os registos do servidor Redis e a saída do INFO à procura de algo que coincida com a janela do timeout. Se o servidor não mostrar nada, confirmou que o problema está a montante do próprio Redis.
  2. Procure uma correlação com um calendário. Acontece a uma hora específica do dia ou num dia específico da semana? Isso aponta para manutenção da infraestrutura de rede.
  3. Reveja a configuração do cliente. Timeout dos comandos, tamanho do pool de ligações, definições de TCP keepalive — compare-os com a tolerância real do seu caminho de rede a ligações inativas.
  4. Exclua chaves grandes e comandos bloqueantes. Execute --bigkeys e reveja os seus padrões de comandos à procura de operações sobre coleções sem limite.
  5. Recolha evidências ao nível dos pacotes se os passos anteriores não resolverem. Uma captura de tráfego durante uma janela de reprodução mostra-lhe de forma definitiva se a ligação está a ser reposta por um dispositivo de rede ou se está a dar timeout do lado do cliente.

Objetivos de resposta a partir de 15 minutos, consoante o plano. Engenheiros seniores designados.

Contacte-nos

Uma equipa de infraestrutura generalista consegue diagnosticar isto, ou são precisos conhecimentos específicos de Redis?

Beneficia realmente de conhecimentos específicos de Redis, sobretudo porque o sintoma (timeout) parece idêntico quer a causa esteja no Redis, no cliente ou na rede, e as equipas sem experiência operacional aprofundada em Redis começam muitas vezes por afinar a camada errada — normalmente o servidor, por ser o componente com "Redis" no nome.

Os dois casos de produção referidos neste artigo exigiram ambos coordenação entre equipas — equipas de aplicação/DevOps a trabalhar com especialistas em Redis e, no caso da firewall, diretamente com a equipa de redes/segurança — para isolar a camada realmente responsável. É precisamente neste tipo de diagnóstico transversal que uma avaliação estruturada de Redis justifica o seu valor: não parte do princípio de que a resposta é "afinar o Redis" e, em vez disso, segue a falha até ao sítio onde ela realmente está.

Um diagnóstico de dez minutos para timeouts do Redis

Esta é a ordem pela qual executamos os comandos e o que cada resposta confirma ou exclui. Tudo isto se aplica também ao Valkey.

  1. redis-cli --latency a partir do host do cliente e, depois, a partir do host do servidor. Execute --latency-history em ambos durante alguns minutos. Picos apenas no host do cliente indicam o caminho de rede ou a máquina cliente; nada no Redis resolve isso. Picos em ambos indicam que o servidor está a bloquear, por isso continue a percorrer esta lista.
  1. SLOWLOG GET 25 e INFO commandstats. O slowlog mostra os comandos individuais que excederam slowlog-log-slower-than (10 ms por omissão). O commandstats mostra o usec_per_call por tipo de comando, o que apanha um KEYS com uma média de 40 ms mesmo quando nenhuma chamada isolada chegou ao slowlog. Os culpados habituais são KEYS, SMEMBERS sobre um set grande, HGETALL sobre um hash largo, operações de conjuntos do tipo SUNION e scripts Lua com ciclos. Cada um deles bloqueia todos os outros clientes durante toda a sua execução.
  1. INFO clients. Um blocked_clients acima de zero é normal com BLPOP ou streams; caso contrário, há algo à espera de uma chave que nunca chega. Compare client_recent_max_output_buffer com CONFIG GET client-output-buffer-limit: um subscritor ou uma réplica lenta enche o seu buffer, o limite é atingido e o servidor corta a ligação, o que o cliente reporta como um timeout.
  1. INFO persistence. Compare rdb_bgsave_in_progress, aof_rewrite_in_progress e latest_fork_usec com as horas dos seus timeouts. Um fork sobre um conjunto de dados grande pausa a thread principal durante centenas de milissegundos, e o copy-on-write que se segue abranda todas as escritas. Timeouts sempre ao mesmo minuto de cada hora são quase sempre um BGSAVE agendado.
  1. INFO stats. Um salto em evicted_keys significa que atingiu o maxmemory e que o servidor está a gastar o seu tempo a escolher vítimas; um salto em expired_keys significa um precipício de TTL, em que muitas chaves expiram no mesmo segundo. Qualquer um dos dois paralisa o ciclo de eventos. O nosso guia de memória do Redis e a FAQ sobre memória que cresce sem mais chaves explicam as correções.
  1. CLIENT LIST. Conte as ligações por addr e name. Um pool preso no seu limite enquanto os pedidos ficam em fila significa que o "timeout" é tempo passado à espera de uma ligação livre, e não uma resposta lenta. Um qbuf ou omem elevado numa entrada aponta para um único cliente com mau comportamento.
  1. O host. Numa VM, vmstat 1 com a coluna steal diferente de zero significa que o hipervisor está a ficar com a sua CPU. cat /sys/kernel/mm/transparent_hugepage/enabled deve devolver never; o Redis e o Valkey avisam disto no arranque porque o THP aumenta as pausas do fork. Qualquer utilização de swap num host Redis é um achado.
  1. As definições do cliente no fim. Só agora olhe para o tamanho do pool, o timeout do socket e a política de retry. Se começar por aqui, vai aumentar o timeout, esconder o sintoma e estar de volta daqui a um mês.

No nosso trabalho de suporte, o passo 2 encontra a causa mais vezes do que todos os outros juntos, com o passo 4 num claro segundo lugar. As causas de rede são menos comuns do que se pensa, e é por isso que o passo 1 resolve essa questão em dois minutos. Para um runbook mais completo, consulte resolução de problemas do Redis.

Erros de timeout por cliente e o que normalmente significam

  • Jedis. JedisConnectionException: Could not get a resource from the pool é esgotamento do pool: ligações que não são devolvidas (falta de close() ou de try-with-resources), ou um maxTotal demasiado baixo para o número de threads. JedisConnectionException a envolver SocketTimeoutException: Read timed out é um timeout de leitura, muitas vezes o valor por omissão de 2000 ms atingido por um único comando lento do passo 2.
  • Lettuce. RedisCommandTimeoutException: Command timed out after 1 minute(s) é o valor por omissão de 60 segundos, e é por isso que os pedidos do Lettuce ficam pendurados em vez de falharem depressa. O Lettuce multiplexa os comandos numa única ligação, pelo que um único comando lento retém a fila para todos os que estão atrás dele. Durante uma religação, os comandos ficam em fila na memória e depois dão timeout todos de uma vez.
  • StackExchange.Redis. RedisTimeoutException: Timeout performing GET (5000ms), inst: 0, qu: 0, qs: 12, aw: False, in: 65536, ... lê-se assim: qs são os comandos enviados à espera de resposta, qu são os comandos ainda não escritos, in são os bytes já recebidos mas ainda não processados e mgr mostra o estado do gestor de sockets. Um in elevado com um qs elevado significa que a resposta chegou e o cliente não a conseguiu ler, o que é falta de threads no thread pool, normalmente por bloquear com .Result ou .Wait() no código de pedidos web. Verifique a linha WORKER na mesma mensagem: busy acima de min é a confirmação.
  • node-redis e ioredis. Ambos separam o timeout de ligação do comportamento dos comandos. O ioredis tem connectTimeout, commandTimeout e maxRetriesPerRequest (20 por omissão), por isso MaxRetriesPerRequestError significa que o ciclo de religação desistiu, e não que o Redis estava lento. Uma retryStrategy que devolve indefinidamente um atraso curto produz uma avalanche de registos e nunca faz aparecer o erro real. O node-redis usa reconnectStrategy e, nas versões mais antigas, não tem timeout por comando, pelo que um servidor parado produz promises pendentes em vez de erros.
  • redis-py. socket_connect_timeout limita o handshake TCP; socket_timeout limita cada leitura e, por omissão, não tem valor, pelo que uma chamada parada espera para sempre. TimeoutError: Timeout reading from socket corresponde a este último. health_check_interval envia um PING antes de reutilizar uma ligação inativa, o que resolve ConnectionError: Connection closed by server depois de uma firewall descartar sockets inativos.
  • Clientes Go. context deadline exceeded é o contexto de quem faz a chamada, e não o timeout do próprio cliente, por isso verifique ambos. redis: connection pool timeout significa que há mais goroutines do que PoolSize e que esperaram mais do que PoolTimeout por uma ligação livre; aumente o pool ou encontre a fuga de goroutines.

Se preferir entregar isto a quem o faz todos os dias, a nossa equipa de suporte Redis está de serviço 24/7 com objetivos de resposta a partir de 15 minutos, consoante o plano, e a consultoria Redis corrige o desenho subjacente.

Obtenha ajuda com timeouts de clientes Redis e problemas de ligação

Tem timeouts do Redis que não coincidem com nada visível nas métricas do servidor? É exatamente o tipo de problema em camadas — cliente, rede ou servidor — que uma avaliação estruturada de Redis foi pensada para isolar, em vez de adivinhar. A AceMQ presta suporte Redis empresarial para ambientes em produção. Fale com um engenheiro da AceMQ.

Este é o quarto de sete passos do guia de fiabilidade do Redis, que aborda os problemas pela ordem em que surgem num ambiente em produção.

Perguntas frequentes

Onde devo procurar se o Redis dá timeouts mas as métricas do servidor parecem normais?

Em três sítios, por ordem de probabilidade: a configuração do cliente (valores de timeout, dimensionamento do pool de ligações, comportamento de retry), o caminho de rede (firewalls, load balancers ou dispositivos NAT que descartam silenciosamente as ligações inativas) e chaves grandes ou comandos bloqueantes que paralisam o ciclo de eventos single-threaded. Num caso real em produção, um timeout de 10 segundos no cliente foi atribuído na totalidade ao esgotamento de recursos do lado do cliente, sem qualquer erro ou abrandamento correspondente do lado do servidor.

Porque é que as ligações ao Redis caem durante uma janela de manutenção específica?

É quase sempre um sintoma da camada de rede, e não um problema do Redis. A manutenção agendada de firewalls, load balancers ou gateways NAT pode terminar silenciosamente as ligações TCP estabelecidas com o seu cluster Redis. Confirme-o verificando se os incidentes coincidem com um calendário recorrente e não com a carga, e pergunte diretamente à equipa de redes quais são as janelas de manutenção.

Que definições do lado do cliente resolvem de facto os timeouts do Redis?

O TCP keepalive e a afinação de retry/timeout ao nível do cliente são as duas definições que mais importam. Ativar o TCP keepalive com um intervalo inferior ao timeout de ligações inativas da firewall ou do NAT evita a terminação silenciosa das ligações, e configurar o timeout dos comandos, o keepalive ao nível do socket e a política de retry na biblioteca cliente (como o Lettuce para Java/Spring) fecha o resto da lacuna.

As chaves grandes podem estar a causar timeouts no Redis?

Sim. O Redis é single-threaded na execução de comandos, por isso um comando sobre um hash, um sorted set ou uma string muito grande pode bloquear o ciclo de eventos tempo suficiente para que os comandos de outros clientes fiquem em fila e deem timeout. Execute redis-cli --bigkeys ou MEMORY USAGE <key> para verificar, e esteja atento a HGETALL, SMEMBERS ou LRANGE usados sem limites sobre chaves com vários megabytes.

Qual é a forma sistemática de diagnosticar um timeout de cliente Redis?

Confirme que o problema está no cliente verificando os registos do servidor Redis e a saída do INFO à procura de algo que coincida com a janela do timeout. Depois, procure uma correlação com um calendário, reveja a configuração do cliente face à tolerância a ligações inativas do seu caminho de rede, exclua chaves grandes e comandos bloqueantes e, se o problema persistir, recolha evidências ao nível dos pacotes.

Diagnosticar timeouts do Redis exige conhecimentos específicos de Redis?

Beneficia realmente deles, porque um timeout parece idêntico quer a causa esteja no Redis, no cliente ou na rede, e as equipas sem experiência em Redis tendem a começar por afinar o servidor. Os dois casos de produção referidos neste artigo exigiram coordenação entre as equipas de aplicação, de DevOps e de redes para isolar a camada realmente responsável.

Consulta gratuita

Peça a um especialista que analise a sua implementação Redis

Quer esteja a resolver um incidente em produção, a planear uma migração ou queira uma segunda opinião sobre a sua arquitetura, a nossa equipa está pronta. Sem discursos de vendas, apenas respostas.

Enviar e-mail