CloudWatchComunidade
Nível de dificuldade: Intermediário (3 de 5)
AWS DevOps Agent encontra no EKS a causa de latência que os alarmes de CPU e memória não veem
Um laboratório publicado na comunidade AWS Community Builders mostra como o AWS DevOps Agent, com acesso de leitura a um cluster EKS, achou em cinco minutos a causa de uma lentidão que CPU, memória e contagem de reinícios não detectavam.
Um laboratório publicado na comunidade AWS Community Builders mostra como o AWS DevOps Agent, com acesso de leitura a um cluster EKS, achou em cinco minutos a causa de uma lentidão que CPU, memória e contagem de reinícios não detectavam.
Quem configura alarmes no CloudWatch conhece a cena: o painel mostra tudo verde e, mesmo assim, o telefone toca porque um cliente ficou esperando quase um minuto por uma resposta. Um laboratório publicado por um integrante da comunidade AWS Community Builders, com o repositório github.com/BnkTCh/aws-devops-labs, documenta exatamente esse cenário dentro de um cluster EKS e mostra o que aconteceu quando o AWS DevOps Agent entrou na investigação com acesso de leitura ao cluster.
Em números
- 69 segundos foi o tempo máximo de espera de um cliente durante o incidente simulado
- 5x foi o fator de aumento de tráfego que disparou a degradação, ao escalar o gerador de carga de 1 para 5 réplicas
- 5 minutos foi o tempo que o AWS DevOps Agent levou para fechar a investigação completa, da alarme à causa raiz
- 2,3% foi a utilização de CPU do pod afetado no pico do incidente, bem abaixo de qualquer limiar que dispararia alarme
O problema
No laboratório, uma API Python chamada slow-api rodava num cluster EKS com falhas propositais: parte das chamadas demorava de 3 a 8 segundos, parte retornava erro 500. Quando o tráfego foi quintuplicado, os pods começaram a reiniciar sozinhos e alguns clientes esperaram até 69 segundos por uma resposta.
Quatro alarmes do CloudWatch cobriam o ambiente: erros nos logs, reinícios de contêiner, CPU e memória, cada uma sobre o limite do próprio pod. Só a alarme de erros disparou. CPU, memória e reinícios continuaram dentro do normal, porque o pod não estava sem recursos: estava bloqueado esperando.
O motivo técnico é simples e comum: o servidor da aplicação usava http.server.HTTPServer, que atende uma requisição por vez. Com o tráfego multiplicado, as requisições lentas entupiram a fila, inclusive o health check, e o liveness probe passou a matar pods saudáveis por timeout, não por falta de memória.
A arquitetura
O pipeline descrito no lab liga a aplicação, a observabilidade e o agente de investigação num fluxo único, do usuário ao diagnóstico:
- O cliente faz a requisição a um Network Load Balancer internet-facing, exposto via anotação
service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facingem um Service do tipoLoadBalancer. - O NLB encaminha o tráfego para os pods de
slow-api, rodando em nós provisionados sob demanda pelo EKS Auto Mode. - O
HTTPServersingle-threaded enfileira as requisições; sob carga, ohealth checkinterno também fica na fila e começa a falhar. - O CloudWatch Agent e o Fluent Bit, instalados pelo add-on
amazon-cloudwatch-observability(Container Insights), coletam CPU, memória, rede, reinícios e logs de cada pod. - Um metric filter transforma cada linha
[ERROR]dos logs numa métrica customizada no namespaceCustomEKSMetrics. - A alarme
eks-demo-app-errors-highdispara sobre essa métrica e notifica um tópico SNS. - O engenheiro de plantão abre o chat do AWS DevOps Agent e pede a investigação da aplicação degradada.
- O Agent Space, autenticado por uma role com
access entryno cluster, consulta a API do Kubernetes (eventosScalingReplicaSet, estado de pods e deployments) e cruza isso com CloudWatch Logs e CloudTrail. - O agente devolve causa raiz, linha do tempo do raciocínio e um plano de mitigação, sem executar nenhuma ação no cluster.
Os serviços envolvidos
O pipeline combina seis peças, cada uma com um papel específico:
| Serviço | Papel no pipeline |
|---|---|
| EKS Auto Mode | Sobe e gerencia os nós sob demanda, sem que o time cuide da camada de workers |
| CloudWatch Container Insights | Coleta métricas e logs de cada pod via CloudWatch Agent e Fluent Bit |
| CloudWatch Logs Metric Filters | Converte padrões de log, como [ERROR], em métricas que podem virar alarme |
| CloudWatch Alarms + SNS | Detecta o sintoma e aciona a notificação que inicia a investigação |
| AWS DevOps Agent (Agent Space) | Investiga a causa raiz cruzando CloudWatch com a API do Kubernetes |
| IAM + EKS access entries | Definem o que o agente pode ler dentro do cluster, via access entry e AmazonEKSViewPolicy |
Segundo o relato do laboratório, um detalhe de configuração muda o resultado inteiro: o CloudWatch mediria pod_cpu_utilization e pod_memory_utilization contra a capacidade do nó, não do pod. Num nó de 4 vCPU, um pod no limite de 250m de CPU apareceria com apenas 6% de uso, e a alarme nunca dispararia. O lab evita esse cenário usando pod_cpu_utilization_over_pod_limit e pod_memory_utilization_over_pod_limit, que comparam contra o limite declarado no próprio pod; vale confirmar esse comportamento na documentação oficial do Container Insights antes de reproduzir a configuração.
Trade-offs
O ponto central, do pilar de segurança do Well-Architected, é que o agente recebeu acesso somente leitura: a configuração desativa ações automáticas e a access entry usa AmazonEKSViewPolicy, que, segundo a descrição do autor do laboratório, lê pods, eventos e deployments, mas não altera nada e não lê Secrets (vale checar o escopo exato dessa policy na documentação oficial da AWS antes de assumir esse comportamento em produção). Isso limita o raio de dano se a investigação for mal conduzida, ao custo de exigir que uma pessoa valide e execute o plano de mitigação.
Do pilar de confiabilidade, o ganho é claro: sem uma access entry no cluster, o agente enxergaria a alarme de erros, mas não o evento de escalonamento, nem as falhas de readiness, nem o exit 137 que matou os pods. Só a API do Kubernetes mostra isso. É um investimento de dois comandos (create-access-entry e associate-access-policy) por um ganho de visibilidade que métricas de infraestrutura simplesmente não têm.
Do pilar de excelência operacional, há um gap que o próprio agente admitiu: sem os audit logs do control plane do EKS ativados, ninguém, nem o agente, nem um humano, sabe quem escalou o traffic-generator. O relatório marcou isso como lacuna em vez de inventar uma resposta, o que é o comportamento correto, mas o trade-off é real: sem auditoria ligada, a investigação para exatamente na fronteira entre ambiente e intenção humana.
Custo estimado
O próprio lab estima o custo de rodar o cenário completo entre $3 e $5, desde que o ambiente seja destruído em até duas horas, mais o tempo de uso do agente, que é cobrado à parte. É um valor de laboratório descartável, não uma estimativa de produção: um cluster real com Container Insights ligado em dezenas de serviços acumula custo de ingestão de logs e métricas que o artigo não detalha.
Vale notar que o lab roda em us-east-1. Quem opera no Brasil deve confirmar a disponibilidade do AWS DevOps Agent e do Agent Space em sa-east-1 antes de replicar o desenho, já que a fonte não cobre regiões fora da usada no laboratório.
Como adaptar
Para levar essa ideia a um ambiente com dezenas de serviços e vários clusters, o lab sugere um conjunto de práticas, não uma receita única:
- Alarme sobre o que o usuário sente primeiro (taxa de erro e latência), e só depois sobre CPU e memória, que neste caso ficaram mascaradas mesmo com o pod travado.
- Troque
http.server.HTTPServerporThreadingHTTPServerem serviços reais que ainda usam um servidor single-threaded sob carga concorrente, para que uma requisição lenta não enfileire ohealth checkatrás dela. - Deixe os
probesde liveness mais tolerantes e adicione umHorizontalPodAutoscalercomPodDisruptionBudget, para que o escalonamento automático absorva picos antes que oliveness probecomece a matar pods saudáveis. - Dê ao agente uma
access entryde leitura em cada cluster que ele precisa investigar: o custo é de dois comandos por cluster, e sem isso a investigação fica cega para tudo que só existe na API do Kubernetes. - Ative os
audit logsdo control plane do EKS antes de depender do agente para responder "quem fez essa mudança", porque sem essa trilha nem humano nem IA consegue reconstruir a autoria. - Some Application Signals ou X-Ray à instrumentação: o agente só enxerga o que está sendo coletado, e latência distribuída entre serviços pede traços, não só logs e métricas por pod.
O ponto que atravessa todas essas recomendações é que o valor do pipeline não está num incidente isolado resolvido rápido, mas em cada alarme chegar com a investigação adiantada, sem depender de quem está de plantão às três da manhã revisando log por log.
Serviços neste textoCloudWatch
Leve para a sua IA
Decida com o seu assistente, com o contexto deste texto já montado.
1. O que você quer saber
Ver o prompt
Li no AWS Hub: "AWS DevOps Agent encontra no EKS a causa de latência que os alarmes de CPU e memória não veem" (https://awshub.com.br/comunidade/aws-devops-agent-encontra-no-eks-a-causa-de-latencia-que-os-alarmes-de-cpu-e-mem). Resumo: Um laboratório publicado na comunidade AWS Community Builders mostra como o AWS DevOps Agent, com acesso de leitura a um cluster EKS, achou em cinco minutos a causa de uma lentidão que CPU, memória e contagem de reinícios não detectavam. Serviços: CloudWatch Minha stack: [descreva em uma linha: serviços, linguagem, volume, região] Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?