Rootless Podman vs Rootful with User Namespaces
Rootless Podman is often presented as the secure way to run containers, full stop. Bundar currently runs rootful Podman with --userns=auto instead. Not because rootless is bad — rootless also reduces risk in the Podman management plane — but because automatic user namespaces give our workloads an additional UID boundary while rootful Podman keeps host networking and system integration straightforward for the servers Bundar manages today.
This is the companion to our userns=auto deep-dive; that post explains the mechanism, this one explains the choice.
What rootless Podman gives you
Running Podman as an unprivileged user means everything — image pulls, container setup, the conmon monitor processes — runs without host-root privileges. If an attacker escapes a container, they land with only that user's privileges. There is no root daemon to target at all. On a shared developer machine or a multi-user host, that is a meaningful layer of protection, and we recommend it there without hesitation.
Workload isolation: the user namespace
User namespaces are an important part of the workload boundary, but they are not equivalent to running the whole container engine rootless. With --userns=auto, each container gets its own subordinate UID/GID range, and UID 0 inside the container maps to an unprivileged UID on the host. For operations that remain subject to that mapping, the kernel evaluates host permissions using the mapped identity instead of host UID 0.
Rootless Podman adds another boundary around the management plane itself: Podman and its helpers run without host-root privileges. That is strictly stronger than only applying a user namespace to a rootful container, even though both approaches use the same kernel primitive for UID mapping.
What we run today
Bundar's current automated server setup is rootful. It installs and enables system-level Podman services, provisions subordinate IDs for automatic user namespaces, and gives every application container --userns=auto. The setup currently assumes a root SSH account, so the Podman management plane still has host-root privileges while application UIDs are mapped into subordinate ranges.
The honest tradeoff, both directions
What rootless does better: the management plane. With rootless, Podman itself never holds root, so a vulnerability in the runtime or its helpers is contained to the invoking user. In our setup, that plane still runs as root, and we won't pretend otherwise.
What rootful with --userns=auto does better, and why it matters on a server whose only job is running your apps:
- Low ports without extra host configuration. Rootful services can bind ports below 1024 directly.
- Straightforward storage compatibility. Rootless Podman supports native OverlayFS on modern kernels, but older kernels and some backing filesystems can still require
fuse-overlayfsor additional storage configuration. - Kernel bridge networking by default. Rootful Podman uses the host's bridge networking directly; rootless networking commonly uses
pastaor rootless port-forwarding paths with different behavior and constraints. - Plain systemd units. System units do not need per-user
lingerconfiguration to stay available after logout.
Fewer layers between your application and the kernel means fewer things to debug at 2 AM.
Why it's the right call for a deployment platform
Our servers are single-purpose: one deploy account, running your workloads, nothing else. The multi-user protection that makes rootless shine on shared machines doesn't apply here — there is no second user to protect workloads from. What does apply is operational simplicity, and rootful with automatic user namespaces gives us the workload UID isolation we want with fewer rootless-specific networking, storage, and systemd considerations.
Daniel J Walsh has described rootless Podman with --userns=auto as "probably the most secure" combination. That pairing is stronger than what Bundar runs today because it constrains both the management plane and the workload UID mapping. We currently choose the rootful half of that tradeoff for simpler host integration on single-purpose app servers, while keeping --userns=auto on every application container.
What would make us reconsider
If the threat model changed — say, mutually untrusting tenants sharing one host — the management-plane argument for rootless would win outright, and we'd switch. Security choices should follow the threat model, not the slogan. Ours says: contain the workloads with user namespaces, keep the platform simple, and be explicit about where root still lives.