Como o Google rastreou timeouts na API do GKE até um bug no kernel Linux

- Leitura
- 7 min
- Fontes
- 1
Em janeiro, times do Google levaram semanas para entender por que a API do Kubernetes no GKE travava de forma intermitente. A causa final não estava em nenhuma configuração, mas em três bugs encadeados, um deles dentro do próprio kernel Linux.
O sintoma: a API do Kubernetes some e volta sozinha
Em janeiro, um cliente do Google Kubernetes↳Kubernetes18 conteúdosGerenciamento de infraestrutura multicloud com Kubernetes proporciona otimização e economiaDevSecOps · set 2021Azure Kubernetes Services – AKS: referências gratuitas e dicas para solução de problemas comunsDevSecOps · abr 2019Kubernetes em produção: o que ninguém te conta e você aprende tarde demaisDev (Back & Front) · abr 2026Ver tudo em DevSecOps → Engine (GKE) rodando múltiplos clusters com Private Service Connect (PSC) para acesso privado ao control plane começou a ver algo difícil de reproduzir: pods tentando falar com o servidor da API do Kubernetes recebiam timeouts intermitentes. Não era um erro constante, nem ligado a um deploy específico. Era o tipo de falha que aparece, some, e deixa qualquer time de plataforma catatônico.
As capturas de pacote mostraram algo estranho: o control plane respondia a pedidos de NOVA conexão TCP com pacotes ACK obsoletos, pertencentes a conexões já encerradas. Ou seja, o servidor estava "confundindo" sessões TCP diferentes. Esse tipo de sintoma raramente aponta para uma causa única, e desta vez não foi diferente: o Google Cloud identificou três bugs distintos, em três camadas de rede separadas, que só causavam problema quando combinados.
O caso afetou cerca de 800 desenvolvedores que ficaram impedidos de fazer deploy em produção enquanto a investigação corria, segundo o relato publicado pela InfoQ.
Três bugs, três camadas, um sintoma idêntico
Akash Thakur, engenheiro sênior de soluções técnicas no Google Cloud, descreve a escala do esforço de investigação:
Numa corrida contra o tempo para resolver o problema, envolvemos engenheiros do Google Kubernetes Engine (GKE), do Private Service Connect, de redes, do hostnet, do kernel e da comunidade upstream do Linux, que juntos rastrearam não uma, mas três causas-raiz distintas. E a correção final não veio como uma mudança de configuração ou uma feature flag, mas como um patch no próprio kernel Linux.
Akash Thakur, senior technical solutions engineer no Google CloudIn a race to fix the problem, we involved engineers across Google Kubernetes Engine (GKE), Private Service Connect, networking, hostnet, kernel, and the Linux upstream community, who together tracked down not one but three distinct root causes. And the final fix landed not as a config change or a feature flag, but as a patch to the Linux kernel itself.
As três causas identificadas foram:
- Reordenação de pacotes no Private Service Connect, que entregava pacotes TCP fora da ordem esperada.
- Comportamento de half-close do Envoy, que impedia que conexões TCP fossem fechadas corretamente dos dois lados.
- Um bug no kernel Linux que descartava certos pacotes FIN reordenados, deixando sockets presos indefinidamente no estado
FIN_WAIT_2.
Sozinho, cada um desses comportamentos é até razoável: reordenação de pacotes acontece em qualquer rede, half-close é uma estratégia legítima de conexão, e o tratamento de FIN_WAIT_2 é um detalhe de implementação do TCP. Juntos, formaram uma falha que nenhum dos três times enxergava sozinho.
Numa corrida contra o tempo para resolver o problema, envolvemos engenheiros do Google Kubernetes Engine (GKE), do Private Service Connect, de redes, do hostnet, do kernel e da comunidade upstream do Linux, que juntos rastrearam não uma, mas três causas-raiz distintas. E a correção final não veio como uma mudança de configuração ou uma feature flag, mas como um patch no próprio kernel Linux.
No original: In a race to fix the problem, we involved engineers across Google Kubernetes Engine (GKE), Private Service Connect, networking, hostnet, kernel, and the Linux upstream community, who together tracked down not one but three distinct root causes. And the final fix landed not as a config change or a feature flag, but as a patch to the Linux kernel itself.
Fonte: InfoQPor que isso é tão difícil de depurar
O que torna este caso interessante para quem trabalha com infraestrutura não é o bug em si, mas o motivo de ele ter levado tanto tempo para ser isolado. Thakur explica o problema central da investigação:
Na maioria dos casos de rede, a resolução acontece numa única camada. Você acha a regra de firewall mal configurada, o pool de conexões esgotado, o MTU mal calculado. Corrige e segue em frente. Este foi diferente porque o sintoma, um timeout de I/O numa conexão que nunca se completava, era o mesmo não importa se você olhasse para a camada do Private Service Connect, para a máquina de estados TCP do kernel ou para o gerenciamento de conexões do Envoy. Cada camada tinha uma explicação plausível, e cada explicação estava incompleta.
Akash Thakur, senior technical solutions engineer no Google CloudMost networking cases resolve at one layer. You find the misconfigured firewall rule, the exhausted connection pool, the miscalculated MTU. You fix it and move on. This one was different because the symptom — i/o timeout on a connection that never completed — was the same whether you were looking at the Private Service Connect layer, the kernel's TCP state machine, or Envoy's connection management. Every layer had a plausible explanation, and every explanation was incomplete.
Rohan Karne, managing director no Google Cloud, resume o tipo de trabalho que isso exigiu:
Essa é a realidade pouco glamorosa da engenharia de plataformas de missão crítica: descartar metodicamente os suspeitos óbvios e vasculhar capturas de pacotes até achar a causa-raiz no kernel.
Rohan Karne, managing director no Google CloudThis is the unglamorous reality of mission-critical platform engineering—methodically ruling out the obvious suspects and digging into packet captures until you find the kernel root cause.
A correção: rollback, patch de proxy e, por fim, o kernel
A solução veio em três etapas coordenadas, ao longo de várias semanas. Primeiro, o Google reverteu uma mudança recente no Private Service Connect para restaurar a conectividade imediatamente. Em seguida, corrigiu o tratamento do proxy protocol no Envoy e adicionou testes de regressão para evitar recorrência. A terceira etapa foi a mais demorada: um patch no próprio kernel Linux, de autoria de Eric Dumazet, ex-engenheiro de software do Google, que resolveu o problema de fundo no tratamento de pacotes FIN reordenados.
Esse patch foi incorporado ao Linux 6.9.7 e retroportado (backport) para os branches LTS 6.6 e 6.1. Ele chegou aos clusters de clientes do GKE a partir da versão 1.33.5.
O detalhe que todo mantenedor de cluster deveria notar
Justin Garrison, field CTO na Sidero, chamou atenção para um ponto que costuma passar batido em anúncios de correção de bug: a defasagem entre o kernel usado em produção e o kernel upstream.
No começo fiquei animado ao ler este artigo que termina num patch de kernel, que são sempre divertidos de acompanhar. Acontece que o GKE simplesmente roda um kernel de três anos atrás (6.1), e o bug já tinha sido corrigido no upstream, só que eles precisaram fazer o backport.
No original: At first I was excited to read this article that leads to a kernel patch which are always fun. It turns out GKE just runs a kernel from 3 years ago (6.1) and the bug was already fixed upstream and they had to backport it.
No começo fiquei animado ao ler este artigo que termina num patch de kernel, que são sempre divertidos de acompanhar. Acontece que o GKE simplesmente roda um kernel de três anos atrás (6.1), e o bug já tinha sido corrigido no upstream, só que eles precisaram fazer o backport.
Justin Garrison, field CTO na SideroAt first I was excited to read this article that leads to a kernel patch which are always fun. It turns out GKE just runs a kernel from 3 years ago (6.1) and the bug was already fixed upstream and they had to backport it.
Essa observação importa para quem roda Kubernetes gerenciado (GKE, EKS, AKS) ou kernels LTS em clusters on-premise: a "versão estável" nem sempre significa "sem este bug específico". O processo normal de backport de correções de segurança e estabilidade do Linux pode demorar para chegar a uma distribuição ou a um serviço gerenciado, mesmo quando o patch já existe há meses no upstream.
O que muda para quem opera Kubernetes
O caso não é motivo para pânico generalizado, mas traz lições práticas para quem administra clusters com arquitetura de rede parecida:
- Quem usa Private Service Connect com GKE e viu timeouts intermitentes e inexplicáveis na API deve verificar se o cluster já está em uma versão 1.33.5 ou posterior.
- Times que operam Envoy como proxy de conexões TCP de longa duração ganham um lembrete de que o comportamento de half-close precisa ser testado sob reordenação de pacotes, não só em condições ideais de rede.
- Qualquer equipe de SRE que debate "em que camada está o problema" deveria notar o ponto levantado por Guangba Yu, pesquisador de pós-doutorado na Chinese University of Hong Kong:
Para AIOps e engenharia do caos, o método transferível aqui é organizar observações simultâneas de caminho de rede, estado de protocolo e eventos de rollout, distinguindo a recuperação do sintoma da correção efetiva da máquina de estados. Este caso anonimizado não fornece uma taxa de falha da população nem explica todos os timeouts de API.
Guangba Yu, postdoctoral researcher na Chinese University of Hong KongFor AIOps and chaos engineering, the transferable method is organizing simultaneous path observations, protocol state, and rollout events while distinguishing symptom recovery from state-machine correction. This anonymized case supplies no population failure rate and does not explain all API timeouts.
Ou seja: correlacionar sintoma de rede com evento de rollout (o que mudou, quando) foi o que permitiu ao Google separar os três bugs. Isso vale tanto para quem monitora Kubernetes manualmente quanto para quem está construindo pipelines automatizados de causa-raiz com IA↳Inteligência artificial440 conteúdosUX e IA: Transformando Experiências Digitais com Inteligência ArtificialProduto & UX · jan 2025MCP: O que é e por que você vai ouvir falar disso em breve?AI · jul 2025IA generativa e a urgência de reconstruir nossa relação com a verdadeAI · jun 2025Ver tudo em AI →.
O que fica em aberto
O relato original do Google Cloud não divulga a taxa de incidência do bug fora do cliente afetado, nem garante que o mesmo padrão de FIN_WAIT_2 preso não apareça em outras combinações de proxy e kernel. Para quem roda infraestrutura própria sobre Linux (não só GKE), vale a pena revisar se o kernel em uso já recebeu o patch de Dumazet, disponível desde a versão 6.9.7 e retroportado para 6.6 e 6.1 LTS, antes de descartar timeouts intermitentes como "instabilidade de rede sem explicação".
Fonte: InfoQ
Highlights
- Três bugs encadeados em Private Service Connect, Envoy e kernel Linux causaram timeouts intermitentes na API do GKE de 800 desenvolvedores em janeiro
- Patch do kernel Linux 6.9.7 de Eric Dumazet (ex-Google) foi retroportado para branches LTS 6.6 e 6.1 e chegou ao GKE 1.33.5
- Mesmo comportamento de timeout em três camadas diferentes (Private Service Connect, TCP state machine, gerenciamento Envoy) tornou diagnóstico extremamente difícil
- GKE usa kernel de três anos atrás (6.1 LTS) e precisou fazer backport de correção já disponível no upstream
- Correlacionar mudanças de rollout com sintomas de rede foi método que permitiu separar os três bugs distintos
Este artigo foi escrito por Redação iMasters. Conteúdo produzido por agente de IA da redação iMasters, sob revisão editorial humana. Saiba como produzimos no expediente.
Bending Spoons compra o Mailchimp da Intuit por US$ 3,68 bilhões
A italiana Bending Spoons fechou a compra da plataforma de email marketing por menos de um terço do valor que a Intuit pagou em 2021. Para quem usa a ferramenta no Brasil, o histórico da compradora com outras marcas dá pistas do que vem pela frente.













