AWS Nitro Sandboxes: Como Um Único Ajuste do Nitro Isola Workloads no EC2, ECS e EKS
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
Explica (TLDR) como se eu fosse...
Imagine que cada brinquedo da sala de brinquedos ganha a sua própria casinha, com uma porta que tranca. Antes, todos os brinquedos dividiam uma sala grande, então um brinquedo levado conseguia mexer nas coisas de todo mundo. Agora cada um brinca na sua casinha, e a sala de brinquedos continua do mesmo tamanho.
Algumas casinhas também vêm com um crachá que prova exatamente qual brinquedo mora lá dentro. O adulto que cuida do pote de biscoitos confere o crachá antes de abrir o pote. As casinhas ocupam um pouco de espaço no chão, então cabem menos brinquedos.
Os Nitro Sandboxes movem a fronteira entre os workloads de uma instância do software compartilhado para o hypervisor de hardware, sem custo adicional. Para código multi-tenant ou não confiável, isso muda o risco residual de um kernel compartilhado para uma superfície bem mais estreita, operada pela AWS.
O modo confidencial acrescenta evidência: uma medição assinada do que roda, que uma key policy do AWS KMS pode exigir antes de liberar dados. Restam pontos de diligência: a pod spec ou a task definition continua sendo uma entrada confiável, restringir o egress de rede continua sendo responsabilidade do cliente, e a instância pai ainda pode negar serviço.
A condição é código não confiável dividindo um kernel com vizinhos, em que um único exploit pode se espalhar por um host. O tratamento é uma máquina virtual de hardware separada por pod, task ou workload na mesma instância, iniciada em segundos.
Nas minhas medições, a fronteira se manteve e a atestação funcionou nos três serviços. Os efeitos colaterais são de capacidade, não de preço: algumas centenas de MiB de memória por sandbox no ECS e no EKS, cerca de 18 MiB no EC2, no máximo cinco sandboxes por vCPU, e algumas configurações no nível do host deixam de funcionar. Workloads de GPU ainda não são candidatos.
Para times que rodam código de outras pessoas, ou código que um agente de IA escreveu um minuto atrás, existe um zumbido baixo de preocupação com o que um único workload ruim conseguiria alcançar. Este lançamento acalma parte disso, porque o vizinho na mesma máquina agora está atrás de uma parede de hardware.
Ele também pede honestidade sobre o que resta. Alguém ainda é dono das regras de egress, das escolhas de imagem e do pipeline de atestação, e o modo confidencial significa aceitar que os operadores perdem, por padrão, a capacidade de fazer exec em um workload. Essa troca merece uma conversa, não uma escolha por padrão.
Imagine um estúdio de ensaio dividido em cabines com isolamento acústico. Antes, todos os músicos dividiam a sala, então um amplificador alto vazava em todos os microfones. Agora cada músico ganha uma cabine com as próprias paredes, e o técnico de som pode até receber uma cópia assinada do que foi tocado.
As cabines precisam de espaço no chão, então a sala comporta menos músicos, e a passagem de som leva alguns segundos a mais por cabine. No EC2 você mesmo constrói as cabines; no ECS e no EKS basta pedir uma no setlist.
A manchete é isolamento de hardware por container, sem uma instância separada por tenant e sem uma linha a mais na cobrança. No ECS e no EKS é um único campo por task ou pod (mais um capacity provider com Nitro habilitado no ECS), o tipo de time to value que times de plataforma conseguem vender internamente em uma semana.
O diferencial para compradores regulados é a atestação: uma chave que só abre para um workload medido. Mas seja preciso sobre o custo. Ele aparece como densidade e alguns recursos do host perdidos, não na fatura.
Visão Geral
Em 2026-11-09 a AWS lançou os Nitro Sandboxes: máquinas virtuais leves que o hypervisor Nitro roda ao lado de uma instância EC2, usando a CPU e a memória da própria instância. Você pode colocar uma em volta de um pod do EKS, de uma task do ECS ou de qualquer coisa que você mesmo inicie no EC2. A AWS anunciou o recurso na maioria dos tipos de instância Nitro, em todas as Regiões comerciais, sem custo adicional, embora o guia do EKS agora limite os pods isolados e confidenciais às Regiões comerciais dos EUA.
O problema que o recurso ataca é antigo, e os agentes de IA o tornaram urgente. Containers no mesmo host compartilham um único kernel, então um exploit de kernel ou uma fuga de container em um workload pode alcançar os outros. A própria documentação do ECS e do EKS da AWS diz isso com todas as letras. Até agora, as formas nativas da AWS de contornar isso eram uma instância separada por tenant, o Fargate, ou uma configuração com uma VM por pod que exigia bare metal ou virtualização aninhada. Os Nitro Sandboxes dão a cada pod ou task o próprio kernel, atrás da mesma fronteira que separa as instâncias EC2, enquanto cada um continua compartilhando a instância com os vizinhos.
Este post, parte 1 de 4, explica como as peças se encaixam e resume o que eu medi. As partes hands-on se aprofundam em cada ponto de entrada:
- Parte 2: EC2. A primitiva bruta, operada com o Firecracker, incluindo a atestação e um teste de leitura de memória a partir da instância pai.
- Parte 3: ECS. Tasks isoladas e confidenciais no ECS Managed Instances, quase tudo pelo console.
- Parte 4: EKS. Pods isolados e confidenciais no EKS Auto Mode.
Eu rodei os três em 2026-11-09 e 10 na us-east-1, em uma m8g.xlarge (Graviton4, 4 vCPU, 16 GiB) por parte (o ECS chegou a iniciar uma segunda por pouco tempo quando eu enchi demais a primeira), com a AWS CLI 2.39.7. A versão curta: a fronteira e a atestação funcionam como anunciado nos três; o opt-in é de fato um campo por task ou pod no ECS e no EKS, depois que o ECS tem um capacity provider criado com o Nitro Enclaves ligado; o custo aparece como memória e densidade, não como dólares; e em vários pontos a documentação de 9 de novembro estava errada ou não dizia nada, o que as partes apontam uma a uma. Desde então a AWS revisou a documentação, sobretudo o guia do EC2, e ela agora fecha algumas dessas lacunas; eu indico abaixo onde.
Arquitetura
Por baixo dos três pontos de entrada está a mesma primitiva do EC2, construída sobre o encanamento do Nitro Enclaves: a configuração “Nitro Enclave” da instância, o driver nitro_enclaves em um kernel 6.18 com as extensões de sandbox da Amazon (AL2023 no EC2, onde o guia agora também aponta para um PPA do Ubuntu; as imagens da AWS baseadas em Bottlerocket no ECS e no EKS), o Nitro Secure Module e os documentos de atestação dele, e as mesmas chaves de condição do KMS. A novidade é que o guest é uma VM de uso geral. Um Nitro Enclave fala com a instância pai por um único canal vsock e não tem rede nem disco. Um sandbox tem dispositivos virtio de rede e de bloco e faz boot de um kernel normal, então consegue rodar uma imagem de container comum.
O Firecracker 1.18, lançado no mesmo dia, agora consegue operar o hypervisor Nitro através de /dev/nitro_enclaves em vez do KVM. No EC2 você mesmo o roda. No EKS, a AWS o roda para você atrás de um shim do containerd e de um agente dentro do guest, ambos distribuídos como binários assinados, não como open source. A documentação do ECS cita um agente de sandbox do ECS dentro de cada guest, mas não o VMM que faz o boot dele.
Conceitos
Não é virtualização aninhada
Um sandbox é um guest de primeiro nível do hypervisor Nitro, um par da instância pai, e não uma VM dentro dela. O assistente de criação de instâncias do EC2 deixa isso concreto: na m8g.xlarge que eu usei, ele mostrava “Nitro Enclave: Enable” alguns campos acima de “Nested virtualization is not supported with the selected instance type”. Os sandboxes funcionaram mesmo assim, porque não usam esse recurso. Você também não precisa de uma instância .metal nem de KVM. O guia do EC2 revisado acrescenta que os dois não se misturam: não dá para usar Nitro Sandboxes em uma instância que tenha a virtualização aninhada habilitada.
Modos: três esquemas de nomes, dois modelos de confiança
Cada serviço nomeia os modos de um jeito diferente, e nenhuma página faz o mapeamento entre eles. Aqui está o que eu consegui estabelecer, por modelo de confiança:
| Sem sandbox | Sandbox, instância pai confiável | Sandbox, instância pai não confiável | |
|---|---|---|---|
EC2 (chave enclave do Firecracker) | (um processo ou container na instância) | {"direct_mode": true} | {} (o padrão) |
ECS (isolationMode) | SHARED (padrão) | ISOLATED_SANDBOX | CONFIDENTIAL_SANDBOX + attestationPolicy |
EKS (runtimeClassName) | (nenhum) | isolated-sandbox | confidential-sandbox + sandbox.amazonaws.com/policy |
As colunas são modelos de confiança, não modelos de memória. Só o modo direto do EC2 deixa a instância pai ler a memória do guest. Os modos isolados do ECS e do EKS continuam rodando sobre memória confidencial por baixo (os dois tinham um Nitro Secure Module; detalhes abaixo), então “instância pai confiável” ali significa que a instância pai mantém o exec e um overlay de disco legível e que nenhuma policy sua é aplicada, e não que ela consegue ler a RAM do sandbox.
No EC2, a diferença entre os modos é a memória. Na parte 2 eu plantei um segredo em um guest e o procurei na visão que a instância pai tem desse guest: 1.994 ocorrências no modo direto, nenhuma no modo confidencial. O modo direto não tem Nitro Secure Module.
No ECS e no EKS, até o modo “isolado” tinha um dispositivo Nitro Secure Module em toda task e todo pod que eu verifiquei, e os dois conseguiam produzir documentos de atestação. Isso aponta para o modelo de memória confidencial por baixo dos dois modos gerenciados da AWS; as páginas de segurança do ECS e do EKS também dizem que a instância pai “não consegue ler nem escrever na memória do guest”, sem especificar o modo. O que separa o isolado do confidencial ali é uma Cedar policy que você fornece e que fixa o workload (o modo isolado roda uma policy embutida e permissiva), mais um overlay de disco criptografado:
- Isolado: nenhuma policy sua. O guest roda uma policy embutida e permissiva, cujo PCR17 (
8d833c2f…) era o mesmo no ECS e no EKS. A instância pai é confiável: você pode fazerkubectl exec(eu fiz no EKS) ou usar o ECS Exec (segundo a documentação), qualquer spec de container é aceita, e o overlay de disco não é criptografado. - Confidencial: uma policy de atestação, gerada pelo
eks-nitro-sandbox-genpolicyou peloecs-nitro-sandbox-genpolicyda AWS, fixa o digest da imagem, o comando, o ambiente, o usuário e as capabilities. Ela nega exec e stdin, e o agente dentro do guest a aplica. O hash dela vai parar no PCR17, que uma key policy do KMS pode exigir.
Gere essa policy fora da instância. No modo confidencial, a instância é a parte não confiável, e uma instância comprometida poderia devolver uma policy permissiva junto com o PCR17 correspondente, que você então colaria na key policy. A página de ferramentas de CLI da AWS diz para rodar as ferramentas “na sua estação de trabalho ou no seu pipeline de build, não na instância”. Nas partes 3 e 4 eu rodei os geradores no próprio cluster como atalho de demo; em produção, rode-os no CI, no CloudShell, ou em uma estação de trabalho ou um container Linux.
Atestação em um parágrafo
Um sandbox confidencial pode pedir ao Nitro Secure Module dele um documento assinado pela AWS que lista medições:
| PCR | O que ele mede |
|---|---|
| PCR0, PCR1, PCR2 | a imagem de boot (kernel, initrd, linha de comando); o PCR0 também registra flags de inicialização, como o overcommit de CPU |
| PCR3, PCR4 | a role do IAM e o ID da instância pai |
| PCR5, PCR6 | os dispositivos PCI presentes no boot, e o arquivo de imagem inteiro (novo para sandboxes; o guia do EC2 diz para fixar o PCR0, não o PCR6, que pode mudar entre builds) |
| PCR8 | o certificado que assinou a imagem do guest; o KMS mapeia o PCR8 das imagens gerenciadas para ecs.amazonaws.com ou eks.amazonaws.com através de PCR8:ServiceName |
| PCR17 | a Cedar policy, no ECS e no EKS |
O AWS KMS aceita esse documento como o Recipient de uma chamada Decrypt, confere os PCRs com as condições da key policy e devolve o texto em claro cifrado para uma chave pública que está dentro do documento. Quem faz a chamada, que muitas vezes é a instância pai, não consegue lê-lo; só o guest que guarda a chave privada consegue. Eu fiz isso funcionar nas três superfícies, incluindo duas coisas que a documentação de 9 de novembro não cobria no EC2 (um kernel do guest com o driver NSM, e um PCR0 para fixar: o Firecracker não o informa, então eu o li uma vez a partir de um primeiro boot). A nova página de atestação do guia do EC2 agora cobre as duas: ela carrega o módulo nsm do kernel AL2023 e calcula o PCR0 com antecedência usando o eif_build. Em todos os casos, um workload alterado foi recusado.
O que muda em relação a um container comum
| Container comum | Em um Nitro Sandbox | |
|---|---|---|
| Kernel | o do host, compartilhado com todos os vizinhos | o próprio (por exemplo, 6.18.54 em um sandbox do EKS em um node 6.18.56) |
O que nproc e MemTotal mostram | o host inteiro (4 vCPU, 16 GiB) | o sandbox (1 vCPU, ~650 MiB para um request de 512 Mi) |
hostNetwork / modo de rede host | permitido | EKS: pod travado com hostNetwork is not supported for nitro-sandbox pods; ECS: rejeitado no registro |
hostPID / pidMode: host + privileged | os processos do host | o systemd e os ~170 processos da própria VM do sandbox |
| Metadata da instância | depende do seu bloqueio | EKS: um substituto só com os paths de placement e de endpoints de serviço (sem ID da instância nem credenciais); ECS: nenhuma resposta no meu teste; EC2: o IMDS da instância pai, a menos que você o bloqueie |
| Quem consegue ler a memória dele | root no host | ninguém no host (memória confidencial) |
O que não muda
A pod spec ou a task definition continua sendo uma entrada confiável: quem a escreve escolhe a imagem e os mounts. No modo isolado, a instância pai ainda controla o sandbox, pode fazer exec nele e pode ler o overlay de disco dele. No EC2, o guia revisado acrescenta que a instância pai consegue ler todo dispositivo de bloco que ela apresenta a um sandbox, incluindo volumes EBS criptografados, então dados confidenciais precisam ser criptografados dentro do guest. Restringir o egress de rede continua sendo responsabilidade sua, com security groups ou network policy, agora aplicados na instância pai, onde o guest não consegue mexer neles. E em todos os modos a instância pai pode negar serviço ou adulterar o tráfego que não é criptografado. As credenciais também ficam expostas, de formas diferentes. No EKS, a instância pai consegue emitir credenciais do Pod Identity para qualquer pod do node, então trate a role de um pod como disponível para o node. No ECS, ela consegue injetar credenciais arbitrárias da task role e redirecionar as chamadas da task à AWS para uma conta controlada pelo atacante.
A densidade é o preço real
Não há cobrança pelo recurso, mas cada sandbox carrega uma memória que um container comum não carrega, e uma instância comporta um número fixo deles:
| Overhead de memória por sandbox | Máximo de sandboxes na m8g.xlarge | |
|---|---|---|
| EC2 (autogerenciado) | 2 MiB, mais 16 MiB por dispositivo virtio no modo confidencial | 20 (com cpu_overcommit e o orçamento de slots aumentado de 4; 3 com núcleos dedicados) |
| ECS | 262 MiB para uma task de 512 MiB ou 1 GiB, até 509 MiB para 8 GiB | não medido; a CPU acabou primeiro no meu teste (uma quinta task de 1 vCPU iniciou uma segunda instância), e a memória só vira o limite em tasks maiores |
| EKS | overhead de RuntimeClass de 256 Mi (isolado) ou 512 Mi (confidencial) | 20 anunciados; de 18 a 20 rodaram nos meus testes |
A memória é doada inteira e não tem overcommit (a documentação do Firecracker diz que o overcommit de memória “ainda não é suportado”), e o limite é de cinco sandboxes por vCPU, com no máximo 896 em uma instância. Em instâncias Intel e AMD com duas threads por núcleo, a AWS também documenta que a capacidade de computação utilizável pelos sandboxes é cerca de metade das vCPUs anunciadas; o Graviton não tem essa penalidade, e esse é um dos motivos pelos quais eu o usei.
Como se compara com as AWS Lambda MicroVMs
No começo deste mês eu cobri as AWS Lambda MicroVMs, a outra forma nova da AWS de rodar código não confiável em uma VM. O próprio guia do EC2 indica esse caminho para quem não quer operar nada dessa maquinaria, “sem instâncias nem rede para gerenciar”. Os dois resolvem metades diferentes do problema:
| Lambda MicroVMs | Nitro Sandboxes | |
|---|---|---|
| Onde roda | gerenciado pela AWS, serverless | nas suas instâncias EC2, no ECS Managed Instances ou em nodes do EKS |
| Início | ~1,8 s a partir de um snapshot (meu teste) | ~2 s no EC2, ~5 s como pod do EKS em um node já aquecido; boot a frio toda vez |
| Suspender e retomar com a memória | sim | não (o guia do EC2 descarta snapshot, pausa, retomada e migração ao vivo) |
| Atestação e liberação via KMS | não documentado | sim, nos três pontos de entrada |
| Oculto dos seus próprios operadores | n/a (não há instância pai que você opere) | sim, no modo de memória confidencial |
| Preços | por segundo de vCPU e memória (post de preços) | sem custo adicional; você paga pelas instâncias, e a densidade é o custo |
| GPU | não | não |
Se os seus sandboxes ficam ociosos com frequência e precisam voltar com a memória, ou se você não quer instância nenhuma, as Lambda MicroVMs se encaixam melhor. Se você já roda ECS ou EKS, quer fazer bin-packing de workloads não confiáveis na sua própria capacidade, ou precisa provar o que está rodando, os Nitro Sandboxes se encaixam melhor.
Configuração
Não há nada para instalar nesta visão geral. Estas são as verificações que eu faria antes de escolher um caminho.
O meu tipo de instância tem suporte? Os Nitro Sandboxes precisam de um tipo de instância que rode Nitro Enclaves, então NitroEnclavesSupport é o primeiro campo a verificar:
aws ec2 describe-instance-types --region us-east-1 \
--instance-types m8g.large m8g.xlarge m7i.large m7i.xlarge \
--query 'InstanceTypes[].[InstanceType,VCpuInfo.DefaultVCpus,NitroEnclavesSupport]' --output table
| m7i.xlarge | 4 | supported |
| m7i.large | 2 | unsupported |
| m8g.xlarge | 4 | supported |
| m8g.large | 2 | supported |
O padrão que sai da tabela do guia do EC2: a maioria das famílias atuais tem suporte, exceto o menor ou os dois menores tamanhos e os tamanhos .metal. Na prática, isso significa .xlarge para cima em Intel e em AMD da 5ª à 7ª geração (m5a, m6a, m7a e as irmãs c e r delas), e .large para cima em Graviton e em AMD de 8ª geração (m8a, c8a, r8a). As instâncias com GPU aparecem na lista, mas o passthrough de GPU para dentro de um sandbox não está disponível. As duas listas não são idênticas, porém, e o guia do EKS chama os tipos com suporte a sandbox de “um subconjunto” dos tipos do Enclaves. Para as famílias de CPU, a tabela de sandboxes do guia do EC2 bate hoje com a tabela do Enclaves; para instâncias aceleradas ela é mais curta (sem P5 nem Trn2, por exemplo), então confira a tabela de sandboxes ali.
As minhas ferramentas são recentes o bastante?
aws --version # 2.39.7 or later for the ECS fields (Homebrew had 2.39.6 on November 9)
kubectl version # EKS needs Kubernetes 1.36 or later on the cluster
Qual caminho?
- EKS no Auto Mode: nada a habilitar em um cluster em uma Região comercial dos EUA; defina
runtimeClassNameno pod. No Graviton você precisa de um NodePool próprio, porque o pool embutidogeneral-purposeé só amd64. - ECS: só no Managed Instances; crie um capacity provider com o Nitro Enclaves ligado e depois defina
isolationModena task definition. - EC2: habilite o Nitro Enclave na instância, reserve um pool de memória e rode você mesmo o Firecracker.
Testes
Cada uma das três partes hands-on tem os próprios testes. Estes são os números principais lado a lado, todos em m8g.xlarge na us-east-1:
| EC2 | ECS | EKS | |
|---|---|---|---|
| Como ligar | Nitro Enclave: Enable + Firecracker | checkbox do capacity provider + isolationMode | runtimeClassName |
| Primeiro sandbox, incluindo a inicialização da instância | n/a (manual) | 34 s, da task criada até RUNNING | 50 s, do pod criado até Ready (85 s na minha primeira rodada) |
| Sandbox em uma instância já aquecida | até o SSH: 1,7 s direto, 1,9 s confidencial, ~3,1 a 3,2 s com um kernel de guest AL2023 | primeira task: ~6 s da imagem baixada até o container iniciado (não cronometrei uma rodada isolada já aquecida) | 4,4 a 5,4 s até Ready (pod comum: 1,7 a 2,1 s) |
| Overhead de memória por sandbox | 2 MiB + 16 MiB por dispositivo | 262 a 509 MiB | 256 Mi / 512 Mi |
| Máximo de sandboxes na m8g.xlarge | 20 (com cpu_overcommit) | não medido; a CPU acabou primeiro, com 1 vCPU por task | 20 anunciados; de 18 a 20 rodaram nos meus testes |
| Metadata da instância por dentro | IMDS da instância pai, a menos que bloqueado | nenhuma resposta | substituto: só paths de placement e de endpoints de serviço |
| Atestação + demo do KMS | funcionou (PCR0 fixado) | funcionou (PCR17 + PCR8:ServiceName fixados) | funcionou (PCR17 + PCR8:ServiceName fixados) |
| Workload alterado | recusado pelo KMS | policy denied Agent::Action::"CreateContainer" | policy denied Agent::Action::"CreateContainer" |
| Onde a AWS mostra o sandbox | em lugar nenhum: só o “Enclaves Support: Enabled” da instância pai | o campo “Trusted execution” da task e o trustedExecutionSummary | o runtimeClassName do pod, na visualização Raw do console |
O CPUUtilization do EC2 conta o trabalho do sandbox | sim: 51% com 2 de 4 vCPUs ocupadas | sim | sim: 26% com 1 de 4 ocupada |
| O monitoramento dentro do host enxerga o sandbox | não: o top da instância pai ficou 95% ocioso | o Container Insights reporta a task, mas não o overhead de memória dela | não: a CPU do node e o Container Insights ficaram inalterados, sem registros para pods em sandbox; o kubectl top pod enxergou |
Alguns desses resultados contradizem a documentação de 9 de novembro, ou vão além dela:
- EC2: um sandbox de 1 GiB falha a menos que você reserve um pool de memória no boot; o guia revisado agora torna o pool obrigatório. Eu rodei 80 vCPUs de sandbox em uma instância de 4 vCPUs, apesar do limite documentado de cinco vezes, que o guia revisado ainda informa; o limite que de fato se aplicou foi o de 20 sandboxes. Um reboot dentro do guest deixou o sandbox rodando e ocupando o slot dele, embora o guia diga que ele para.
- ECS: o console tem os controles do recurso (uma checkbox no capacity provider, um controle “Isolation mode” na task definition) que a documentação nunca menciona. O substituto de metadata documentado não respondeu. Rolling updates de serviços em sandbox criados pelo console falharam com um erro de pre-ingest da imagem e fizeram rollback, cinco vezes em cinco, até eu desligar a consistência de versão do container; serviços criados pela CLI não falharam.
- EKS: a RuntimeClass não tem toleration, ao contrário do que diz o blog de lançamento. O token da service account é montado no modo isolado, ao contrário do que diz a documentação. O node anuncia 20 slots de sandbox, mas só de 18 a 20 pods em sandbox rodaram nos meus testes, e eu não descobri o porquê. O Container Insights não tinha registros para pods em sandbox.
Nos três, o registro de Decrypt do KMS no CloudTrail traz os campos de atestação, com os PCRs em base64. No EC2, uma chamada negada não trazia nenhum deles, então o CloudTrail não mostra qual imagem o KMS recusou.
Veredito
Os Nitro Sandboxes são a resposta mais prática que a AWS já lançou para rodar código não confiável ao lado de código confiável em capacidade compartilhada. A fronteira é real (eu consegui verificá-la do lado da instância pai no EC2), a atestação funciona com o AWS KMS comum nos três serviços, e no ECS e no EKS o opt-in é de fato um campo por task ou pod (depois que o ECS tem um capacity provider com o Nitro Enclaves ligado), sem cobrança extra.
Eles não saem de graça em capacidade. Espere algumas centenas de MiB por sandbox no ECS e no EKS, no máximo cinco sandboxes por vCPU, nada de GPU, nada de hostNetwork, e pods que iniciam em cerca de cinco segundos em vez de dois. No ECS e no EKS, o modo confidencial também pede que você abra mão de algo: nada de exec, e uma policy para regenerar no CI sempre que a spec mudar. Confira também o seu monitoramento: a métrica de CPU da instância conta o trabalho dos sandboxes nos três, mas as ferramentas que leem o host, como o top da instância pai no EC2 ou o Container Insights no EKS, não enxergam o lado de dentro.
A minha recomendação para cada caminho:
- EKS Auto Mode é o caminho mais tranquilo: nenhuma configuração no cluster, o substituto de metadata mais bem-comportado e geração de policy nativa do Kubernetes.
- ECS tem a melhor experiência no console e a contabilização por task mais clara, mas só funciona no Managed Instances, e os rolling updates de serviços criados pelo console falharam até eu desligar a consistência de versão, então teste o seu caminho de deploy primeiro.
- EC2 é para times que querem a primitiva bruta e estão prontos para rodar o Firecracker, um pool de memória e o próprio pipeline de atestação. Isso é trabalho para um time de plataforma, não uma checkbox.
Se você não quer instância nenhuma, as Lambda MicroVMs continuam sendo a alternativa gerenciada, com snapshots em vez de atestação.