Kubernetes v1.36: User Namespaces Reach General Availability

User Namespaces in Kubernetes have finally reached General Availability (GA) with the v1.36 release, marking a significant milestone for container security. This Linux-only feature allows workloads to run with “rootless” isolation, meaning processes inside containers can have root privileges without granting the same power on the host. It also introduces critical patterns like namespaced capabilities, enabling new use cases that were previously impossible without fully privileged containers. Below, we answer key questions about this feature, its mechanics, and how to use it.

What is the significance of User Namespaces reaching GA in Kubernetes v1.36?

The GA of User Namespaces in Kubernetes v1.36 is a long-awaited milestone for low-level container runtimes and rootless technologies. After several years of development, this feature now provides production-ready security isolation for Kubernetes workloads. It allows containers to run with root privileges inside their own user namespace without having those privileges on the host. This is a fundamental shift because previously, any process running as UID 0 inside a container was seen as root on the host, making container escapes extremely dangerous. With User Namespaces, the kernel remaps UIDs so that even if an attacker breaks out, they have no special powers on the host. This GA means that enterprises can now adopt this security practice at scale.

What problem does User Namespaces solve regarding UID 0?

A process running as root (UID 0) inside a container appears to the kernel as root on the host. If an attacker exploits a kernel vulnerability or misconfigured mount to escape the container, they gain full root access on the host. While other security measures exist, they don’t change the underlying identity of the process. User Namespaces solve this by mapping the container’s UID 0 to a high, unprivileged UID on the host. This way, even if the process breaks out, it has no special privileges. The container retains full root capabilities inside its namespace (such as running iptables or binding to low ports), but those capabilities are namespaced and cannot affect the host. This dramatically reduces the attack surface for containerized workloads.

What is ID-mapped mounts and how does it enable User Namespaces?

ID-mapped mounts are a Linux kernel feature (introduced in 5.12 and refined later) that transparently remaps UIDs and GIDs at mount time. Without this, enabling User Namespaces was expensive: the Kubelet had to recursively chown every file in attached volumes so the container could read and write them. For large volumes, this startup cost was prohibitive. With ID-mapped mounts, when a volume is mounted into a Pod with User Namespaces enabled, the kernel performs an O(1) translation. To the container, files appear owned by UID 0; on disk, their ownership is unchanged. No chown is needed, making the operation instant and efficient. This was a key enabler that allowed User Namespaces to move from alpha to GA.

How do you enable User Namespaces in a Pod spec?

Enabling User Namespaces in Kubernetes v1.36 is straightforward. In your Pod specification, set hostUsers: false. This opts out of the host user namespace and requests a dedicated user namespace for the Pod. No changes to container images or complex configuration are required. Here’s an example:

apiVersion: v1
kind: Pod
metadata:
  name: isolated-workload
spec:
  hostUsers: false
  containers:
  - name: app
    image: fedora:42
    securityContext:
      runAsUser: 0

You can set runAsUser: 0 as usual; the kernel will map it to a high UID. The same interface has been stable since the alpha phase. For more details, see the previous blog posts on User Namespaces (alpha, beta, and GA).

What new use cases does User Namespaces enable?

User Namespaces enable workloads that need root privileges inside the container while remaining confined. For example, setting hostUsers: false with capabilities like CAP_NET_ADMIN becomes namespaced: the container can manage its own network interfaces, firewall rules, or routing tables without affecting the host. This was previously only possible with fully privileged containers, which were risky. Now, operators can safely run network tools, VPN clients, or container-level firewalling. Other use cases include running init processes, mounting filesystems inside the container, or using setuid binaries—all without granting host root. This effectively bridges the gap between security and functionality for many cloud-native applications.

How does User Namespaces improve security for privileged containers?

The GA of User Namespaces introduces a critical pattern: running workloads with privileges while still being confined in the user namespace. When hostUsers: false is set, capabilities like CAP_NET_ADMIN or CAP_SYS_ADMIN are namespaced. This means they grant administrative power only over container-local resources, not the host. For instance, a container can use iptables to manipulate its own network stack, but cannot affect host networking. This is a massive security improvement because it limits the blast radius if a container is compromised. Previously, such capabilities required a fully privileged container that could potentially damage the host. Now, operators can grant necessary privileges with confidence that even if an attacker escapes the container, they won’t have host root.

What is the impact on container images and configuration?

One of the best aspects of User Namespaces in Kubernetes v1.36 is that it requires no changes to container images or existing configurations. The feature works transparently: you simply add hostUsers: false to your Pod spec. Your images continue to run with runAsUser: 0 if needed; the kernel handles the UID remapping. There is no need to rebuild images or adjust file ownership in the container filesystem. This backward compatibility eases adoption. However, keep in mind that User Namespaces currently only work on Linux nodes, and the feature relies on the ID-mapped mounts kernel capability. For stateful workloads, ensure your storage provider supports this feature. Overall, the impact on operations is minimal while the security benefits are substantial.