deniz.in

Markets

Weather

Loading weather

· via dev.to (home feed)

AWS Nitro Sandboxes gives each EKS pod its own hardware-isolated virtual machine

AWS has announced Nitro Sandboxes for Amazon EKS, running each pod in its own lightweight VM on the Nitro hardware layer. On EKS Auto Mode, opting in means setting a single runtimeClassName field.

AWS Nitro Sandboxes gives each EKS pod its own hardware-isolated virtual machine

AWS has announced a new isolation mechanism for Amazon Elastic Kubernetes Service. According to a dev.to write-up of the launch, a feature called Nitro Sandboxes — announced on 9 November 2026 — runs each Kubernetes pod inside its own lightweight virtual machine, using the Nitro System hardware layer that already keeps EC2 instances apart from one another.

A single field turns isolation on

On EKS Auto Mode the feature needs no installation: both runtime classes ship with every cluster, and a pod opts in by setting runtimeClassName to isolated-sandbox. Nothing else in the deployment changes — images, Helm charts and delivery pipelines stay as they are, and the pod keeps its Pod Identity credentials, EBS and EFS volumes, CloudWatch metrics and VPC CNI networking. The dev.to post reports that AWS claims every Kubernetes conformance test passes with sandboxes enabled. Clusters on standard EKS, rather than Auto Mode, need a sandbox-capable AMI.

A second runtime class, confidential-sandbox, sits alongside the first; running kubectl get runtimeclass on an Auto Mode cluster lists both.

Two threat models

Isolated mode answers one question: how to protect the host node and neighbouring pods from whatever runs inside the container. That covers agent workloads, multi-tenant SaaS and privileged build jobs.

Confidential mode answers a different question, in which the person operating the cluster is treated as untrusted. According to the source, an AWS KMS secret is released only when presented with an attestation document that names the expected system image and Cedar policy, providing cryptographic proof of the code running in the sandbox. AWS also states that the design prevents a cluster administrator from reading a pod's memory, which, as the dev.to post notes, changes who can safely hold cluster-admin rights on a shared platform. The post points to HIPAA, PCI DSS and FedRAMP contexts, where evidence that a workload ran untampered is increasingly requested.

What happens when a pod boots

The sequence the dev.to article describes runs in five stages, none of which alter the Kubernetes API. The scheduler places the pod normally; the RuntimeClass carries the node selector and toleration, so on Auto Mode the pod lands on a sandbox-capable node without extra spec fields. EKS then requests a Nitro Partition from EC2 and boots a lightweight VM inside it, after which the Nitro Hypervisor enforces the CPU and memory boundary in hardware. Inside the guest, a 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 under a standard container runtime.

From the outside the pod looks ordinary: logs, exec, port-forward, probes and metrics flow back to the kubelet over an internal control channel. From the inside the sandbox is detectable — AWS's example shows the product name file under /sys/class/dmi/id returning 8i.enclave, and block devices named vda, vdb and vdc where a regular pod on the same node sees nvme0n1-style devices.

Egress is declared, not assumed

The launch includes a worked example of a coding agent that reads a GitHub issue, writes a fix, runs the tests and opens a pull request. Its entire external surface is declared in the pod: model access is an IAM role scoped to bedrock:InvokeModel* through Pod Identity, with no long-lived API keys, and repository access is a short-lived fine-grained token mounted as a Secret, limited to contents and pull-request read and write plus issue read on a single repository.

Everything else is refused by an EKS Auto Mode ApplicationNetworkPolicy that permits egress only to CoreDNS and HTTPS on the Bedrock and GitHub hostnames. A standard Kubernetes NetworkPolicy cannot match hostnames; this policy type can, though AWS notes it requires setting enable-network-policy-controller to true in the amazon-vpc-cni ConfigMap in kube-system, and that the sample needs a GitHub App token if the pull request should show a bot author.

What the VM boundary does not cover

CPU and memory are carved out per sandbox in hardware, so neither the EC2 host nor a neighbouring pod can reach that slice. The rest of the node is shared by design: network bandwidth, disk I/O, DNS queries, log output and connection tracking entries all pass through the same kernel, and AWS applies configurable throttles to each by default so a runaway agent hits its own ceiling rather than the node's. The throttles ship enabled, and platform teams can raise them per workload.

Two limits are flagged in the coverage. The egress policy matches hostnames, so a different name that resolves to the same addresses as an allowed one stays reachable, and node-level resources keep a shared path between tenants.

Why it matters

Containers on a shared kernel make one container's kernel bug a problem for every neighbour, and the usual fix — a dedicated machine per sensitive workload — wastes most of the machine. Nitro Sandboxes offers a third option: a hardware-enforced boundary per pod that preserves scheduling behaviour, volumes, credentials and observability. For multi-tenant platforms, AI agents executing partly trusted code and regulated workloads that need attestation evidence, that is a meaningful new default. The remaining shared paths mean it is a strong boundary rather than a total one, and platform teams will still need to reason about co-tenancy when packing nodes.

  • #kubernetes
  • #aws
  • #security
  • #cloud
  • #containers

Related posts