Nitro Sandboxes Isolate the Kernel, Not Your Threat Model
Add one pod field and every opted-in EKS pod gets its own Firecracker microVM, its own guest kernel, no shared memory mappings with the host or with its neighbors.
That’s AWS Nitro Sandboxes, launched this week with no extra charge and availability across all commercial regions. The EKS documentation describes a containerd-shim-nitro-sandbox-v2 process on the parent instance that boots the microVM, after which an agent inside runs the pod’s containers through its own containerd, and both sides talk over virtio and vsock.
The isolation is real. Containers share a kernel, which means a kernel bug is a cross-tenant bug; Firecracker’s attack surface is far smaller, and AWS has been running untrusted code behind it since Lambda. So why am I not excited? Because a pod field is a deployment knob, not a security boundary, and the interesting question is which side of the boundary you’re allowed to distrust.
Isolated mode trusts the parent
In isolated-sandbox mode you keep kubectl exec, logs, and process listing. For coding agents that’s the whole selling point: you can watch what the agent does while it writes to your repo. The trust model is one-directional, and Sandip Das, an AWS Container Hero who went through the documentation, stated it more precisely than the launch post: a compromised parent can observe or tamper with the guest’s unencrypted traffic and DNS, rewrite the pod’s /etc/hosts, and mint Pod Identity credentials for any pod on that node.
Fine if the node is yours. It stops being fine when the untrusted thing in your threat model is smart enough to come back up the channel.
confidential-sandbox flips that assumption. Enforcement moves inside the VM: a Cedar policy generated from the pod spec pins image digests, arguments, environment, mounts and capabilities, exec and stdin are denied, the Nitro Secure Module measures image and policy into PCRs, and a KMS key policy can release secrets only to a sandbox whose measurements match.
Attestation without a verifier is decoration. The docs say it outright: with no KMS policy and no external verifier checking PCR values, the measurement is recorded but never verified, and the confidentiality guarantee stays incomplete. People will ship confidential mode with no verifier and call it done. I’ve watched that happen with TPM attestation setups on bare metal fleets, twice.
The density arithmetic nobody quotes
AWS calls performance near-native. Vendor claim until you measure startup latency, I/O throughput, and tail latency on your own nodes. The caps matter more than the adjective.
Total sandbox vCPUs can’t exceed five times the node’s vCPU count, and neither can the sandbox count, halved on CPU-overcommit instance types. A 4-vCPU node holds twenty 1-vCPU sandboxes or five 4-vCPU ones.
SMT makes those numbers worse. Core scheduling stops two sandboxes from sharing sibling threads of one core, so on an Intel box roughly half the advertised vCPUs are usable. Graviton, one thread per core, sidesteps it entirely. Four nodes of headroom on paper is often two in production, and a capacity plan built from the spec sheet will be wrong in the same direction every time.
No GPU passthrough at launch. Firecracker can’t hand host devices to a guest, so GPU pods run without the sandbox class and you’re back to plain containers. The mistake I expect is a team reading “microVM” and concluding the node-to-pod chain is now trusted end to end.
Where this differs from gVisor
GKE Sandbox has shipped a gVisor RuntimeClass since 2019, and more recently a microVM class on Kata Containers with Cloud Hypervisor. gVisor traps syscalls in a userspace kernel and starts in under 200 ms. Kata is closer to what AWS built, same VM boundary, different bookkeeping: 250 mCPU and 130 MiB fixed per pod, one to two seconds of startup, no GPUs either.
The split is honest. gVisor wins on start latency and compatibility work Google already did. AWS expresses overhead as density and thread scheduling rather than per-pod resource reservation, which changes the cost model without changing the ceiling.
A microVM protects the kernel from the code. It does not protect the code from the operator, the control plane, or the credentials the node can mint. Confusing those two is how teams end up with sandboxing that reads well in a compliance document and leaks in the incident report.
Two operational gotchas, each worth an afternoon. Standard EKS needs a sandbox-enabled AMI for node groups or Karpenter, and the managed node group launch template must have Nitro Enclaves enabled or sandboxed pods sit in Pending with no useful event. Kubernetes 1.36 or later, and Pod Identity rather than IRSA for credentials. Auto Mode provisions both RuntimeClasses for you; everything else you assemble.
For warm starts, the open-source agent-sandbox project hands out pre-booted VMs in roughly two seconds. That’s the gap between a sandbox per task and a sandbox per session, and for agent workloads it decides whether the design is viable at all.
My read for shared control planes: don’t put a coding agent with repo write access into isolated-sandbox and treat the node as trusted while a customer pod sits on it. Use confidential mode with a real verifier, or dedicate the node group. The third option, staying on plain containers because microVMs feel like overhead, is the one I’d argue against hardest.
Read the considerations page before the blog post. The blog post is where the feature lives; the considerations page is where your capacity model goes to die.