IAMComunidade
Nível de dificuldade: Especialista (5 de 5)
EKS Pod Identity fecha a lacuna entre RBAC do Kubernetes e permissões da AWS
Um artigo publicado em 7 de novembro de 2026 por Sajana Kirindeniya no Medium expõe um ponto cego comum em clusters EKS: times que blindam o RBAC do Kubernetes e esquecem que o acesso à AWS é decidido por outro sistema, o IAM. A autora descreve, passo a passo, como essa lacuna vira caminho de escalada quando um pod é comprometido, e por que o worker node seguir com uma IAM role genérica continua sendo prática arriscada mesmo em 2026.
O recorte interessa direto a quem desenha a malha de identidade do cluster: arquitetos, SREs e quem cuida especificamente de IAM. RBAC e IAM são dois perímetros de autorização independentes, e nenhuma configuração dentro do Kubernetes reduz sozinha o que uma aplicação pode fazer contra s3:GetObject, secretsmanager:GetSecretValue ou dynamodb:Query.
Dois perímetros que não se enxergam
O RBAC do Kubernetes decide o que um ServiceAccount pode fazer contra a API do cluster: listar pods, criar deployments, ler ConfigMaps, operar dentro de um namespace. O IAM da AWS decide algo completamente diferente, o que a mesma aplicação pode fazer contra os serviços da AWS quando chama a API com credenciais válidas.
Uma Role do Kubernetes que restringe o payment-api a só ler pods no namespace payments não impede nada no lado da AWS. Se o pod tiver credenciais válidas de uma IAM role com s3:*, ele chama s3:GetObject em qualquer bucket da conta sem que o RBAC perceba. Em resumo: travar um lado não trava o outro, e os dois precisam de configuração própria.
O cenário de ataque descrito no artigo
O exemplo usado é direto: uma aplicação de pagamentos (payment-api) roda dentro do EKS com RBAC corretamente restrito, mas o worker node onde o pod está agendado carrega uma IAM role de instância ampla. Se essa role vaza para dentro do container, o atacante que já tem execução de comando (via RCE, dependência insegura, injeção de comando ou endpoint administrativo exposto) ganha acesso à AWS inteira, não só ao namespace do Kubernetes.
O caminho descrito pela autora segue uma sequência técnica reconhecível:
- O atacante explora uma vulnerabilidade na aplicação e ganha execução de comando no container.
- Ele investiga o ambiente com
env | grep AWSe testa o endpoint do Instance Metadata Service,http://169.254.169.254. - Se o IMDS responder (e a instância não exigir IMDSv2), ele recupera as credenciais temporárias da IAM role do worker node.
- Com essas credenciais, ele chama a API da AWS com qualquer permissão que a role do node tiver.
Uma aplicação comprometida não deveria se tornar automaticamente um portal para todo o ambiente AWS.
A compromised application should not automatically become a gateway to the broader AWS environment.Sajana Kirindeniya, autora do artigo no Medium
O ponto central é que o blast radius deixa de ser o namespace comprometido e passa a ser a conta da AWS inteira, dependendo de quanto a role do node acumula.
Por que a role do worker node vazar é tão comum
O artigo cita uma policy de exemplo, deliberadamente exagerada para ilustrar o problema, mas próxima do que se vê em ambientes reais que nunca foram auditados:
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["s3:*", "secretsmanager:GetSecretValue", "dynamodb:*"],
"Resource": "*"
}]
}Duas falhas estruturais aparecem aqui. A primeira é permissão em excesso: a role cobre múltiplos serviços quando a aplicação só precisa de um recurso específico. A segunda é identidade compartilhada: todas as cargas que rodam no mesmo node herdam a mesma identidade, se o acesso ao IMDS não for restringido por pod. Isso torna impossível separar quem fez o quê quando algo dá errado, o que complica qualquer pós-mortem de incidente.
IRSA: a solução que já existe há anos
IAM Roles for Service Accounts (IRSA) resolve o problema associando um ServiceAccount do Kubernetes a uma IAM role específica, via um provedor OIDC exposto pelo próprio EKS. O fluxo documentado no artigo tem oito etapas: o EKS expõe o issuer OIDC, a AWS registra esse provedor, uma IAM role é criada com trust policy referenciando o provedor, o trust restringe por namespace e ServiceAccount, o ServiceAccount recebe a annotation eks.amazonaws.com/role-arn, o pod recebe um token projetado, o SDK troca esse token por credenciais via AssumeRoleWithWebIdentity no STS, e o STS devolve credenciais temporárias.
Na prática, o ServiceAccount fica assim:
apiVersion: v1
kind: ServiceAccount
metadata:
name: payment-api
namespace: payments
annotations:
eks.amazonaws.com/role-arn: arn:aws:iam::123456789012:role/payment-api-roleE o trust policy da role restringe quem pode assumi-la usando a condição sub:
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLE:aud": "sts.amazonaws.com",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLE:sub": "system:serviceaccount:payments:payment-api"
}Isso impede que qualquer outro ServiceAccount, de qualquer outro namespace, assuma a mesma role. IRSA segue sendo válido para ambientes já estabelecidos, e o artigo é claro em não recomendar migração só porque existe alternativa mais nova.
EKS Pod Identity: o mesmo resultado sem OIDC por cluster
A diferença operacional do EKS Pod Identity é administrativa, não criptográfica. Em vez de registrar um provedor OIDC por cluster e referenciá-lo em cada trust policy, o Pod Identity usa uma associação gerenciada pelo próprio EKS, um DaemonSet (o EKS Pod Identity Agent) e a EKS Auth API.
O fluxo descrito tem cinco peças: a associação entre cluster, namespace, ServiceAccount e IAM role; o Agent rodando como DaemonSet nos nodes elegíveis; a chamada AssumeRoleForPodIdentity feita pelo Agent à EKS Auth API usando o token projetado do pod; a validação da associação pelo EKS; e a devolução das credenciais temporárias para a aplicação.
A associação é criada direto via AWS CLI, sem tocar no YAML do ServiceAccount:
aws eks create-pod-identity-association \
--cluster-name production-cluster \
--namespace payments \
--service-account payment-api \
--role-arn arn:aws:iam::123456789012:role/payment-api-roleO trust policy também muda de principal, agora é pods.eks.amazonaws.com, e passa a exigir duas ações, não uma:
"Principal": { "Service": "pods.eks.amazonaws.com" },
"Action": ["sts:AssumeRole", "sts:TagSession"]sts:AssumeRole permite que o serviço de Pod Identity assuma a role; sts:TagSession habilita as session tags que carregam cluster, namespace e ServiceAccount dentro da sessão assumida. O artigo recomenda ainda considerar a condição aws:SourceOrgId no trust policy para reduzir o risco de confused deputy entre serviços da AWS.
IRSA ou Pod Identity: o que muda na operação do cluster
| IRSA | EKS Pod Identity | |
|---|---|---|
| Requer provedor OIDC por cluster | Sim, configurado manualmente | Não, gerenciado pelo EKS |
| Onde fica a referência à role | Annotation no ServiceAccount | Associação via API/CLI do EKS |
| Principal no trust policy | OIDC do cluster | pods.eks.amazonaws.com |
| Ações exigidas no trust | sts:AssumeRoleWithWebIdentity | sts:AssumeRole + sts:TagSession |
| Indicado para | Clusters já em produção com IRSA | Clusters novos, multi-cluster |
Para quem administra múltiplos clusters, a vantagem prática do Pod Identity é não repetir o cadastro de provedor OIDC em cada um deles nem reescrever trust policies toda vez que um cluster é recriado. Isso simplifica rotação de clusters em cenários de blue/green ou de disaster recovery, onde o OIDC issuer muda a cada recriação.
O IMDS continua sendo a porta dos fundos
Nem IRSA nem Pod Identity fecham sozinhos o acesso ao IMDS do worker node. Se o pod ainda alcançar 169.254.169.254 e as credenciais da instância, o atacante tem uma rota alternativa para a role do node, mesmo com workload identity configurada corretamente.
O artigo lista cinco controles complementares, direcionados a quem mexe na malha de rede do cluster e nas políticas de IAM:
- Exigir IMDSv2 nas instâncias EC2, eliminando requisições não autenticadas via IMDSv1.
- Restringir o acesso de pods ao endpoint de metadados quando a aplicação não precisa dele.
- Ajustar o hop limit da resposta de metadados para 1, testando antes contra a topologia de rede real.
- Revisar pods com
hostNetwork: true, que mantêm acesso ao IMDS independente das restrições normais de rede do container. - Não tratar o IMDSv2 como substituto do isolamento de credenciais por workload: é complemento, não solução completa.
O que muda para quem responde pela conta
Para quem cuida especificamente de IAM dentro do time de plataforma, o recado prático do artigo é reduzir a role do worker node ao mínimo de operação de infraestrutura e nunca usá-la como atalho de permissão para aplicação. Cada ServiceAccount de aplicação merece sua própria IAM role, com policy restrita ao recurso exato que ela usa, como o exemplo do artigo que limita payment-api a s3:GetObject em um único bucket.
O trade-off real não está em escolher IRSA ou Pod Identity: as duas entregam isolamento de credenciais equivalente. Está em auditar, hoje, quantas aplicações no cluster ainda dependem implicitamente da role do node porque nunca tiveram um ServiceAccount dedicado criado, e em decidir se vale rodar essa migração aplicação por aplicação ou tratar como item de Well-Architected pendente no próximo ciclo de revisão.
Serviços neste textoIAM
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: "EKS Pod Identity fecha a lacuna entre RBAC do Kubernetes e permissões da AWS" (https://awshub.com.br/comunidade/eks-pod-identity-fecha-a-lacuna-entre-rbac-do-kubernetes-e-permissoes-da-aws). Resumo: Um pod com RBAC impecável ainda pode herdar credenciais de IAM muito mais amplas do que sua função exige. Um artigo publicado no Medium detalha o cenário de ataque e compara IRSA com EKS Pod Identity como resposta. Serviços: IAM 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ã?