Rootful, Rootless or Sandboxed: A ContainerOps Comparison

Health Tech

Clinic and hospital web teams often run a small number of containers on one host: a website, a booking form handler, a document viewer, a scheduler for reminders. The big question is rarely which orchestration platform to adopt. It is how to run those few containers in a way that is safe enough and simple enough for a small team. This comparison weighs three operating styles, with the Ops Atlas (an xOps School reference) as the yardstick. Everything here concerns administration of software; none of it addresses clinical matters.

A word on the term first. The Atlas treats ContainerOps as a non-standard label, which it applies to the operation of individual containers below any orchestrator, and it notes that unrelated projects use the same name. The comparison below sits wholly inside the scope list on the Atlas ContainerOps page: runtimes, namespaces, control groups, rootless operation and single-host setups.

The three contenders

  1. Rootful with a standard engine. The container engine runs with administrator rights and starts containers on request. This is the default most tutorials assume.
  2. Rootless. The engine and the containers run under an ordinary user account. Podman and recent Docker versions both support this mode.
  3. Sandboxed. A runtime such as gVisor or Kata places an extra isolation layer between the container and the shared kernel.

Criterion 1: How much damage can a breakout do?

All three styles use namespaces and control groups to separate containers, but they differ in what happens if something escapes. The Atlas is clear that namespaces do not turn a container into a virtual machine, because the kernel is shared. In a rootful setup, an escape can land the attacker with administrator rights on the host. Rootless limits that outcome to one unprivileged account. Sandboxed runtimes add a barrier meant to stop the escape in the first place.

Real events illustrate the stakes. The Atlas cites a flaw in the low-level runtime published on 31 January 2024, in which leaked file descriptors allowed breakouts, fixed in version 1.1.12. It also cites an advisory dated 5 November 2025 whose guidance favours user namespaces that leave the host’s root unmapped, and rootless operation. Neither event proves one style flawless, but together they favour designs that reduce what a breakout can reach.

Criterion 2: Resource limits that actually work

Here rootful wins on simplicity. Memory, process and CPU limits behave as documented. In rootless mode, the Atlas lists several caveats: limit flags may quietly do nothing when cgroup v2 and systemd are absent, CPU limits require a delegated CPU controller, and the hosts must be configured accordingly. A team that adopts rootless without checking these may think it has limits when it does not. The check is easy: start a container with a small memory limit and confirm the limit appears in its configuration and is enforced.

Sandboxed runtimes bring their own accounting. They are designed for isolation first, and performance overhead varies by workload, so test your own services rather than relying on rules of thumb.

Criterion 3: Networking and ports

This is where rootless exacts a price. The Atlas notes that ports below 1024 need a system setting change, overlay networks are unsupported and user-mode networking is slower than the kernel path. For a small web tool behind a reverse proxy, those limitations rarely hurt. For a service that moves large volumes of data between containers, they might.

Rootful engines have a different networking hazard, and it is the same for rootless engines that publish ports. Published ports can bypass host firewall tools, and a mapping without a host address binds every interface. Whichever style you pick, bind to 127.0.0.1 and use internal networks for traffic that has no reason to leave.

Criterion 4: Day-to-day effort

Rootful is the least work to begin with, which is why it is common. It is also the style where convenience hides risk: access to the Docker socket and membership of the docker group are, in the Atlas, equivalent to root. Rootless asks for more care at setup, in return for a smaller blast radius, and it fits well with Podman features such as Quadlet units and auto-update. Sandboxed runtimes demand the most deliberate configuration and are normally reserved for workloads that include code you do not control.

Criterion 5: Compatibility

Images built to the OCI format run in all three styles. That portability is a major reason the standards matter: the Atlas shows the shared formats as mature: the image spec is on 1.1.1 and the runtime spec on 1.3.0, so tool choice rarely locks you in. Some software that expects to open privileged ports, load kernel modules or mount special file systems may not run in rootless or sandboxed modes without changes. Test before committing.

A test you can run in an afternoon

You do not have to take any of this on faith. Pick a throwaway service and run it in each style on a spare host. For each run, answer five questions and write the answers down. Does the container start as an ordinary user? Is the memory limit visible and enforced when you push the process past it? Does a stop request finish within the grace period, or does the status end with 137? Which ports are reachable from another machine? How long does a fresh pull and start take compared with the other styles?

Five answers across three styles gives you a small grid, and the grid usually settles the debate. Teams are often surprised that the extra setup for rootless turns out to cost an hour, not a week, and that the odd friction points they feared, such as privileged ports, never touch their actual services.

Side-by-side summary

  • Isolation strength: rootful lowest, rootless middle, sandboxed highest.
  • Setup effort: rootful lowest, rootless moderate, sandboxed highest.
  • Limit behaviour: rootful predictable, rootless dependent on cgroup v2 and delegation, sandboxed varies.
  • Network performance: rootful best, rootless slower in user mode, sandboxed workload dependent.
  • Best fit: rootful for trusted internal tools with tight configuration, rootless for most public-facing small sites, sandboxed for untrusted code.

Hidden costs that do not show in a feature table

Every column in a comparison hides a maintenance bill. Rootful is cheap on day one and expensive after an incident, because every container effectively holds a copy of the host’s keys. Rootless is a little more work up front and gives back a calmer risk profile, but it depends on host settings that can drift, so someone must own them. Sandboxed runtimes add yet another component to patch and track through its own lifecycle. The Atlas stresses currency of the runtime as a metric, and gives dates to show why: support for one popular runtime line already lapsed at the end of September 2026.

Which one for a typical clinic website team?

For a team running a handful of public-facing tools, rootless is the sensible default today, provided the hosts run cgroup v2 with systemd so limits work. Keep rootful for cases where a specific requirement forces it, and then compensate: drop all capabilities, run as an ordinary user inside the container, make the root file system read-only and keep the socket private. Reserve sandboxing for anything that processes files or code from outside the organisation.

Whichever you choose, the habits do not change. Deploy by digest, set memory and process limits, rotate logs, and keep an inventory with owners. The Atlas also recommends measuring: digest coverage in production, base-image age and the throttle ratio, with under five percent as the aim for latency-sensitive services.

A comparison needs a ledger

Comparisons like this are only useful if the numbers are recorded. A tidy record is the same idea behind a household or business budget. If you enjoy that angle, the site’s piece on a festival-season budget planner that keeps gifts and bills in check and the one about a simple farm budget book for village families both show how a plain notebook makes decisions easier. Do the equivalent for your hosts: a single page per server stating which style runs there, which limits were tested, when it was last reviewed and who answers for it.

Pick a style deliberately, test its caveats on a throwaway container, and write down what you found. A team that can explain why it chose rootless, and what it checked, is better placed than one that inherited a setup from a tutorial.