AWS Nitro Sandboxes no EKS: Hands-On com Pods Isolados e Confidenciais
Por Fabio Douek
Conduzido por humano, com apoio de IA. Pesquisa e implementação feitas com ferramentas de IA, conduzidas, testadas e editadas por mim. Como os posts são classificados
Ir para seção
- Visão Geral
- Arquitetura
- Configuração
- Passo 1: Ferramentas
- Passo 2: Uma VPC e um cluster Auto Mode com Terraform
- Passo 3: As RuntimeClasses, antes de qualquer node
- Passo 4: Um NodePool Graviton, limitado a um node
- Passo 5: A mudança de uma linha
- Testes
- Teste 1: O primeiro pod, e o node que ele traz
- Teste 2: Um pod de sandbox e um pod comum no mesmo node
- Teste 3: Latência de inicialização num node já aquecido
- Teste 4: Configurações de nível de host dentro de um sandbox
- Teste 5: Quantos pods de sandbox cabem num node
- Teste 6: Um pod confidencial, de ponta a ponta
- Teste 7: Confidencial, isolado e adulterado
- Resumo dos resultados
- Operação e Monitoramento
- Preços
- Limpeza
- Veredito
- O que funciona
- O que ainda não funciona
- Quem deve usar
Explica (TLDR) como se eu fosse...
Imagina uma estante grande de brinquedos onde agora qualquer brinquedo pode ganhar a sua própria caixinha com tampa. Você escreve uma palavra na etiqueta do brinquedo, e a estante coloca ele na caixa para você, assim um brinquedo bagunceiro não se espalha em cima dos outros.
Também existe uma caixa especial com um selo que diz exatamente o que tem dentro. Um adulto só abre o pote de biscoitos para uma caixa cujo selo confere. A estante diz que tem lugar para 20 caixas, mas em alguns dias só cabem 18 ou 19, e eu ainda não descobri por quê.
No Amazon EKS, o isolamento por hardware agora é uma propriedade do pod. Um campo na pod spec roda o pod na sua própria máquina virtual, num node compartilhado. A pod spec em si continua sendo uma entrada confiável, então quem pode submeter pods controla o que roda dentro deles, e essa permissão merece ser restrita.
O modo confidencial acrescenta evidência. O pod apresenta uma medição assinada da sua própria policy, e uma chave do AWS KMS liberou um segredo só quando ela conferia. O mesmo pod no modo isolado, sem essa policy, foi recusado, o acesso interativo foi negado, e uma cópia com um comando alterado foi barrada antes de o container dela iniciar. Dois comportamentos documentados não bateram com o que eu observei, então verifique antes de depender deles.
A queixa principal são pods num mesmo node compartilhando um único kernel. A intervenção é uma máquina virtual dedicada por pod, prescrita com uma linha na pod spec. Na minha execução, o pod em sandbox tinha o próprio kernel, uma vCPU e memória dimensionada a partir do seu request, ao lado de um pod comum que enxergava o node inteiro.
Efeitos colaterais: uns três segundos a mais para iniciar, 256 MiB reservados por pod (512 MiB quando confidencial) e um teto de cinco sandboxes por vCPU: meu node anunciava 20, e de 18 a 20 eram utilizáveis. Para pods confidenciais a evidência é forte: o KMS liberou uma chave só para o pod cuja medição de policy conferia.
Times que rodam código que não escreveram costumam carregar uma preocupação silenciosa com o que uma imagem ruim poderia alcançar. Aqui a resposta é uma linha na pod spec, e no Auto Mode não é preciso instalar mais nada, o que tira um pouco do medo de dizer sim.
O novo peso é a contabilidade. Pods confidenciais precisam de uma policy gerada, e uma mudança na imagem, no comando, no ambiente ou até no nome do pod significa gerá-la de novo e atualizar a key policy. Meu node de 4 vCPUs anunciava 20 slots de sandbox, cinco por vCPU, e eu nem sempre consegui preencher todos, então alguém vai acompanhar a capacidade mais de perto do que antes, e o Container Insights não vai ajudar: ele não reportou nada para os pods em sandbox.
Imagine uma sala de ensaio onde todas as bandas dividiam as mesmas paredes. Agora cada banda pode ganhar a própria cabine com isolamento acústico dentro dessa sala, do tamanho do que pediu: uma vCPU e a memória do seu request, nada emprestado da casa.
As cabines levam uns três segundos a mais para montar do que um canto aberto, e uma sala deste tamanho tem 20 lugares, embora em algumas noites só caibam 18 ou 19 bandas. A cabine confidencial toca a partir de uma partitura lacrada, e se alguém mexer num compasso, a banda nunca sobe ao palco.
A história para times de Kubernetes é simples: isolamento por máquina virtual, por pod, no EKS Auto Mode, ligado com um campo na pod spec, sem custo adicional. As runtime classes já estavam lá antes de o cluster ter um único node.
A prova está no modo confidencial. Uma chave do KMS que só abre para um pod cuja medição de policy confere, com o acesso interativo negado, é uma demo que compradores de setores regulados entendem na hora. Seja honesto sobre densidade: cinco sandboxes por vCPU e 256 MiB reservados por pod servem melhor a workloads reais do que a enxames de workloads minúsculos.
Visão Geral
Em 2026-11-09 a AWS lançou os Nitro Sandboxes: VMs leves que o hypervisor Nitro recorta de uma instância EC2, cada uma um guest de primeiro nível ao lado da sua instância pai. No Amazon EKS, a feature é o sandboxing com pods isolados e confidenciais: cada pod roda no próprio Nitro Sandbox, “um guest de primeiro nível com virtualização direta assistida por hardware, não por emulação nem por virtualização aninhada”, e muitos deles compartilham um node.
Este post, parte 4 de 4, cobre o EKS. A Parte 1 explica a arquitetura e compara as três portas de entrada, a parte 2 opera a primitiva bruta no EC2 com Firecracker, e a parte 3 cobre o ECS.
No EKS, a “mudança de uma linha” do anúncio é o runtimeClassName, e no EKS Auto Mode a documentação promete o resto: “O Auto Mode inclui suporte a Nitro Sandbox sem nenhuma configuração adicional. Você não cria nem gerencia uma AMI.” Eu queria saber o que essa frase deixa de fora: o que o Auto Mode instala de fato, se um node Graviton funciona quando o node pool embutido é só amd64, o que um pod em sandbox enxerga ao lado de um pod comum, quantos cabem num node, e se a atestação do modo confidencial funciona de ponta a ponta via Pod Identity. Eu rodei tudo duas vezes num cluster Auto Mode com Kubernetes 1.37 em us-east-1, em 2026-11-10, com um node m8g.xlarge por vez (Graviton4, 4 vCPU, 16 GiB), kubectl 1.37.2 e AWS CLI 2.39.7: uma execução exploratória a partir das 00:12 UTC, e a execução gravada que o vídeo mostra, num cluster novo, das 02:08 até por volta das 06:30. Onde a execução gravada mostra um número, eu uso esse número e dou o da primeira execução ao lado. Uma terceira execução, mais tarde no mesmo dia, para a seção de operações do vídeo, criou o cluster no console e olhou o monitoramento e o CloudTrail (Operação e Monitoramento).
Três resultados se destacaram:
- No Auto Mode, a mudança de uma linha é mesmo toda a configuração. As duas RuntimeClasses já existiam antes de o cluster ter um node, e um NodePool sem nenhuma configuração de sandbox produziu um node Graviton capaz de rodar sandboxes. Ao lado de um pod comum nesse node, o pod em sandbox tinha o próprio kernel, uma vCPU e memória dimensionada a partir do seu request, e num node já aquecido ficou Ready em 4,4 a 5,4 segundos, contra 1,7 a 2,1 de um pod comum.
- O modo confidencial condiciona uma chave do KMS à policy do pod, via Pod Identity. O gerador de policy previu o PCR17 exatamente, nas duas execuções. O KMS liberou um segredo para o pod confidencial e recusou o mesmo pod rodando isolado; o
kubectl execno pod confidencial foi negado, e uma cópia com só o comando alterado foi recusada noCreateContainer, como no ECS. - Uma
m8g.xlargeanuncia 20 slots de sandbox (5 × as suas 4 vCPUs), e eu nem sempre consegui usar todos. É o mesmo limite que eu encontrei no EC2. Em quatro execuções do mesmo Deployment de 22 replicas, de 18 a 20 pods rodaram e o resto ficou emPendingpor falta de slot, e eu não descobri o que segurava os que faltavam.
Arquitetura
O caminho do pod é o de sempre no Kubernetes, com um runtime diferente no final. O kubelet chama o containerd, o containerd chama o containerd-shim-nitro-sandbox-v2, e o shim inicia um processo Firecracker que pede um sandbox ao Nitro. Dentro do guest, o nitro-sandbox-agent roda o próprio containerd e inicia os containers do pod. Em nodes autogerenciados, a documentação liga o mesmo binário do shim entre o kubelet e o containerd como um cri-proxy; no Auto Mode ele também está lá, porque é o componente que recusou o meu pod com hostNetwork no Teste 4. Logs, exec e métricas voltam por vsock.
É a RuntimeClass que faz o trabalho de scheduling. O overhead dela soma memória e um eks.amazonaws.com/nitro-sandbox aos requests de todo pod, e o nodeSelector dela manda o pod para um node com o label eks.amazonaws.com/nitro-sandbox=true; o request do extended resource significa que esse node também precisa ter um slot de sandbox livre. No guest, o agente avalia uma policy Cedar para toda operação controlada: a annotation sandbox.amazonaws.com/policy do pod, se houver uma, ou, no modo isolado, “um default embutido permissivo que permite todos os containers e operações”. A policy é medida no PCR17 do documento de atestação do sandbox, que é o que uma key policy do KMS consegue fixar.
O EKS tem dois modos, escolhidos pela RuntimeClass. No isolated-sandbox, “a instância pai é confiável e o guest não é confiável”, e a policy é opcional. No confidential-sandbox, a instância pai não é confiável, e a policy “fixa todos os campos de admissão (digests de imagem, args, variáveis de ambiente, mounts, capabilities e configurações de segurança)”. Pods sem runtimeClassName usam o runtime padrão do node, no mesmo node. O Teste 2 mostra qual modo de memória do EC2 fica por baixo da classe isolada.
Configuração
O Terraform cria a VPC e o cluster; tudo depois disso é kubectl e o AWS CLI.
Passo 1: Ferramentas
Você precisa do kubectl 1.36 ou mais novo (eu usei o 1.37.2), do Terraform e do AWS CLI. Eu usei o AWS CLI 2.39.7, como na parte 2 e na parte 3, mas nada no EKS precisa de um campo novo: as páginas das APIs CreateCluster, ComputeConfigRequest e UpdateClusterConfig do EKS não mencionam sandboxes nem enclaves em nenhum momento. Você não precisa do eksctl. A única ferramenta só para Linux é o gerador de policy para pods confidenciais. Nesta demo eu rodei ele num pod no cluster (Teste 6), então não precisei de uma máquina Linux, mas isso é um atalho: em produção, rode o gerador no pipeline de CI/CD que produz os seus manifests de pod ou numa estação de trabalho ou container Linux, pelo motivo explicado no Teste 6.
Passo 2: Uma VPC e um cluster Auto Mode com Terraform
Os requisitos rígidos são a versão e a Região. “O Nitro Sandboxes requer o Kubernetes versão 1.36 ou mais novo. Ele é suportado nas duas versões mais recentes”, diz a página de versões. A página de visão geral, numa linha acrescentada depois do lançamento, diz que pods isolados e confidenciais “estão disponíveis nas Regiões comerciais da AWS nos EUA”, enquanto o anúncio ainda coloca os Nitro Sandboxes “em todas as regiões comerciais do mundo”. Minhas execuções foram em us-east-1, então não sei dizer o que acontece em outros lugares. Nem o módulo terraform-aws-modules/eks (21.29.0) nem o provider AWS do Terraform têm um argumento de sandbox, porque não há nada para ligar no nível do cluster. O Terraform cria uma VPC (10.63.0.0/16, duas subnets privadas e duas públicas, um NAT gateway) e este cluster:
# EKS Auto Mode, Kubernetes 1.37. Nitro Sandboxes need 1.36+; there is no
# sandbox-specific argument in the module, the provider or the EKS API.
# Only the "system" built-in pool is enabled: it keeps the default NodeClass
# and does not launch a node on its own. The general-purpose pool is amd64-only,
# so the Graviton (m8g.xlarge) NodePool is created with kubectl.
module "eks" {
source = "terraform-aws-modules/eks/aws"
version = "~> 21.0"
name = local.name # my2cents-nitro-eks
kubernetes_version = "1.37"
endpoint_public_access = true
enable_cluster_creator_admin_permissions = true
compute_config = {
enabled = true
node_pools = ["system"]
}
vpc_id = module.vpc.vpc_id
subnet_ids = module.vpc.private_subnets
}
A linha node_pools = ["system"] é a que precisa de explicação. O pool embutido general-purpose do Auto Mode “Usa só a arquitetura amd64”, segundo a página de pools embutidos, então ele não consegue me dar um node Graviton. Mas “Habilitar pelo menos um NodePool embutido é necessário para que o EKS provisione a NodeClass ‘default’”, e o meu próprio NodePool no Passo 4 precisa dessa NodeClass. O pool system suporta arm64 e tem um taint CriticalAddonsOnly, e ele não lançou nenhum node sozinho: depois do terraform apply, que levou 13 minutos e 42 segundos na primeira execução e uns 13 minutos na gravada, o cluster tinha zero nodes.
terraform init && terraform apply
aws eks update-kubeconfig --region us-east-1 --name my2cents-nitro-eks
kubectl get nodes # No resources found
O control plane reportou v1.37.1-eks-577a51e. A alternativa de um comando só, na documentação, é eksctl create cluster --name sandbox-demo --region us-west-2 --version 1.37 --enable-auto-mode; mantenha a versão explícita, porque a documentação avisa que o eksctl usa por padrão uma mais antiga.
O console também funciona. Na execução de operações eu criei o mesmo cluster com Create cluster > Custom configuration: remova o general-purpose dos node pools embutidos para sobrar só o system, e repare que a etapa de add-ons já vem com o add-on de comunidade Metrics Server selecionado. Eu desmarquei esse add-on na criação, para que o node de sandbox fosse o único node, e adicionei depois. O cluster ficou Active cerca de 12 minutos depois do Create, e quem criou o cluster, a minha role do console, virou admin dele; o meu usuário do CLI precisou de um access entry com AmazonEKSClusterAdminPolicy.
Passo 3: As RuntimeClasses, antes de qualquer node
No cluster novo, ainda com zero nodes, o kubectl get runtimeclass já listava confidential-sandbox e isolated-sandbox:
NAME HANDLER AGE
confidential-sandbox confidential-sandbox 2m57s
isolated-sandbox isolated-sandbox 2m57s
Essa é a execução gravada; na primeira, elas tinham uns quatro minutos de idade. O guia do usuário não publica os objetos do Auto Mode, então aqui está a isolada, idêntica nas duas execuções:
kubectl get runtimeclass isolated-sandbox -o yaml
apiVersion: node.k8s.io/v1
handler: isolated-sandbox
kind: RuntimeClass
metadata:
name: isolated-sandbox
overhead:
podFixed:
eks.amazonaws.com/nitro-sandbox: "1"
memory: 256Mi
scheduling:
nodeSelector:
eks.amazonaws.com/nitro-sandbox: "true"
A confidential-sandbox é igual, com memory: 512Mi. As duas batem com o que a página da AMI publica para nodes autogerenciados. O overhead é como o scheduler paga pela VM: todo pod com esta RuntimeClass recebe 256Mi (ou 512Mi) e um eks.amazonaws.com/nitro-sandbox somados aos seus requests.
A NodeClass padrão também não tem nenhum campo de sandbox: ephemeralStorage 80Gi, networkPolicy: DefaultAllow, snatPolicy: Random.
Passo 4: Um NodePool Graviton, limitado a um node
Nenhuma página da AWS tem um NodePool de sandbox, então eu escrevi um comum a partir do exemplo documentado, limitado a m8g.xlarge on-demand:
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
name: sandbox-m8g
spec:
template:
spec:
nodeClassRef:
group: eks.amazonaws.com
kind: NodeClass
name: default
requirements:
- key: node.kubernetes.io/instance-type
operator: In
values: ["m8g.xlarge"]
- key: karpenter.sh/capacity-type
operator: In
values: ["on-demand"]
limits:
cpu: "4" # one m8g.xlarge, never two
kubectl apply -f nodepool.yaml
Não há nenhum requisito de sandbox nele, e ele não precisou de nenhum: quando um pod de sandbox ficou pendente, o Auto Mode lançou uma m8g.xlarge com o label e a capacidade de sandbox (Teste 1). O limits.cpu: "4" se manteve nas duas execuções. Os pods além do que um node comportava ficaram em Pending com all available instance types exceed limits for nodepool, em vez de comprar uma segunda instância como o ECS fez na parte 3.
Passo 5: A mudança de uma linha
O pod de teste é o exemplo da documentação com um probe e um nodeSelector no label node.kubernetes.io/instance-type do Auto Mode, que o mantém no pool Graviton:
apiVersion: v1
kind: Pod
metadata:
name: hello-sandbox
spec:
runtimeClassName: isolated-sandbox # the one-line change
nodeSelector:
node.kubernetes.io/instance-type: m8g.xlarge
containers:
- name: probe
image: public.ecr.aws/amazonlinux/amazonlinux:2023
command: ["bash", "-c"]
args:
- |
echo "kernel: $(uname -rv)" # the full probe is in the block below
sleep infinity
resources:
requests: {cpu: 500m, memory: 512Mi}
limits: {cpu: "1", memory: 1Gi}
O pod comum, hello-plain, é o mesmo arquivo sem a linha do runtimeClassName.
O probe que os dois pods rodam
echo "kernel: $(uname -rv)"; echo "boot_id: $(cat /proc/sys/kernel/random/boot_id)"; echo "uptime: $(cut -d' ' -f1 /proc/uptime)"; echo "nproc: $(nproc)"; grep MemTotal /proc/meminfo; echo "disks: $(ls /sys/block | tr '\n' ' ')"; ls -la /dev/nsm 2>&1 | head -1
echo "pci: $(for d in /sys/bus/pci/devices/*; do printf '%s ' $(cat $d/vendor):$(cat $d/device); done | tr ' ' '\n' | sort | uniq -c | tr '\n' ' ')"
T=$(curl -s -m3 -X PUT http://169.254.169.254/latest/api/token -H 'X-aws-ec2-metadata-token-ttl-seconds: 60'); echo "imdsv2 token: ${#T} chars"
for p in placement/region placement/availability-zone instance-id iam/security-credentials/; do echo "imds $p: $(curl -s -m3 -w ' [HTTP %{http_code}]' -H "X-aws-ec2-metadata-token: $T" http://169.254.169.254/latest/meta-data/$p | tr '\n' ' ' | head -c 120)"; done
echo "sa token: $(ls /var/run/secrets/kubernetes.io/serviceaccount/token 2>&1)"
echo "procs: $(ls /proc | grep -c '^[0-9]')"
Num Deployment, o runtimeClassName vai em spec.template.spec (o Teste 5 tem um). As annotations de sandbox vão em spec.template.metadata; a página de configuração avisa que uma annotation no metadata do próprio controller “é aceita e depois ignorada”.
Testes
Teste 1: O primeiro pod, e o node que ele traz
Eu apliquei o hello-sandbox no cluster sem nodes e esperei por ele:
kubectl apply -f pod-sandbox.yaml && kubectl wait pod/hello-sandbox --for=condition=Ready --timeout=600s
Na execução gravada, o pod ficou Ready 50 segundos depois do kubectl apply, incluindo o lançamento do node, que tinha 14 segundos de idade quando eu o listei:
NAME STATUS ROLES AGE VERSION INSTANCE-TYPE NITRO-SANDBOX
i-056659827b67f2792 Ready <none> 14s v1.37.0-eks-29d7970 m8g.xlarge true
Na primeira execução, levou 85 segundos. Os eventos desse pod:
| Horário (UTC) | Evento |
|---|---|
| 00:29:16 | Criado; FailedScheduling, sem nodes |
| 00:30:11 | Nominated para nodeclaim/sandbox-m8g-… |
| 00:30:39 | Pulled, em 1,466 s |
| 00:30:41 | Started |
Para comparar, a primeira task isolada no ECS, na parte 3, estava rodando uns 34 segundos depois da criação, incluindo a instância dela.
O kubectl describe node no node que o Auto Mode lançou na primeira execução (o node da execução gravada também não tinha taints e tinha 20 eks.amazonaws.com/nitro-sandbox allocatable):
| Recurso | Capacity | Allocatable |
|---|---|---|
cpu | 4 | 3770m |
memory | 16048204Ki | 13513Mi |
eks.amazonaws.com/nitro-sandbox | 20 | 20 |
O kubelet dele era v1.37.0-eks-29d7970, os labels incluíam eks.amazonaws.com/nitro-sandbox=true e kubernetes.io/arch=arm64, ele tinha capacidade para 56 pods e não tinha taints. Vinte é cinco vezes o número de vCPUs do node, o mesmo limite por instância que eu encontrei no EC2 na parte 2 (pcie_slots_total); o Teste 5 preenche esse limite.
Na consolidação, o Auto Mode trata um node de sandbox como qualquer outro. Depois que eu apaguei os pods de sandbox, deixando no máximo um pod comum, ele substituiu o node, duas vezes na primeira execução: i-023f6942008372e7d, depois i-054c09a2cf3dca87f, depois i-0956c7c6b4bd96b04. Na execução gravada ele fez o mesmo entre os passos: o i-056659827b67f2792 do Teste 1 já não existia no Teste 5, que rodou no i-08330145d8695dd72. Na execução de operações, um NodePool com disruption: {consolidationPolicy: WhenEmpty, consolidateAfter: 5m} manteve o node durante toda a sessão, de 22 a 32 minutos, mas pods de add-ons também rodavam nele, então ele nunca ficou vazio.
Teste 2: Um pod de sandbox e um pod comum no mesmo node
Mesma imagem, mesmo probe, mesmos requests (500m, 512Mi) e limits (1 CPU, 1Gi), mesmo node. A única diferença é o runtimeClassName: isolated-sandbox. A execução gravada imprimiu o kernel, o uptime, a CPU, a memória, o disco, o NSM e duas linhas de metadata, e todas bateram com a primeira execução, exceto os uptimes; as outras linhas são da primeira execução.
isolated-sandbox | Comum | |
|---|---|---|
| Kernel | 6.18.54 #1 SMP Thu Oct 22 17:48:46 UTC 2026 | 6.18.56 #2 SMP Fri Oct 30 22:32:43 UTC 2026 (o do node) |
| Uptime no probe | 5,43 s (primeira execução: 5,33 s) | 28,12 s (primeira execução: 37,97 s), o do node, recém-iniciado |
nproc | 1 | 4 |
| MemTotal | 666.384 kB | 16.048.204 kB |
| Discos | dm-0 vda vdb vdc | dm-0 loop0-7 nvme0n1 nvme1n1 zram0 |
| PCI | 42 bridges da Amazon, 1af4:1041 (rede), três 1af4:1042 (bloco), 1af4:1053 (vsock), 1af4:1061 (NSM), 1d0f:8250 | 1af4:1053, dois NVMe da Amazon 1d0f:8061, ENA 1d0f:ec20, 1d0f:e4c1 |
/dev/nsm | presente (crw-rw-rw-, 10, 258) | ausente |
| Token IMDSv2 | 48 caracteres | nenhum |
IMDS placement/region | us-east-1 (HTTP 200) | HTTP 401 |
IMDS placement/availability-zone | us-east-1a (HTTP 200) | HTTP 401 |
IMDS instance-id | Not Found (HTTP 404) | HTTP 401 |
IMDS iam/security-credentials/ | Not Found (HTTP 404) | HTTP 401 |
| Token da service account | presente | presente |
spec.overhead do pod | {"eks.amazonaws.com/nitro-sandbox":"1","memory":"256Mi"} | nenhum |
O pod em sandbox é uma máquina separada, dimensionada para o pod. No arm64, o kernel dele nem sequer é da mesma versão que o do node: 6.18.54 contra 6.18.56. Os exemplos x86 da AWS mostram versões iguais com builds diferentes, então não use só o uname -r como evidência; a string de build, o uptime e os discos virtio são os sinais confiáveis. Ele enxerga uma CPU, o request de 500m arredondado para cima, e 666.384 kB de memória, dimensionada a partir do request de 512Mi; o limit de 1Gi não tem papel nenhum. O pod comum enxerga o node: o kernel dele, as quatro CPUs, os 16 GiB inteiros e os discos NVMe, não importa o que digam os limits do cgroup. O admission controller acrescentou o overhead da RuntimeClass à spec do pod em sandbox e nada à do pod comum.
A vCPU não é reservada. Nas palavras da página de visão geral, “um sandbox não recebe cores físicos dedicados. As vCPUs são compartilhadas no tempo”, e o tamanho da VM é fixado no boot, então o resize in-place não é suportado.
O dispositivo NSM está lá no modo isolado, como estava no ECS na parte 3. No EC2, na parte 2, um sandbox no modo direto não tinha NSM e um no modo confidencial tinha, então o isolated-sandbox parece rodar, por baixo, sobre o modo de memória confidencial do EC2. Essa é uma inferência minha a partir da lista de dispositivos; nenhuma página do EKS relaciona os dois.
Duas linhas divergem da documentação ou do ECS:
- O substituto de metadata respondeu, como documentado. A página de credenciais descreve um substituto só IMDSv2 em
169.254.169.254que atende cinco paths de placement e de serviço e retorna 404 para todo o resto. Foi o que eu obtive: um token, a Região e a Zona de Disponibilidade, e 404 para o ID da instância e para as credenciais. No ECS, na parte 3, a task isolada não recebeu resposta nenhuma. O pod comum não recebeu token, e toda request sem token voltou com 401, o que bate com o “Acesso restrito ao metadata da instância usando IMDSv2 com hop limits controlados” do Auto Mode, descrito no guia de segurança do Auto Mode. Nenhum dos dois pods conseguiu alcançar as credenciais do node. - O token da service account foi montado. Para o modo isolado, a página de visão geral, revisada desde o lançamento, ainda diz “O token da service account não é replicado para dentro do sandbox.” Num pod isolado sem policy, o
/var/run/secrets/kubernetes.io/serviceaccount/tokenestava lá. Se você contava com essa frase para manter uma credencial da API do Kubernetes longe de uma imagem não confiável, desligue você mesmo o automount do token na pod spec, e confira.
Teste 3: Latência de inicialização num node já aquecido
Com o node no ar e a imagem em cache, eu criei pods um de cada vez (alternando entre pod em sandbox e pod comum na execução gravada) e medi o tempo do kubectl apply até o retorno do kubectl wait --for=condition=Ready:
| Pod | Execução gravada | Primeira execução |
|---|---|---|
isolated-sandbox | 5,32 s, 4,69 s | 5,37 s, 4,38 s, 4,44 s |
| Comum | 1,97 s, 1,69 s | 2,14 s, 1,73 s; um terceiro ficou Pending: o node estava sem CPU, e o limite do NodePool se manteve |
O sandbox acrescenta uns três segundos à inicialização de um pod, nas duas execuções. Os blueprints da AWS citam “cerca de 5 a 6 segundos” para um novo pod de sandbox quando o node já existe, então os meus números estão do lado mais rápido disso. Para ter uma escala, na parte 2 um sandbox puro no EC2 fez o boot até o SSH em uns dois segundos; o resto é o agente, a imagem e a inicialização do container dentro do guest.
Teste 4: Configurações de nível de host dentro de um sandbox
Eu apliquei três variantes do pod de probe isolado: uma com hostNetwork: true, uma com hostPID: true e uma com a annotation de isolamento de rede da página de isolamento de rede:
metadata:
name: sandbox-network-isolated
annotations:
sandbox.amazonaws.com/network-isolated: "true"
spec:
runtimeClassName: isolated-sandbox
| Variante | Resultado |
|---|---|
hostNetwork: true | Agendado, depois preso em ContainerCreating, com FailedCreatePodSandBox se repetindo. Não foi rejeitado na admissão |
hostPID: true | Roda. O PID 1 é o systemd (/sbin/init), e 167 processos ficam visíveis (170 na primeira execução): os da VM do sandbox, não os do node |
sandbox.amazonaws.com/network-isolated: "true" | Dispositivos de rede lo e dummy0, nenhuma rota, curl: (6) Could not resolve host, IMDS inalcançável (HTTP 000) |
kubectl exec num pod isolado | Funciona (uname -r retorna 6.18.54) |
Os quatro se repetiram na execução gravada (o kubectl exec isolado está no Teste 7). Dois deles, dessa execução:
$ kubectl exec sandbox-hostpid -- bash -c 'echo pid1: $(cat /proc/1/comm), processes: $(ls /proc | grep -c ^[0-9])'
pid1: systemd, processes: 167
$ kubectl exec sandbox-network-isolated -- bash -c '...; curl -sS -m 5 https://aws.amazon.com 2>&1 | head -1'
interfaces: lo dummy0
curl: (6) Could not resolve host: aws.amazon.com
O evento do pod com hostNetwork diz exatamente o que está errado:
FailedCreatePodSandBox: ... cri-proxy: hostNetwork is not supported for nitro-sandbox pods; remove `hostNetwork: true` from the pod spec
A página de considerações lista o hostNetwork como não suportado, então a recusa não é surpresa; o lugar onde ela acontece, sim. O API server aceita o pod, o scheduler o posiciona, e ele fica tentando de novo para sempre em ContainerCreating em vez de falhar. No ECS, na parte 3, a mesma ideia, networkMode: host, foi rejeitada quando eu registrei a task definition. Se você quer a recusa logo na porta no EKS, isso é uma admission policy que você mesmo escreve. Dentro do guest a questão nem se coloca: todo container compartilha a stack de rede da VM, e o gerador de policy no Teste 6 até fixa host_network == true com o comentário “the VM owns the network stack, so no network namespace exists in the OCI spec.”
O hostPID se comporta como o pidMode: host do ECS, que mostrou 172 processos na parte 3: o “host” é a VM do sandbox, e o systemd no PID 1 é o init do próprio guest. Nada do node fica visível.
O isolamento de rede é real, com a ressalva que a documentação deixa explícita: o pod não tem interface de rede, DNS, NTP, IMDS nem Pod Identity, mas logs e exec continuam funcionando por vsock, e o canal vsock continua alcançável a partir da instância pai, “então este não é um isolamento absoluto”.
O outro lado de tudo isso está no modelo de segurança: a feature foi feita para imagens não confiáveis, não para pod specs não confiáveis. “Trate a submissão de pod specs como uma operação privilegiada.”
Teste 5: Quantos pods de sandbox cabem num node
Todo pod de sandbox pede um eks.amazonaws.com/nitro-sandbox através do overhead da sua RuntimeClass, e o node anunciava 20. Eu enchi o node com um Deployment de 22 replicas que não fazem nada:
apiVersion: apps/v1
kind: Deployment
metadata:
name: density
spec:
replicas: 22
selector:
matchLabels: {app: density}
template:
metadata:
labels: {app: density}
spec:
runtimeClassName: isolated-sandbox
nodeSelector:
node.kubernetes.io/instance-type: m8g.xlarge
containers:
- name: app
image: public.ecr.aws/amazonlinux/amazonlinux:2023
command: ["sleep", "infinity"]
resources:
requests: {cpu: 50m, memory: 64Mi}
kubectl apply -f density.yaml
kubectl get pods -l app=density --no-headers | awk '{print $3}' | sort | uniq -c
kubectl describe node <node-name> | grep nitro-sandbox
O vídeo mostra a execução gravada, contando os estados dos pods mais ou menos a cada 13 segundos:
t= 14s running 0 creating 0 pending 22 rejected 0
t= 27s running 0 creating 19 pending 3 rejected 0
t= 40s running 16 creating 3 pending 3 rejected 0
t= 54s running 19 creating 0 pending 3 rejected 0
t= 67s running 19 creating 0 pending 3 rejected 0
...
t=162s running 19 creating 0 pending 3 rejected 0
A partir dos 54 segundos, ficou estável em 19 rodando e 3 pendentes, e os pods pendentes diziam por quê:
0/1 nodes are available: 1 Insufficient eks.amazonaws.com/nitro-sandbox
O node continuava reportando 20 allocatable. Eu rodei o mesmo teste cinco vezes no total:
| Execução | Ponto de partida | Requests | Resultado |
|---|---|---|---|
| Primeira execução, A | O node já tinha rodado e apagado seis pods de sandbox; um outro pod de sandbox estava rodando | 100m, 128Mi | 13 pods de densidade rodaram, 14 pods de sandbox no total. O resto ficou em Pending com Insufficient eks.amazonaws.com/nitro-sandbox, enquanto o kubectl describe node mostrava 14 de 20 alocados. Os 13 levaram 257 s para chegar a Running |
| Primeira execução, B | Um node novo | 50m, 64Mi | 18 Running em cerca de 66 s, 2 Failed, 4 Pending |
| Primeira execução, C | Um node cujos três pods de sandbox eu tinha apagado uns três minutos antes | 50m, 64Mi | 20 Running, 2 Pending, depois de 100 s |
| Gravada, fora da câmera | Um node com rotatividade recente de sandboxes, depois de uns três minutos de calmaria | 50m, 64Mi | 18 Running, 4 Pending |
| Gravada, na câmera | Logo depois da execução fora da câmera, no i-08330145d8695dd72 | 50m, 64Mi | 19 Running, 3 Pending, estável dos 54 s aos 162 s |
Na primeira execução, B, as duas falhas foram rejeitadas pelo kubelet depois que o scheduler já tinha posicionado os pods:
OutOfeks.amazonaws.com/nitro-sandbox: Pod was rejected: Node didn't have enough resource: eks.amazonaws.com/nitro-sandbox, requested: 1, used: 20, capacity: 20
O teto é de 20 pods de sandbox por m8g.xlarge (5 × as suas 4 vCPUs): o node anunciou 20 todas as vezes, a rejeição do kubelet diz capacity: 20, e a primeira execução, C, conseguiu todos. Cada pod de densidade ainda enxergava uma CPU (nproc 1, MemTotal: 280848 kB), então 20 sandboxes também são 20 vCPUs, cinco vezes as quatro do node. A documentação limita tanto a quantidade quanto o total de vCPUs a cinco vezes as vCPUs do node, e com sandboxes de 1 vCPU os dois limites caem no mesmo número, então esta execução não consegue distinguir um do outro. No EC2, na parte 2, onde eu podia dar 4 vCPUs a cada sandbox, o limite que pesava era o da quantidade.
O que eu não esperava é que não daria para contar com os 20. Com o mesmo Deployment de 50m / 64Mi, as quatro execuções conseguiram 18, 20, 18 e 19. Mais duas observações da primeira execução:
- Na execução A, o scheduler reportou
Insufficient eks.amazonaws.com/nitro-sandboxpara os pods restantes enquanto okubectl describe nodemostrava só 14 de 20 alocados. Quando eu apaguei mais um pod de densidade que estava rodando, o substituto dele também não foi agendado, com 13 de 20 alocados. - Na execução B, eu apaguei três pods que estavam rodando; os substitutos ainda não tinham rodado 60 segundos depois, o que deixou 15. E mesmo naquele node novo, a rajada teve dois pods rejeitados pelo kubelet por excesso de capacidade enquanto só 18 estavam rodando.
Depois da primeira execução, eu interpretei isso como slots liberados voltando depois de um atraso, porque a execução C, depois de alguns minutos de calmaria, conseguiu os 20. A execução gravada não sustenta essa leitura: depois de uns três minutos de calmaria, a execução fora da câmera conseguiu 18, e a logo seguinte, 19. Eu não descobri qual componente segurava os slots que faltavam nem por que o número variava, então tudo o que eu posso relatar é o que vi: o node anuncia 20, eu consegui de 18 a 20 com o mesmo Deployment, e menos logo depois de remoções. O efeito prático, para runners de CI ou sessões de agentes que vêm e vão, é não planejar com os 20, ficar de olho em pods Pending com Insufficient eks.amazonaws.com/nitro-sandbox e esperar um pod Failed de vez em quando numa rajada.
Teste 6: Um pod confidencial, de ponta a ponta
Um pod confidencial precisa de uma Cedar policy na sua annotation sandbox.amazonaws.com/policy, gerada a partir do manifest dele pelo eks-nitro-sandbox-genpolicy. O agente do guest aplica essa policy e a mede no PCR17, e uma key policy do KMS pode exigir esse PCR17. No EKS, o pod recebe as credenciais da AWS via Pod Identity.
Identidade. Uma role IAM que o Pod Identity consegue assumir, uma service account e uma associação entre as duas. O Auto Mode não precisou do add-on Pod Identity Agent.
{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"pods.eks.amazonaws.com"},"Action":["sts:AssumeRole","sts:TagSession"]}]}
aws iam create-role --role-name my2cents-nitro-eks-attest --assume-role-policy-document file://pod-trust.json
kubectl apply -f sa.yaml # ServiceAccount attest in namespace default
aws eks create-pod-identity-association --cluster-name my2cents-nitro-eks \
--namespace default --service-account attest \
--role-arn arn:aws:iam::<ACCOUNT_ID>:role/my2cents-nitro-eks-attest
O segredo. Uma chave nova do KMS, uma por execução, cuja policy no início tinha só um statement de administração da conta. Eu criptografei o segredo na minha máquina e coloquei o ciphertext no ambiente do pod como SECRET_CT:
KEY_ID=$(aws kms create-key --policy file://kms-eks-admin.json --query KeyMetadata.KeyId --output text) # only the AccountAdmin statement shown below
printf '%s' 'eks: only a measured pod can read this' > secret.txt
SECRET_CT=$(aws kms encrypt --key-id "$KEY_ID" --plaintext fileb://secret.txt --query CiphertextBlob --output text)
O workload é o mesmo do ECS na parte 3. O container (amazonlinux:2023) instala openssl, awscli-2 e python3, grava o cliente NSM só com stdlib da parte 2 (nsm.py) a partir de uma variável de ambiente, gera um par de chaves RSA, obtém um documento de atestação de /dev/nsm, imprime os PCRs, pede ao KMS para descriptografar o segredo para esse documento com as credenciais do Pod Identity e abre a resposta dentro do sandbox. Desenrolado, sem o tratamento de erros:
dnf install -y -q openssl awscli-2 python3
echo "$NSM_PY_B64" | base64 -d > /tmp/nsm.py; cd /tmp
openssl genrsa -out key.pem 2048 && openssl rsa -in key.pem -pubout -outform DER -out pub.der
python3 nsm.py attest pub.der att.doc && python3 nsm.py pcrs att.doc | grep -E "module_id|PCR0:|PCR8:|PCR17:"
echo "$SECRET_CT" | base64 -d > ct.bin
aws kms decrypt --region us-east-1 --ciphertext-blob fileb://ct.bin \
--recipient "KeyEncryptionAlgorithm=RSAES_OAEP_SHA_256,AttestationDocument=$(base64 -w0 att.doc)" \
--query CiphertextForRecipient --output text | base64 -d > cfr.der
echo "SECRET: $(openssl cms -decrypt -inform DER -in cfr.der -inkey key.pem)"
O par de chaves fica em /tmp, na camada gravável do container. Isso é aceitável aqui porque o overlay de um sandbox confidencial é criptografado (a policy gerada abaixo exige isso), enquanto para o modo isolado a documentação diz “O filesystem overlay não é criptografado, para permitir uma inicialização mais rápida do pod.” A parte 2 explica por que essa distinção importa.
O manifest, como rodou, sem dois valores longos em base64:
{
"apiVersion": "v1",
"kind": "Pod",
"metadata": { "name": "attest-confidential", "namespace": "default" },
"spec": {
"serviceAccountName": "attest",
"runtimeClassName": "confidential-sandbox",
"nodeSelector": { "node.kubernetes.io/instance-type": "m8g.xlarge" },
"containers": [
{
"name": "attest",
"image": "public.ecr.aws/amazonlinux/amazonlinux:2023",
"command": ["bash", "-c", "dnf install -y -q openssl awscli-2 python3 >/dev/null 2>&1; ... echo ATTEST_DONE; sleep 3600"],
"env": [
{ "name": "NSM_PY_B64", "value": "<...>" },
{ "name": "SECRET_CT", "value": "<...>" },
{ "name": "AWS_REGION", "value": "us-east-1" },
{ "name": "AWS_DEFAULT_REGION", "value": "us-east-1" }
],
"resources": {
"requests": { "cpu": "500m", "memory": "512Mi" },
"limits": { "cpu": "1", "memory": "1Gi" }
}
}
],
"enableServiceLinks": false
}
}
Três detalhes nele vêm de pegadinhas. O comando é uma única linha, unida com ; : no ECS, na parte 3, o gerador rejeitou um comando de várias linhas, e assim eu nunca esbarrei nisso. Tanto AWS_REGION quanto AWS_DEFAULT_REGION estão definidas, seguindo os blueprints da AWS: se só AWS_REGION estiver definida, o webhook do Pod Identity deixa AWS_DEFAULT_REGION de fora, a policy ainda espera por ela, e o guest recusa o container. Eu defini as duas desde o início, então não testei essa falha. E o enableServiceLinks: false, que eu aprendi do jeito difícil, mais abaixo.
Gerando a policy, no cluster. A AWS distribui o eks-nitro-sandbox-genpolicy só para Linux (x86_64 e aarch64, glibc 2.34 ou mais novo). Como no ECS, eu rodei o gerador no cluster em vez de procurar uma máquina Linux: um pod comum no node arm64 baixa a release assinada do runtime, verifica a release com a chave pública impressa na página de download e gera a policy a partir do manifest, que ele lê de um ConfigMap.
m8g.xlarge que depois hospedou o pod confidencial, e a saída dele voltou por kubectl logs, que é servido pelo kubelet desse node. Um node comprometido poderia devolver uma policy permissiva junto com o PCR17 correspondente, e você colaria esse PCR17 direto na key policy. A página de configuração do modo confidencial diz para colocar a regeneração "no pipeline de CI/CD que produz os seus manifests de pod", e o modelo de segurança diz "A pod spec e a Cedar policy gerada a partir dela são entradas confiáveis". Em produção, gere a policy lá ou numa estação de trabalho ou container Linux (glibc 2.34 ou mais novo), fixe uma release na URL de download em vez de latest e revise a policy antes de confiar no PCR17 dela.
kubectl create configmap confidential-manifest --from-file=manifest.json=pod-confidential-nopolicy.json
kubectl apply -f pod-genpolicy.yaml
kubectl logs genpolicy
apiVersion: v1
kind: Pod
metadata:
name: genpolicy
spec:
nodeSelector:
node.kubernetes.io/instance-type: m8g.xlarge
restartPolicy: Never
containers:
- name: genpolicy
image: public.ecr.aws/amazonlinux/amazonlinux:2023
command: ["bash", "-c"]
args:
- |
dnf install -y -q tar gzip openssl findutils >/dev/null 2>&1; cd /tmp
U=https://d1uvmbvklg8rt.cloudfront.net/latest/aarch64
curl -fsSLO $U/nitro-sandboxes-runtime.tar.gz && curl -fsSLO $U/SHA256SUM && curl -fsSLO $U/SHA256SUM.sig
cat > nitro-sandboxes-runtime-v1.pub <<'PEM'
-----BEGIN PUBLIC KEY-----
MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAESqdVXO82n+Zh5+IFLh1xjmxZLkjjZWvf
DCS927SdVYjP0AZ92XCxS+ucrs9cjuNlTaDARTHov2XVfMVgau8TEPFKGDRmVZXJ
c25CVihKHLFK8T8hNMIL+fbGcvE2fwIO
-----END PUBLIC KEY-----
PEM
openssl dgst -sha384 -verify nitro-sandboxes-runtime-v1.pub -signature SHA256SUM.sig SHA256SUM && sha256sum -c SHA256SUM --ignore-missing
tar -xzf nitro-sandboxes-runtime.tar.gz 2>/dev/null; GP=$(find /tmp -name eks-nitro-sandbox-genpolicy -type f | head -1); chmod +x $GP; $GP --version 2>&1 | head -1
$GP --profile confidential --with-pod-identity --image-architecture arm64 /work/manifest.json > policy.b64 2> gp.err; echo "exit=$? bytes=$(wc -c < policy.b64)"; cat gp.err | tail -15
echo POLICY_BEGIN; fold -w 4000 policy.b64; echo; echo POLICY_END
sleep infinity
resources:
requests: {cpu: 500m, memory: 512Mi}
volumeMounts:
- {name: manifest, mountPath: /work}
volumes:
- name: manifest
configMap:
name: confidential-manifest
O --with-pod-identity importa: sem ele, segundo a documentação, o arquivo de token de que o Pod Identity precisa não existe num pod que carrega uma policy. O --image-architecture arm64 corresponde ao node.
A minha primeira tentativa, na execução exploratória e antes de eu acrescentar enableServiceLinks: false, falhou:
error: policy generation failed: manifest does not set enableServiceLinks: false. Kubelet will inject unpredictable service discovery env vars that break exact env matching.
A ferramenta ofereceu três saídas: definir enableServiceLinks: false, passar --allow-additional-env ou usar um profile com pin_env: false. As duas últimas afrouxam o que a policy fixa, então eu fiquei com a primeira. Com ela, o pod gerador da execução gravada imprimiu:
Verified OK
nitro-sandboxes-runtime.tar.gz: OK
eks-nitro-sandbox-genpolicy 0.1.4274.0
exit=0 bytes=28151
info: fetching image configs from the registry to resolve pin_image, pin_working_dir, pin_identity, pin_args, pin_env (pulling layers for pin_identity)
info: fetching image config for public.ecr.aws/amazonlinux/amazonlinux:2023
O que a policy diz. Diferente do ECS, onde eu rodei a ferramenta duas vezes e decodifiquei o gzip eu mesmo, uma execução imprimiu tudo no stdout: 28.151 bytes (28.155 na primeira execução) em cinco seções, --- Admission Policy --- e --- Runtime Policy --- como Cedar legível, --- Base64 Encoded Policy Envelope --- (8.240 caracteres, o valor da annotation; 8.244 na primeira execução), --- Predicted PCR17 --- e --- KMS Key Policy Condition ---. Fora o ciphertext em SECRET_CT, o Cedar legível foi o mesmo nas duas execuções.
- Admission tem um permit para o container
attest. Ele fixa o digest da imagem (amazonlinux@sha256:5e98730d…), o diretório de trabalho,run_as_user 0,run_as_group 0, os IDs de grupo extras,read_only_rootfs, a lista efetiva de capabilities, todo mount (incluindo os tokens da service account e do Pod Identity), o hostname, o comando exato, todo valor de ambiente declarado, além da lista exata de nomes de variáveis, incluindo as que o kubelet e o webhook do Pod Identity acrescentam. As oito variáveis de serviçoKUBERNETES_*são fixadas só pelo nome, e aAWS_CONTAINER_CREDENTIALS_FULL_URIa um de dois endpoints, IPv4 ou IPv6. Umforbidespecífico do EKS recusa a annotation de exec do ECS. - Dicas HARDEN ficam no topo como comentários, uma por configuração que eu poderia apertar na pod spec, por exemplo “set securityContext.readOnlyRootFilesystem: true to enforce read-only root filesystem in the policy”. O meu pod rodou como root com as capabilities padrão, e as dicas dizem isso.
- Runtime não tem permit para exec nem stdin (“Blocks: kubectl exec, kubectl cp”), nega
SetupVolumeporque não há volumes CSI, e permite logs, stats, eventos de OOM e escrita de arquivos em/etc/hosts, no termination log e nos dois volumes de token. O permit deSetupSandboxfixa o hostname e exige o overlay criptografadointegrity-memory.
A policy gerada, resumida
--- Admission Policy ---
// Container: attest
// HARDEN: set securityContext.readOnlyRootFilesystem: true to enforce read-only root filesystem in the policy
// HARDEN: set securityContext.allowPrivilegeEscalation: false to enforce no_new_privileges in the policy
// HARDEN: set securityContext.runAsNonRoot: true to enforce a non-root user in the policy
// HARDEN: set securityContext.capabilities.drop: ["ALL"] to restrict capabilities in the policy
permit(
principal,
action == Agent::Action::"CreateContainer",
resource == Workload::Container::"attest"
)
when {
context.image_ref == "public.ecr.aws/amazonlinux/amazonlinux@sha256:5e98730d73190367a4d29c086f2ed2911cc5867eff5aa8b2a19cbb884e9d601f" &&
context.working_dir == "/" &&
context.run_as_user == 0 &&
context.run_as_group == 0 &&
context.additional_gids == [0] &&
context.read_only_rootfs == false &&
// … effective, bounding and permitted capabilities: the 14 container defaults
// … masked and read-only paths, and every mount, including
// /var/run/secrets/kubernetes.io/serviceaccount and
// /var/run/secrets/pods.eks.amazonaws.com/serviceaccount
context.hostname == "attest-confidential" &&
// … OS flags, hooks, devices, seccomp, SELinux and AppArmor fields
context.process_args == "[\"bash\",\"-c\",\"dnf install -y -q openssl awscli-2 python3 …\"]" &&
// Guest networking: the VM owns the network stack, so no network namespace
// exists in the OCI spec. The pod hostNetwork setting has no effect.
context.host_network == true &&
context.host_pid == false &&
context.host_ipc == false &&
context.shared_pid == false &&
context.linux_namespace_types == ["pid", "ipc", "uts", "mnt", "cgroup"] &&
context.sysctls.isEmpty() &&
context.env.containsAll([
{"name": "PATH",
"value": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
{"name": "NSM_PY_B64", "value": "<...>"},
{"name": "SECRET_CT", "value": "<...>"},
{"name": "AWS_REGION", "value": "us-east-1"},
{"name": "AWS_DEFAULT_REGION", "value": "us-east-1"},
{"name": "AWS_STS_REGIONAL_ENDPOINTS",
"value": "regional"},
{"name": "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
"value": "/var/run/secrets/pods.eks.amazonaws.com/serviceaccount/eks-pod-identity-token"}]) &&
context.env_names == ["PATH", "NSM_PY_B64", "SECRET_CT", "AWS_REGION",
"AWS_DEFAULT_REGION", "AWS_STS_REGIONAL_ENDPOINTS",
"AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
"KUBERNETES_SERVICE_HOST", "KUBERNETES_SERVICE_PORT",
"KUBERNETES_SERVICE_PORT_HTTPS", "KUBERNETES_PORT",
"KUBERNETES_PORT_443_TCP",
"KUBERNETES_PORT_443_TCP_PROTO",
"KUBERNETES_PORT_443_TCP_PORT",
"KUBERNETES_PORT_443_TCP_ADDR",
"AWS_CONTAINER_CREDENTIALS_FULL_URI"] &&
(context.env.contains({"name": "AWS_CONTAINER_CREDENTIALS_FULL_URI", "value": "http://169.254.170.23/v1/credentials"}) ||
context.env.contains({"name": "AWS_CONTAINER_CREDENTIALS_FULL_URI", "value": "http://[fd00:ec2::23]/v1/credentials"}))
};
// Admission: the ECS execute-command annotation (sandbox.amazonaws.com/ecs-exec-enabled) is
// forbidden on EKS. It drives SSM binary mount injection in the
// guest agent, which EKS never uses.
forbid(
principal,
action == Agent::Action::"CreateContainer",
resource
)
when {
context.ecs_exec_enabled
};
// PrepareImage: public.ecr.aws/amazonlinux/amazonlinux@sha256:5e98730d73190367a4d29c086f2ed2911cc5867eff5aa8b2a19cbb884e9d601f
// … one permit pinning the same digest
// Admission: host image mounting is disabled (no permit policy)
--- Runtime Policy ---
// Runtime: stdin writes are denied (no permit policy)
// Blocks: kubectl attach -i, kubectl exec -i, kubectl cp (to pod)
// Runtime: exec is denied (no permit policy)
// Blocks: kubectl exec, kubectl cp
// Runtime: SetupVolume is denied (no CSI volumes)
// … permits for ReadLogs, ReadTerminationLog, Stats, InitGuestMetadata,
// UpdateGuestMetadata, and WriteFile to /etc/hosts, the termination log
// and the two projected token volumes
// Runtime: allow sandbox setup
permit(
principal,
action == Agent::Action::"SetupSandbox",
resource
)
when {
context.sysctls.isEmpty() &&
context.fsgroup == -1 &&
context.host_entries.isEmpty() &&
context.deny_all_egress == false &&
context.hostname == "attest-confidential" &&
// the ephemeral overlay must use the required encryption mode
context.ephemeral_layer == Workload::EphemeralLayer::"integrity-memory" &&
// the agent creates exactly the pod's mounted emptyDir volumes
context.volume_paths.isEmpty()
};
// … permits for WatchOomEvents, RemoveContainer, StreamAgentLogs,
// and CreateTask with no binary logger
--- Base64 Encoded Policy Envelope ---
H4sIAAAAAAAC/+08aXfiSJJ/Res3r8c1XZjL2Iaa6rfcyBiwuaHdq6cjkdLo… (8,240 characters)
--- Predicted PCR17 ---
5ccb2d706da3b61f6ecbb85799cc24c54fddc841b2b259d0a67f732dc9ace02212cba02e6a3ad441c284eb4b1da3b5da
--- KMS Key Policy Condition ---
"Condition": {
"StringEqualsIgnoreCase": {
"kms:RecipientAttestation:PCR17": "5ccb2d706da3b61f6ecbb85799cc24c54fddc841b2b259d0a67f732dc9ace02212cba02e6a3ad441c284eb4b1da3b5da",
"kms:RecipientAttestation:PCR8:ServiceName": "eks.amazonaws.com"
}
}
Fixando o PCR17. A key policy dá à role do Pod Identity o kms:Decrypt só quando o PCR17 do documento de atestação é o previsto e a imagem do guest foi assinada para o EKS. O PCR8 é “a medição do certificado que assinou a imagem do guest (o EIF)”, e a página de configuração do modo confidencial diz para comparar o ServiceName dele em vez do valor bruto, e que “Condicionar só ao PCR17 não é suficiente.” O PCR17 abaixo é o da execução gravada; o da primeira execução era 11d02790…2de1313, porque cada execução tinha a sua própria chave e, portanto, o seu próprio ciphertext no ambiente fixado.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AccountAdmin",
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::<ACCOUNT_ID>:root" },
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "DecryptOnlyFromAttestedConfidentialPod",
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::<ACCOUNT_ID>:role/my2cents-nitro-eks-attest" },
"Action": "kms:Decrypt",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {
"kms:RecipientAttestation:PCR17": "5ccb2d706da3b61f6ecbb85799cc24c54fddc841b2b259d0a67f732dc9ace02212cba02e6a3ad441c284eb4b1da3b5da",
"kms:RecipientAttestation:PCR8:ServiceName": "eks.amazonaws.com"
}
}
}
]
}
Isso basta para o teste, que é sobre a role do pod. Não é uma key policy de produção: o statement AccountAdmin delega para o IAM, então qualquer principal IAM da conta com uma identity policy que permita isso consegue chamar um kms:Decrypt simples, sem atestação. Os blueprints da AWS trocam esse statement por um de administração mais restrito e acrescentam dois statements Deny explícitos em Principal: "*", um por registrador, para que nada seja descriptografado sem uma atestação que confira.
Depois eu apliquei a key policy, copiei a seção do envelope dos logs para eks-policy.b64 e encaixei o envelope no manifest como a annotation:
aws kms put-key-policy --key-id "$KEY_ID" --policy-name default --policy file://kms-eks-final.json
jq --rawfile p eks-policy.b64 '.metadata.annotations["sandbox.amazonaws.com/policy"] = $p' \
pod-confidential-nopolicy.json > pod-confidential.json
kubectl apply -f pod-confidential.json
A policy tem que vir da spec final. Os blueprints da AWS observam que a annotation é imutável num pod em execução, então uma mudança significa apagar e recriar o pod.
Teste 7: Confidencial, isolado e adulterado
Eu apliquei juntos o pod confidencial com a sua policy e o mesmo manifest como attest-isolated, com runtimeClassName: isolated-sandbox e sem annotation; os dois caíram no mesmo node:
kubectl apply -f pod-confidential.json -f pod-attest-isolated.json
kubectl logs attest-confidential
kubectl logs attest-isolated
| Confidencial, com a sua policy | Mesmo pod, isolado | |
|---|---|---|
| Status | Running | Running |
/dev/nsm e documento de atestação | sim, 4.809 bytes | sim, 4.808 bytes |
| PCR0 (imagem do guest) | 2be43455…68f83c4 | igual |
| PCR8 (assinante) | fdb0f814…6ad3698 | igual |
| PCR17 (policy) | 5ccb2d70…1da3b5da, o valor previsto (primeira execução: 11d02790…2de1313, também o valor previsto) | 8d833c2f…aa08dc, nas duas execuções |
| Decrypt do KMS via Pod Identity | SECRET: eks: only a measured pod can read this | AccessDeniedException ... not authorized to perform: kms:Decrypt |
kubectl exec ... uname -r | negado pela policy | 6.18.54 |
A execução gravada imprimiu só o PCR17 e o resultado do KMS, então os tamanhos dos documentos, o PCR0 e o PCR8 são da primeira execução. Os logs gravados, cortados nas linhas que importam:
# kubectl logs attest-confidential
PCR17: 5ccb2d706da3b61f…
SECRET: eks: only a measured pod can read this
# kubectl logs attest-isolated
PCR17: 8d833c2f8409829a…
aws: [ERROR]: An error occurred (AccessDeniedException) when calling the Decrypt operation: is not authorized to perform
E o kubectl exec em cada um:
$ kubectl exec attest-isolated -- uname -r
6.18.54
$ kubectl exec attest-confidential -- uname -r
… policy denied Agent::Action::"Exec" on container "attest" …
A execução gravada imprimiu a negação a partir de policy denied; na primeira execução, a mensagem começava com error executing command in container: failed to create exec "…".
Adulteração, de duas formas. Na execução gravada, eu apaguei o attest-confidential e criei um pod com o mesmo nome e a mesma annotation de policy, mudando só o comando: echo tampered; na frente dele. Na primeira execução, o pod adulterado também tinha sido renomeado, para attest-tampered.
kubectl delete pod attest-confidential --wait=true
jq '.spec.containers[0].command[2] |= "echo tampered; " + .' pod-confidential.json > pod-tampered.json
kubectl apply -f pod-tampered.json # metadata.name is still attest-confidential
kubectl get events --field-selector involvedObject.name=attest-confidential
| Pod adulterado | Status | Evento |
|---|---|---|
| Mesmo nome e policy, comando alterado (execução gravada) | CrashLoopBackOff | policy denied Agent::Action::"CreateContainer" |
Renomeado para attest-tampered, comando alterado (primeira execução) | ContainerCreating | FailedCreatePodSandBox ... guest sandbox setup failed: rpc status: Status { code: PERMISSION_DENIED, message: "policy denied SetupSandbox" |
O que as tabelas mostram:
- O PCR17 é previsível. Nas duas execuções, o valor que o gerador imprimiu antes de o pod existir é o valor que o pod em execução reportou, então a key policy pode ser escrita antes do primeiro deploy, como no ECS.
- Pods isolados também conseguem fazer atestação, e o KMS consegue diferenciá-los. O pod isolado tinha um NSM, a mesma imagem do guest (PCR0) e o mesmo assinante (PCR8). Dos PCRs que eu imprimi (PCR0, PCR8, PCR17), só o PCR17 era diferente, e foi por ele que o KMS recusou. O PCR17 dele,
8d833c2f…aa08dc, foi o mesmo nas duas execuções e idêntico ao da task isolada do ECS na parte 3, enquanto o PCR0 e o PCR8 diferem entre EKS e ECS (imagens de guest assinadas separadamente). Então esse valor parece ser a medição da policy permissiva embutida, a mesma nos dois serviços. - Exec é uma decisão de policy. O
kubectl execfuncionou no pod isolado e foi recusado pelo agente do guest no confidencial, como a runtime policy dizia. O ECS traça a linha mais cedo: na parte 3, o ECS Exec funcionou numa task isolada, mas uma task confidencial iniciada com o ECS Exec ligado, contra uma policy gerada sem--allow-exec-command, nunca iniciou. Aqui o pod confidencial rodou, e só a chamada de exec foi recusada. - Um comando alterado é recusado no
CreateContainer, como no ECS. Com o nome inalterado, o agente montou o sandbox e depois se recusou a criar o container. A negação deSetupSandboxda primeira execução, um passo antes, veio da troca de nome: o permit deSetupSandboxgerado fixacontext.hostname == "attest-confidential", e dos campos que ele verifica, o hostname é o único que a troca de nome mudou. Nenhum dos pods adulterados rodou, e nenhum falhou de vez: como o pod comhostNetwork, os dois ficaram tentando de novo, então fique de olho no evento, não numa faseFailed.
O custo é a rotatividade. A policy fixa os valores do ambiente, incluindo o ciphertext, o digest da imagem e o nome do pod, então criptografar o segredo de novo, editar o cliente NSM, passar para uma imagem nova ou renomear o pod significa, em cada caso, uma policy nova, um PCR17 novo e uma atualização da key policy. As duas execuções mostram isso: uma chave e um ciphertext novos, e nada mais, deram um PCR17 novo.
Como no EC2 e no ECS, o module_id do documento de atestação começa com o ID da instância pai, aqui o node da primeira execução: i-0956c7c6b4bd96b04-enc01a1c2f63a2c8aa2.
O que eu não testei: os throttles padrão, que a documentação coloca em 100 Mbps e 1.500 pacotes por segundo em cada sentido, 100 queries DNS por segundo e 4.096 conexões rastreadas, e que ela manda aumentar antes de você fazer benchmarks; volumes EBS e EFS; imagens criptografadas; e a verificação do AWS Signer.
Resumo dos resultados
| Pergunta | Resposta das minhas execuções |
|---|---|
| Chave no nível do cluster | Nenhuma: Kubernetes 1.36 ou mais novo no Auto Mode, numa Região comercial dos EUA segundo a página de visão geral; nenhum argumento de módulo, provider ou API |
| O que o Auto Mode entrega | As duas RuntimeClasses antes de qualquer node: overhead de 256Mi ou 512Mi mais um eks.amazonaws.com/nitro-sandbox, um nodeSelector, sem toleration |
| Graviton | Funciona, com o seu próprio NodePool, porque o general-purpose é só amd64 |
| Opt-in do pod | runtimeClassName: isolated-sandbox |
| Primeiro pod, incluindo o node | 50 s até Ready na execução gravada, 85 s na primeira |
| Inicialização a quente | 4,4 a 5,4 s, contra 1,7 a 2,1 s de um pod comum, nas duas execuções |
| O que um pod em sandbox enxerga | O próprio kernel (6.18.54), 1 vCPU e memória a partir dos requests, discos virtio, um dispositivo NSM |
| Metadata | O substituto respondeu Região e AZ; ID da instância e credenciais deram 404 |
| Token da service account no modo isolado | Montado, embora a documentação diga que não |
| Configurações de nível de host | hostNetwork preso em ContainerCreating; hostPID enxerga o systemd da VM |
| Densidade | O node anuncia 20 slots de sandbox (5 × as suas 4 vCPUs); de 18 a 20 pods rodaram em quatro execuções do mesmo Deployment, o resto ficou Pending com Insufficient eks.amazonaws.com/nitro-sandbox |
| Modo confidencial | O PCR17 bateu com a previsão nas duas execuções; o KMS liberou o segredo via Pod Identity só para esse pod; exec negado; um comando alterado foi recusado no CreateContainer (CrashLoopBackOff), um pod renomeado no SetupSandbox (ContainerCreating) |
| Geração da policy | Rodou num pod comum no cluster como atalho de demo; em produção, gere no CI ou numa estação de trabalho Linux, fora do node. Precisa de enableServiceLinks: false (ou de uma das duas alternativas mais frouxas que a ferramenta oferece) |
| Monitoramento | O kubectl top pod e o CPUUtilization do EC2 enxergam um sandbox ocupado; o kubectl top node e o Container Insights não, e o Container Insights não tem registros dos pods em sandbox |
| CloudTrail | O Decrypt com atestação traz o PCR17 em base64 e PCR8ServiceName: eks.amazonaws.com |
Operação e Monitoramento
Assista a esta parte: a seção de operações do vídeo, a partir de 5:24, percorre tudo isso no console, no CLI e no kubectl.
Em 2026-11-10 eu fiz uma terceira rodada, para a seção de operações do vídeo, do zero no console, com o CLI e o kubectl ao lado: uma VPC criada pelo assistente de VPC do console, o cluster (veja o Passo 2), o mesmo NodePool de m8g.xlarge com um Deployment de duas replicas de pods isolated-sandbox, os add-ons CloudWatch Observability e Metrics Server, de novo o pod confidencial do Teste 6, e a desmontagem. Os dois pods estavam rodando de 59 a 71 segundos depois do kubectl apply, com o lançamento do node incluído.
Onde o sandbox aparece. A aba Compute do cluster lista o node e os dois node pools, o system como “Built-in” e o sandbox-m8g como “Custom”. A alocação de capacidade na página do node conta a memória de cada pod com o overhead de 256Mi (1 GiB reservado para dois pods pedindo 256Mi), mas não os slots de sandbox. A visão estruturada da página do pod não menciona o sandbox em nenhum momento; só a visão Raw mostra o runtimeClassName, o overhead e o nodeSelector injetado.
Gerenciá-los é kubectl puro. Logs e exec funcionam, e o exec cai dentro do guest (kernel 6.18.54, uma CPU). Escalar para quatro fez o boot de mais duas VMs, o rollout restart substituiu cada pod e a sua VM, e escalar para zero removeu todos; não existe pausa. Uma pegadinha: um loop de bash como PID 1 ignorava o SIGTERM, então os pods esperavam o grace period de 30 segundos inteiro até eu acrescentar trap 'exit 0' TERM.
Enquanto um pod em sandbox consumia uma vCPU inteira:
| Sinal | O que mostrou |
|---|---|
kubectl top pod (Metrics Server) | 984m: ele enxerga o sandbox |
kubectl top node | 29m |
| Container Insights, CPU do node | 0,8% |
| Container Insights, registros de pod e de container | Nenhum para os pods em sandbox, só para os cinco containers dos add-ons, ao longo de 10 minutos ou mais; a contagem de pods em execução do node incluía os pods em sandbox |
CPUUtilization do EC2 para o node | 26%, uma de quatro vCPUs |
| Logs de aplicação | O stdout de cada pod em sandbox chegou a /aws/containerinsights/<cluster>/application via Fluent Bit |
A página de visão geral diz que a instância pai “não consegue observar o estado de CPU nem de memória do sandbox”, e o node, com tudo o que lê dele, não observou. O kubectl top observou, como a página de observabilidade promete, depois que o Metrics Server foi instalado; o Auto Mode não instala o Metrics Server, embora a Custom configuration o deixe pré-selecionado. E a métrica do EC2 observou, porque ela é “a soma do CPUUtilization do guest e do CPUUtilization do hypervisor”. A mesma página de observabilidade diz que o agente do CloudWatch “consegue coletar logs e métricas de containers de pods em sandbox”: logs, sim; métricas, não nos registros de pod do Container Insights neste setup.
CloudTrail. O registro de CreateCluster mostra a sessão do console e computeConfig.nodePools: ["system"]. O Decrypt do KMS do pod confidencial vem da role do Pod Identity dele, com um bloco recipient contendo o module ID (o ID da instância do node mais -enc…), o digest da imagem, PCR1 a PCR4, PCR8, PCR17 e attestationDocumentEnclavePCR8ServiceName: "eks.amazonaws.com". O PCR17 está em base64, o que a página do KMS sobre CloudTrail não diz; decodificado, ele era igual à previsão do gerador nas duas execuções. O registro aparecia no lookup-events em algo entre 40 segundos e 2 minutos.
Preços
Os Nitro Sandboxes não têm custo adicional. No EKS, você paga o que um cluster Auto Mode já custaria de qualquer forma. Em us-east-1:
| Item | Preço |
|---|---|
| Control plane do EKS | $0,10 por cluster-hora |
m8g.xlarge on-demand | $0,17952 por hora |
Taxa de gerenciamento do Auto Mode para m8g.xlarge | $0,02154 por hora |
| Um node de sandbox, control plane incluído | $0,30106 por hora |
O NAT gateway desta VPC acrescenta cerca de $0,045 por hora mais dados, e a chave do KMS, $1 por mês até você agendar a remoção dela. O node custa o mesmo com zero sandboxes ou com vinte, então o custo real aparece como capacidade:
- Overhead fixo de memória por pod. A RuntimeClass soma 256Mi aos requests de todo pod isolado e 512Mi aos de todo pod confidencial. Num pod de 512Mi, isso é metade a mais no modo isolado e o dobro no modo confidencial, do ponto de vista do scheduler. No ECS, na parte 3, eu medi um overhead real que crescia com o tamanho da task, de 262 a 509 MiB; no EKS o número é fixo, e eu não medi o que o node gasta de fato.
- O limite de 20 sandboxes numa
m8g.xlarge. Para pods pequenos, a quantidade pesa muito antes da memória. Vinte dos meus pods de densidade de 50m / 64Mi reservariam 20 × (64 + 256) = 6.400 Mi dos 13.513 Mi allocatable do node, e a memória restante só pode ir para pods comuns. E nas minhas execuções só de 18 a 20 dos 20 slots eram utilizáveis (Teste 5). - Por pod com 1 vCPU. Pelos 3.770m de CPU allocatable do node, cabem no máximo três pods pedindo 1 vCPU numa
m8g.xlarge: cerca de $0,067 por hora cada, com a taxa do Auto Mode, antes do control plane. Uma Lambda MicroVM com 1 vCPU e 2 GB custa $0,1261 por hora, mas só enquanto roda; um node é cobrado por toda hora em que está no ar. O Auto Mode consolida nodes de sandbox como qualquer outro (Teste 1), então um node esvaziado não precisa ficar ocioso.
A minha exploração foi das 00:12 até por volta das 01:10 UTC, e 13 minutos e 42 segundos disso foram de terraform apply. A execução gravada manteve um segundo cluster no ar das 02:08 até por volta das 06:30 UTC, depois de mais um apply de uns 13 minutos.
Limpeza
Apague primeiro os workloads e o NodePool, para que o Auto Mode encerre o node, e depois a associação do Pod Identity, a chave e a infraestrutura:
kubectl delete deployment density --ignore-not-found
kubectl delete pod --all -n default
kubectl delete nodepool sandbox-m8g
ASSOC=$(aws eks list-pod-identity-associations --cluster-name my2cents-nitro-eks \
--query 'associations[0].associationId' --output text)
aws eks delete-pod-identity-association --cluster-name my2cents-nitro-eks --association-id "$ASSOC"
aws kms schedule-key-deletion --key-id <key-id> --pending-window-in-days 7 # key ID, not alias
terraform destroy
aws iam delete-role --role-name my2cents-nitro-eks-attest
Na execução gravada, a chave foi para PendingDeletion e o terraform destroy terminou com Destroy complete! Resources: 54 destroyed.; eu apaguei a role separadamente. Como nas partes 2 e 3, o schedule-key-deletion quer o ID da chave, não o alias, e sete dias é o menor período de espera. A role IAM foi criada com o CLI, não com o Terraform, então o terraform destroy não a remove; é para isso que serve a última linha.
Veredito
O que funciona
No Auto Mode, o opt-in é tão pequeno quanto o prometido. As duas RuntimeClasses estavam lá antes do primeiro node, um NodePool comum sem nenhuma configuração de sandbox produziu um node Graviton capaz de rodar sandboxes, e o pod precisou de um campo. Um pod em sandbox é visivelmente uma máquina à parte, com o próprio kernel, uma VM dimensionada a partir dos requests, discos virtio e um dispositivo NSM, enquanto um pod comum no mesmo node enxerga o node todo. O substituto de metadata se comportou exatamente como documentado, o que é mais do que eu poderia dizer do ECS. O hostPID fica confinado à VM, o isolamento de rede remove a rede, e exec, logs e Pod Identity funcionam sem mudanças no modo isolado. No dia a dia, os pods em sandbox escalaram, reiniciaram e mandaram logs para o CloudWatch como quaisquer outros, e o CloudTrail registrou cada decrypt com atestação.
O modo confidencial é tão completo quanto era no ECS, com a ergonomia do Kubernetes. O gerador previu o PCR17 exatamente e imprimiu a policy como Cedar legível, com dicas para apertá-la. Nesta demo ele rodou num pod no cluster, mas em produção o lugar dele é o pipeline de CI/CD que produz os seus manifests, fora do node que o modo confidencial trata como não confiável. O KMS liberou o segredo só para o pod que carregava essa policy, via Pod Identity e sem add-on, e recusou o mesmo pod no modo isolado; o guest recusou o kubectl exec, e uma cópia com só o comando alterado foi recusada no CreateContainer, a mesma etapa que no ECS. As duas execuções concordaram em tudo isso.
O que ainda não funciona
A documentação e o blog de lançamento estão atrás do produto em dois pontos que importam para revisões de segurança. A RuntimeClass do Auto Mode não tem toleration e o node de sandbox não tem taint, contradizendo o blog de lançamento, então pods comuns compartilham nodes de sandbox a menos que você providencie o contrário. E um pod isolado recebeu o token da service account que a página de visão geral diz que ele não recebe.
O monitoramento também merece uma segunda olhada. O Container Insights não tinha registros de pod nem de container para os pods em sandbox, e a CPU do node ficou estável enquanto um deles consumia uma vCPU inteira. Quem enxergou isso foi o kubectl top, com um Metrics Server que o Auto Mode não instala por padrão, e a métrica do EC2 para o node.
Os modos de falha são silenciosos. Um pod com hostNetwork é aceito e depois fica parado em ContainerCreating, e um pod confidencial com um comando alterado entra em CrashLoopBackOff (um renomeado, em ContainerCreating); todos eles ficam tentando de novo em vez de falhar. O ECS recusou a task definition com host network no registro, e a task adulterada dele foi registrada e depois parou com TaskFailedToStart em vez de ficar tentando de novo. A densidade chega no máximo aos 20 slots que uma m8g.xlarge anuncia (5 × as suas 4 vCPUs), e eu não consegui contar com todos eles: de 18 a 20 pods rodaram em quatro execuções do mesmo Deployment, menos logo depois de remoções, e uma rajada num node novo teve dois pods rejeitados pelo kubelet. Eu não descobri por quê. O overhead fixo de 256Mi, 512Mi no modo confidencial, deixa pods pequenos caros em memória. O pool embutido general-purpose é só amd64, então o Graviton precisa de um NodePool seu. E o modo confidencial acrescenta um ciclo de policy: uma policy e uma key policy regeneradas a cada mudança na imagem, no comando, no ambiente ou no nome do pod, vindas de um gerador que deveria rodar fora do node. O gerador precisa de enableServiceLinks: false (ou de uma das duas alternativas mais frouxas que a ferramenta oferece). Um comando de uma linha só e as duas variáveis de Região são requisitos que eu trouxe do ECS e dos blueprints da AWS; não testei nenhum dos dois no EKS.
Quem deve usar
Times de Kubernetes que rodam imagens de container que não escreveram, por pod: agentes de código, runners de CI, workers por tenant. No Auto Mode, a configuração é quase zero, e os pods mantêm tudo o que o Kubernetes dá a eles, incluindo Pod Identity, o VPC CNI, logs e exec. O modo confidencial é para pods que precisam provar o que rodam antes de receber uma chave, e, como no ECS, a medição vem de uma ferramenta documentada, e não de dentro de um guest em execução. Ele se encaixa melhor em pods de 1 GiB para cima, onde o overhead de 256Mi é um quarto ou menos, com folga abaixo dos 20 slots que um node anuncia.
Pule se os seus pods precisam de hostNetwork, GPUs ou resize in-place, e se a ideia é empacotar centenas de pods minúsculos por node. Se você está no ECS, a parte 3 é a mesma feature com um campo na task definition. Se você roda o seu próprio orquestrador, a primitiva bruta no EC2 (parte 2) dá mais controle e mais trabalho. Se você prefere não rodar nodes, as AWS Lambda MicroVMs cobram por segundo enquanto rodam e suspendem com a memória intacta, mas não documentam nenhuma atestação.