Pablo Monteiro

Engenharia de software, arquitetura e liderança técnica

clouddevopsdotnetgovernançapython

Em junho de 2024 a gente fez uma das maiores mudanças de infraestrutura que eu acompanhei até hoje. A loja virtual rodava em parte no Azure App Service e em parte na AWS, e num fim de semana migramos tudo para Kubernetes na Azure, o mesmo modelo que já usávamos em outra parte da plataforma.

Foram semanas de preparação, roteiro de migração revisado várias vezes, ambiente novo subido em paralelo e um “esquenta” na véspera, em que subimos tudo e testamos de novo pelo ambiente de staging da CDN, só para ter certeza de que não haveria surpresa. Na virada, as aplicações subiram, o tráfego foi direcionado para o ambiente novo e os testes passaram.

Na segunda-feira de manhã saiu o comunicado para a empresa dizendo que a migração tinha sido concluída, com a lista de benefícios do ambiente novo. Todo mundo achou que a migração tinha sido um sucesso, e por um bom motivo, quase tudo funcionou.

Este post é sobre o quase.

Os primeiros dias

Nenhuma migração desse tamanho termina na virada. Nos dias seguintes apareceram as pendências que a gente já esperava encontrar: parceiros chamando domínios antigos que deixaram de existir, requisições barradas com 413 porque o limite de tamanho de header e de payload no ambiente novo era menor do que no antigo, e até um parâmetro de timeout de pipeline que deixou de ser repassado depois da mudança.

Eram problemas chatos, mas com causa clara. Aparecia o erro, alguém olhava a configuração, ajustava e seguia. Foi nesse clima que chegou uma reclamação que não se encaixava em nada disso.

O cliente que achou que estava sendo atacado

Um cliente reclamou de um DDoS na rede dele.

O cliente era uma das indústrias que recebem pedidos pela nossa plataforma. Quando o cliente final monta um pedido, a plataforma consulta o ERP da indústria para saber preço, prazo de entrega e restrições. Do lado dela, o que aparecia era um volume de requisições que não fazia sentido, a mesma consulta chegando várias vezes, com cerca de um minuto de diferença entre uma e outra. Num dos testes, uma única solicitação gerou sete requisições iguais.

Investigamos e não conseguimos identificar. Do nosso lado, o código fazia uma chamada só, os logs da aplicação não mostravam nada estranho e nenhuma mudança de código explicava aquilo. A primeira suspeita foi o front, talvez a tela estivesse disparando a mesma requisição mais de uma vez, e passamos um bom tempo olhando os acessos na CDN tentando achar o padrão. Olhamos traces, olhamos logs, montamos um painel no Kibana só para acompanhar o volume de chamadas para a indústria, e nada fechava.

Até que alguns pedidos começaram a ficar inconsistentes, e eram sempre os pedidos grandes. Foi aí que chegamos na regra do NGINX.

Por que os pedidos grandes

O SAP dessa indústria sempre foi lento para pedidos com muitos itens, e acima de seis itens a resposta passava de um minuto com frequência. Isso era um problema antigo e conhecido, tanto que a aplicação tinha um timeout de quatro minutos configurado só para essa rota. Olhando o código, estava tudo certo.

O que mudou com a migração foi o caminho da requisição. No ambiente novo, o ingress do Kubernetes passou a ficar entre o cliente e a aplicação, e o NGINX tem um proxy_read_timeout padrão de sessenta segundos. Como um colega resumiu durante a investigação, o menor timeout da cadeia é o que vale. Não importa que a aplicação aceite esperar quatro minutos se alguém no meio do caminho desiste em um.

A primeira ação foi aumentar os timeouts do ingress para seis minutos. Os testes com pedidos grandes voltaram a passar, a indústria confirmou que estava recebendo uma requisição só, e o chamado acalmou. Mas isso explicava o erro, não as requisições repetidas.

Elas vinham do proxy_next_upstream, uma diretiva que nenhum de nós tinha configurado. O padrão dela no NGINX é error timeout, ou seja, quando o upstream dá erro ou timeout, o NGINX tenta o próximo. No Kubernetes, os upstreams de um ingress são os pods do serviço, então, quando um pedido grande fazia o primeiro pod passar de sessenta segundos, o NGINX desistia dele e mandava a mesma requisição para o segundo pod, depois para o terceiro, e assim por diante. Para a indústria, cada uma dessas tentativas era uma nova consulta no ERP dela. Para ela, aquilo parecia um ataque.

O que mais me surpreendeu foi justamente isso, o padrão da configuração ser fazer o retry, e não vir desabilitado. A gente revisou com cuidado tudo o que configurou na infraestrutura nova, e o problema estava no que não configuramos.

Provar antes de encerrar

Na época, a causa registrada no chamado foi a lentidão do SAP, e o aumento de timeout entrou como mitigação. Era verdade, mas não era a história toda, e a gente queria entender exatamente o que tinha acontecido antes de dar o assunto por encerrado.

Um colega do time de plataforma montou um laboratório com kind, um cluster Kubernetes local com o mesmo ingress e um servidor que só esperava alguns segundos antes de responder. Em poucos minutos o comportamento estava reproduzido: uma requisição lenta entrava no ingress e aparecia nos logs de todos os pods do serviço.

Isso virou pauta do chapter de backend na mesma semana. Falamos sobre como uma requisição sai do navegador e chega até a aplicação, o que é um ingress controller, como olhar a configuração do NGINX direto no pod e como o retry funciona. Também pedimos para o time de QA incluir nos testes sintéticos os dois casos que exigiam configuração especial no proxy, o timeout maior para as rotas que dependem das indústrias e o payload acima de 1 MB em algumas rotas, para que uma mudança de infraestrutura não voltasse a quebrar esses fluxos sem ninguém perceber.

Um detalhe sobre o GET

[REVISAR: este trecho é um achado do levantamento feito para o post, não algo vivido na época. Decida se entra.]

Quando se fala de retry duplicando requisição, a primeira coisa que vem na cabeça é um POST sendo enviado duas vezes. Mas desde a versão 1.9.13 o NGINX não repete requisições não idempotentes, como POST e PATCH, depois que elas já chegaram ao upstream, a menos que isso seja pedido explicitamente com non_idempotent.

A rota do incidente era um GET. Ela devolvia preço, agenda e restrições do pedido, então fazia sentido ser um GET do ponto de vista da API, só que por baixo cada chamada disparava uma consulta no SAP da indústria. Para o NGINX, repetir um GET não tem efeito colateral, porque é isso que o HTTP promete. Para a indústria, tinha.

Os campos que importam

Depois desse incidente, passei a olhar com mais atenção para um grupo pequeno de diretivas do módulo de proxy do NGINX. São elas que decidem quanto tempo o NGINX espera e o que ele faz quando desiste.

  • proxy_connect_timeout: tempo para estabelecer a conexão com o upstream. O padrão é 60 segundos, e a própria documentação avisa que normalmente ele não passa de 75. Ele só vale para a conexão. Depois que a requisição chegou na aplicação, não tem mais efeito.
  • proxy_read_timeout: tempo de espera pela resposta do upstream, com padrão de 60 segundos. Um detalhe que pouca gente lembra é que ele conta o intervalo entre duas leituras, e não o tempo total da resposta. Uma rota que fica um minuto calada, como o SAP processando um pedido grande, estoura esse timeout.
  • proxy_send_timeout: o mesmo raciocínio para o envio da requisição ao upstream, também com padrão de 60 segundos entre duas escritas.
  • proxy_next_upstream: em quais situações o NGINX tenta o próximo servidor. Aceita valores como error, timeout, invalid_header, http_500, http_502, http_503, http_504, http_429, non_idempotent e off. O padrão é error timeout.
  • proxy_next_upstream_tries: quantas tentativas no total. O padrão do NGINX é 0, que desliga o limite.
  • proxy_next_upstream_timeout: tempo máximo somando todas as tentativas. Também tem padrão 0, sem limite.

No Kubernetes ninguém escreve essas diretivas direto. Elas são geradas pelo ingress controller a partir de anotações no Ingress ou de uma configuração global, e cada controller tem os seus nomes e os seus padrões:

DiretivaNGINXingress-nginx (comunidade)F5 NGINX Ingress Controller
proxy_connect_timeout60s560s
proxy_read_timeout60s6060s
proxy_send_timeout60s6060s
proxy_next_upstreamerror timeouterror timeouterror timeout
proxy_next_upstream_tries0 (sem limite)30 (sem limite)
proxy_next_upstream_timeout0 (sem limite)0 (sem limite)0 (sem limite)

No ingress-nginx da comunidade, as anotações seguem o padrão nginx.ingress.kubernetes.io/proxy-next-upstream, nginx.ingress.kubernetes.io/proxy-read-timeout e assim por diante, os valores são em segundos sem unidade, e os padrões globais ficam no ConfigMap do controller. Ele também tem a chave retry-non-idempotent, desligada por padrão, que é o que impede o retry de POST e PATCH.

No controller da F5, as anotações mudam para nginx.org/proxy-next-upstream, nginx.org/proxy-read-timeout e assim por diante, e os valores levam unidade, como 60s. Os timeouts podem ser definidos de forma global pelo ConfigMap, mas o retry não tem chave no ConfigMap, ele é ajustado por anotação em cada Ingress ou pelos campos next-upstream, next-upstream-tries e next-upstream-timeout do recurso VirtualServer, que é próprio da F5.

[REVISAR: a tabela mostra que o ingress-nginx da comunidade limita o retry a 3 tentativas por padrão, mas na época a indústria recebeu 7 requisições iguais. Ou o limite estava alterado no values do Helm, ou havia outra camada repetindo também. Vale conferir antes de publicar para não deixar essa conta em aberto.]

O NGINX de novo

Às vezes a gente não dá o devido valor para o NGINX. Ele fica ali no meio, funcionando, e só lembramos dele quando algo quebra.

Recentemente o Kubernetes parou de dar suporte ao ingress-nginx, o controller mantido pela comunidade. A aposentadoria foi anunciada em novembro de 2025, a manutenção acabou em março de 2026 e, desde então, não sai mais nenhuma correção, nem de segurança. Passamos a usar o controller da F5. As regras são diferentes, as anotações mudam de nome e de comportamento, e precisamos fazer o de/para de novo, ingress por ingress.

E a tabela acima mostra o tipo de coisa que se perde nesse de/para. A gente traduziu cada anotação que tinha declarada, mas os padrões que ninguém declarou também mudaram. Comparando os padrões de um controller e do outro, o timeout de conexão vai de 5 para 60 segundos e o limite de tentativas do retry vai de 3 para nenhum.

[REVISAR: o parágrafo abaixo vem do levantamento no repositório e no cluster de dev; confirmar em produção antes de publicar.]

Olhando o repositório de manifestos e a configuração que o controller da F5 gera hoje, nenhum Ingress declara nginx.org/proxy-next-upstream. Isso quer dizer que continua valendo o padrão, error timeout, agora sem limite de tentativas. O retry que causou o incidente continua lá, e de certa forma mais solto do que estava em 2024.

[REVISAR: em abril de 2026 um PR adicionou as anotações de retry em outro serviço e foi revertido no dia seguinte, porque alguém lembrou do incidente. Vale contar? Se sim, o que você pensa sobre isso?]

O que eu levo disso

[REVISAR: escreva aqui as suas conclusões. Alguns pontos que surgiram no texto e podem servir de ponto de partida:

  • o default do retry ser habilitado;
  • migração trazendo configurações que ninguém escolheu;
  • o NGINX ser subestimado até quebrar;
  • o de/para para a F5 como mais um momento em que esses padrões mudam sem ninguém perceber.]
Tagged:
Engenheiro de software desde 2011, trabalhando com .NET, Python, arquitetura distribuída e cloud (Azure e AWS). Escrevo sobre o que aprendo construindo e mantendo plataformas: testes, governança técnica, pipelines, migrações e agentes de IA.

LEAVE A RESPONSE

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Related Posts