segunda-feira, 16 de novembro de 2026 Edição nº 240
Buscar
Avaliação Conduzido por humano, com apoio de IA · Infraestrutura · 24 min de leitura

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...
O que é isso?

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.

GitHub Veja o código-fonte aqui: aws-nitro-sandboxes

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

TRÊS PONTOS DE ENTRADA EC2 (parte 2) Advanced details › Nitro Enclave: Enable você roda o Firecracker 1.18: "enclave": {} ou {"direct_mode": true} você cuida da imagem, rede e atestação ECS Managed Instances (parte 3) capacity provider: Turn on Nitro Enclaves task definition: trustedExecutionConfiguration ISOLATED_SANDBOX | CONFIDENTIAL_SANDBOX agente de sandbox do ECS no guest EKS Auto Mode (parte 4) Kubernetes 1.36+, nada a habilitar runtimeClassName: isolated-sandbox ou confidential-sandbox (+ Cedar policy) shim do containerd opera o Firecracker UMA PRIMITIVA · uma instância EC2 iniciada com o Nitro Enclaves habilitado Instância pai driver nitro_enclaves (/dev/nitro_enclaves) doa vCPUs e memória contígua memória sem overcommit no máximo 5 sandboxes por vCPU (20 em uma m8g.xlarge de 4 vCPU) containers comuns continuam rodando aqui, no kernel compartilhado do host sem KVM, sem .metal, sem virtualização aninhada Nitro Sandbox guest de primeiro nível do hypervisor Nitro kernel próprio, boot UEFI, disco e NIC virtio memória confidencial: instância pai não lê RAM memória direta (só EC2): instância pai lê o Nitro Secure Module (NSM) assina documentos de atestação com PCRs inicia em ~2 s no EC2, ~5 s como pod do EKS AWS KMS kms:RecipientAttestation: ImageSha384 (PCR0) PCR17 (Cedar policy) PCR8:ServiceName libera uma chave só para um workload medido, selada a um par de chaves que só o guest possui

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 sandboxSandbox, instância pai confiávelSandbox, 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_SANDBOXCONFIDENTIAL_SANDBOX + attestationPolicy
EKS (runtimeClassName)(nenhum)isolated-sandboxconfidential-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 fazer kubectl 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-genpolicy ou pelo ecs-nitro-sandbox-genpolicy da 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:

PCRO que ele mede
PCR0, PCR1, PCR2a imagem de boot (kernel, initrd, linha de comando); o PCR0 também registra flags de inicialização, como o overcommit de CPU
PCR3, PCR4a role do IAM e o ID da instância pai
PCR5, PCR6os 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)
PCR8o 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
PCR17a 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 comumEm um Nitro Sandbox
Kernelo do host, compartilhado com todos os vizinhoso próprio (por exemplo, 6.18.54 em um sandbox do EKS em um node 6.18.56)
O que nproc e MemTotal mostramo host inteiro (4 vCPU, 16 GiB)o sandbox (1 vCPU, ~650 MiB para um request de 512 Mi)
hostNetwork / modo de rede hostpermitidoEKS: pod travado com hostNetwork is not supported for nitro-sandbox pods; ECS: rejeitado no registro
hostPID / pidMode: host + privilegedos processos do hosto systemd e os ~170 processos da própria VM do sandbox
Metadata da instânciadepende do seu bloqueioEKS: 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 deleroot no hostningué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 sandboxMáximo de sandboxes na m8g.xlarge
EC2 (autogerenciado)2 MiB, mais 16 MiB por dispositivo virtio no modo confidencial20 (com cpu_overcommit e o orçamento de slots aumentado de 4; 3 com núcleos dedicados)
ECS262 MiB para uma task de 512 MiB ou 1 GiB, até 509 MiB para 8 GiBnã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
EKSoverhead 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 MicroVMsNitro Sandboxes
Onde rodagerenciado pela AWS, serverlessnas 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óriasimnão (o guia do EC2 descarta snapshot, pausa, retomada e migração ao vivo)
Atestação e liberação via KMSnão documentadosim, nos três pontos de entrada
Oculto dos seus próprios operadoresn/a (não há instância pai que você opere)sim, no modo de memória confidencial
Preçospor segundo de vCPU e memória (post de preços)sem custo adicional; você paga pelas instâncias, e a densidade é o custo
GPUnãonã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 runtimeClassName no pod. No Graviton você precisa de um NodePool próprio, porque o pool embutido general-purpose é só amd64.
  • ECS: só no Managed Instances; crie um capacity provider com o Nitro Enclaves ligado e depois defina isolationMode na 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:

EC2ECSEKS
Como ligarNitro Enclave: Enable + Firecrackercheckbox do capacity provider + isolationModeruntimeClassName
Primeiro sandbox, incluindo a inicialização da instâncian/a (manual)34 s, da task criada até RUNNING50 s, do pod criado até Ready (85 s na minha primeira rodada)
Sandbox em uma instância já aquecidaaté o SSH: 1,7 s direto, 1,9 s confidencial, ~3,1 a 3,2 s com um kernel de guest AL2023primeira 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 sandbox2 MiB + 16 MiB por dispositivo262 a 509 MiB256 Mi / 512 Mi
Máximo de sandboxes na m8g.xlarge20 (com cpu_overcommit)não medido; a CPU acabou primeiro, com 1 vCPU por task20 anunciados; de 18 a 20 rodaram nos meus testes
Metadata da instância por dentroIMDS da instância pai, a menos que bloqueadonenhuma respostasubstituto: só paths de placement e de endpoints de serviço
Atestação + demo do KMSfuncionou (PCR0 fixado)funcionou (PCR17 + PCR8:ServiceName fixados)funcionou (PCR17 + PCR8:ServiceName fixados)
Workload alteradorecusado pelo KMSpolicy denied Agent::Action::"CreateContainer"policy denied Agent::Action::"CreateContainer"
Onde a AWS mostra o sandboxem lugar nenhum: só o “Enclaves Support: Enabled” da instância paio campo “Trusted execution” da task e o trustedExecutionSummaryo runtimeClassName do pod, na visualização Raw do console
O CPUUtilization do EC2 conta o trabalho do sandboxsim: 51% com 2 de 4 vCPUs ocupadassimsim: 26% com 1 de 4 ocupada
O monitoramento dentro do host enxerga o sandboxnão: o top da instância pai ficou 95% ociosoo Container Insights reporta a task, mas não o overhead de memória delanã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.

Comments