Containers

Install Podman on Ubuntu 26.04 LTS (Docker Alternative)

Most Docker habits carry straight over when you install Podman on Ubuntu 26.04, but three of them break on a fresh server. A plain podman pull nginx refuses the short name. A service account created the wrong way breaks on most images, and containers on the default network cannot find each other by name. None of that is a Podman bug. Each one is a design choice in how Podman resolves images, maps users and builds networks, and once you know the mechanism the fix takes one line.

Original content from computingforgeeks.com - post 166061

This guide installs Podman from the Ubuntu archive, reads podman info to show what the stack is made of, and then walks through registries.conf short names, rootless user namespaces, pasta and netavark networking, a Quadlet systemd unit and podman compose. We reproduced every error on purpose and timed image pulls and container starts against Docker on the same VM. The behavior described here was checked against Podman 5.7.0 from the Ubuntu 26.04.1 LTS archive in November 2026, on a fresh lab VM where every output below was captured.

What you need before you start

You need an Ubuntu 26.04 server with a sudo account and outbound HTTPS to Docker Hub and Quay. Rootless containers live in each user’s home directory, so plan disk per user rather than only under /var/lib. If you haven’t looked at what changed in this release yet, the Ubuntu 26.04 LTS features rundown covers the kernel and cgroup changes Podman builds on.

  • Lab VM: 2 vCPU, 8 GB RAM, 30 GB disk, kernel 7.0. That is a floor for testing, not a production size.
  • Production sizing: driven by the images you run, so budget the sum of your containers’ memory plus about 1 GB for the host, and 10 to 20 GB of image storage per active user.
  • Login user: a normal account with an entry in /etc/subuid and /etc/subgid. Accounts made with adduser or useradd on Ubuntu get one automatically; the exception is covered below.

Everything after the install runs as that normal user unless a command starts with sudo, because rootless mode is the reason most people pick Podman over Docker in the first place. Mixing the two modes is the most common source of confusion later, since each keeps its own images, containers and configuration, so decide early which one a workload belongs to.

What the Ubuntu 26.04 archive installs

One apt install podman pulls the whole container stack from the Ubuntu archive, so there’s no PPA or third-party repo to manage. The package brings crun as the OCI runtime, conmon as the per-container monitor, netavark and aardvark-dns for networks, and pasta for rootless networking. The install took 19 seconds on the lab VM.

sudo apt update
sudo apt install -y podman

Check which build landed. On Ubuntu 26.04 the version string comes straight from the archive package, so it only moves when Ubuntu publishes an update, never when upstream tags a release.

podman --version

On the lab VM the archive build reported itself as follows. If you see something newer here, you are running a backport or an upstream build, and some of the error texts below may read differently.

podman version 5.7.0

These are the component versions apt resolved on the lab VM. They matter when you read upstream docs, because a flag added to pasta or netavark after these builds won’t exist here until Ubuntu ships an update.

ComponentArchive package versionRole
podman5.7.0+ds2-3build1CLI and REST API
crun1.21-1ubuntu3OCI runtime that starts the container process
conmon2.1.13+ds1-2Monitors each container, holds its logs and exit code
netavark1.16.1-3.1Creates bridges, firewall rules and port forwards
aardvark-dns1.16.0-3DNS for container names on user networks
passt (pasta)0.0~git20260120.386b5f5-1Rootless network stack and port forwarding
podman-compose (optional)1.5.0-2Compose provider for podman compose

Most of that stack shows up again in podman info, which is the quickest way to confirm the network backend and runtime on any host you inherit. The screenshot below pairs the version check with the package list from apt.

Podman 5.7.0 version and archive package versions with netavark and pasta on Ubuntu 26.04

For the full picture, filter podman info down to the fields that decide how containers behave. Run it as your normal user, not with sudo, because rootful and rootless Podman keep separate storage and configuration:

podman info | grep -E '^  (cgroupManager|cgroupVersion|databaseBackend|kernel|networkBackend|rootlessNetworkCmd|graphDriverName|graphRoot|runRoot):|^    rootless:|^    path: /usr/bin/(crun|conmon)'

Read it top to bottom and the design is visible. Podman hands cgroups to systemd on cgroup v2, stores its state in SQLite, uses netavark for networks and pasta for rootless traffic, and keeps images under the user’s home:

  cgroupManager: systemd
  cgroupVersion: v2
    path: /usr/bin/conmon
  databaseBackend: sqlite
  kernel: 7.0.0-1017-gcp
  networkBackend: netavark
    path: /usr/bin/crun
  rootlessNetworkCmd: pasta
    rootless: true
  graphDriverName: overlay
  graphRoot: /home/gedion/.local/share/containers/storage
  runRoot: /run/user/1001/containers

That graphRoot line is the one people miss. An image pulled with sudo podman lands in /var/lib/containers/storage and is invisible to your user, so a rootless podman run pulls it again. Pick one mode per workload and stick with it.

Why podman pull nginx fails on a fresh install

Podman refuses a bare image name unless it can map that name to exactly one registry, and Ubuntu ships /etc/containers/registries.conf with no search registries at all. Docker silently assumes Docker Hub. Podman treats that assumption as a supply chain risk, because the same short name can exist on several registries with different owners.

Error: short-name “nginx” did not resolve to an alias and no unqualified-search registries are defined

Typing a bare image name is the first thing a Docker user does, and on a stock Ubuntu 26.04 install it fails before any network traffic happens.

podman pull nginx

Podman exits with code 125 and names the file it looked in, which is helpful because it tells you exactly where the fix goes.

Error: short-name "nginx" did not resolve to an alias and no unqualified-search registries are defined in "/etc/containers/registries.conf"

Resolution happens in order. Podman first checks the alias table in /etc/containers/registries.conf.d/shortnames.conf, which maps names such as centos, podman and hello to fixed registries but no nginx. With no alias, it falls back to unqualified-search-registries, and Ubuntu leaves that list empty. Add Docker Hub and Quay to it, once only, because a second run appends a duplicate key that breaks the TOML file:

echo 'unqualified-search-registries = ["docker.io", "quay.io"]' | sudo tee -a /etc/containers/registries.conf

Now try a name that has no alias. In an interactive terminal Podman stops and asks which registry you meant, and the arrow keys pick one:

podman pull traefik/whoami

Two candidates appear because both registries are in the search list now. Podman records the choice once you press Enter, so the next pull of the same name skips the prompt.

? Please select an image:
  ▸ docker.io/traefik/whoami:latest
    quay.io/traefik/whoami:latest
   ✔ docker.io/traefik/whoami:latest
Trying to pull docker.io/traefik/whoami:latest...
Getting image source signatures
Writing manifest to image destination
cd370f99dbfb63a9541c3787c576352d0d22e78fa33ef9d831f97cbeee9667e9

Without a terminal (a script, cron, CI or an SSH command), there’s nobody to ask, so with the default permissive short-name-mode Podman walks the list in order and takes the first registry that has the image (set the mode to enforcing and the same pull errors out instead). Our non-interactive podman pull redis printed Resolving "redis" using unqualified-search registries and pulled from docker.io without a prompt. That’s convenient, and it’s also exactly the ambiguity the prompt exists to stop, so write fully qualified names such as docker.io/library/nginx:latest in scripts, Quadlet files and compose files. The rest of this guide does that.

Podman short-name error and registry selection prompt after editing registries.conf on Ubuntu 26.04

All three stages appear together in the screenshot. You can see the stock error, the one-line fix and the prompt it unlocks, which is the order you will meet them on a new server.

How rootless Podman maps your user to container root

A rootless container runs as your own UID on the host, and root inside the container is just your account seen through a user namespace. The other UIDs a container needs (nginx’s worker user, for example) come from a block of subordinate IDs that /etc/subuid and /etc/subgid reserve for you. Ubuntu’s useradd gave the lab account a block of 65,536, and the idMappings section of podman info shows how Podman uses it:

podman info

In the uidmap part of that output, container UID 0 maps to the account’s own UID 1001, and container UIDs from 1 upward map to the subordinate block that starts at 165536:

    uidmap:
    - container_id: 0
      host_id: 1001
      size: 1
    - container_id: 1
      host_id: 165536
      size: 65536

Start an nginx container as that user. The image name is fully qualified, and port 8080 is above 1024, so no privileges are involved anywhere and nothing in the command needs sudo.

podman run -d --name web -p 8080:80 docker.io/library/nginx:latest
curl -sI http://localhost:8080 | head -3

nginx answers through the rootless port forward. Behind that port sits pasta, running as gedion, which is covered in the networking section further down.

HTTP/1.1 200 OK
Server: nginx/1.31.8
Date: Sat, 14 Nov 2026 09:01:17 GMT

Now look at the mapping itself. With podman top you can print the UID inside the container next to the UID the host sees, and that pair of columns is the clearest proof of what rootless means in practice.

podman top web user huser pid args

The nginx master runs as root inside but as UID 1001 (gedion) on the host, and the workers run as 165636, which sits inside gedion’s subordinate range:

USER        HUSER       PID         COMMAND
root        1001        1           nginx: master process nginx -g daemon off;
nginx       165636      24          nginx: worker process
nginx       165636      25          nginx: worker process 

This matters because a process that escapes the container lands as an unprivileged user that owns nothing outside its own home directory. With Docker’s default rootful daemon, the same escape lands as real root.

Rootless Podman nginx container with podman top showing host UID mapping on Ubuntu 26.04

The screenshot ends with one more line that the code block above doesn’t show. It reads true pasta and comes from podman info --format "{{.Host.Security.Rootless}} {{.Host.RootlessNetworkCmd}}", which confirms both rootless mode and the network helper in one call, so it makes a handy health check in a provisioning script.

What happens when a user has no subuid range

Without a subordinate range, Podman can map only one UID into the container, so any image that ships files owned by another user fails to unpack. Accounts from LDAP or SSSD, and local accounts created with SUB_UID_COUNT=0, are the usual cases. The usermod fix below works on local accounts only; a directory user needs a hand-written line in /etc/subuid and /etc/subgid, or subordinate IDs served by SSSD or FreeIPA. We created one deliberately to capture the failure:

sudo useradd -m -s /bin/bash -K SUB_UID_COUNT=0 -K SUB_GID_COUNT=0 appsvc
sudo -iu appsvc podman run --rm docker.io/library/alpine:latest id

The first command creates an account with no subordinate IDs, which mimics a directory user, and the second asks it for the smallest possible container.

Error: potentially insufficient UIDs or GIDs available in user namespace

Podman warns first, then tries anyway with a single mapping. The alpine layer fails on /etc/shadow because that file belongs to group 42 inside the image, and a namespace with only one UID has nowhere to put group 42.

time="2026-11-14T09:01:22Z" level=error msg="cannot find UID/GID for user appsvc: no subuid ranges found for user \"appsvc\" in /etc/subuid - check rootless mode in man pages."
time="2026-11-14T09:01:22Z" level=warning msg="Using rootless single mapping into the namespace. This might break some images. Check /etc/subuid and /etc/subgid for adding sub*ids if not using a network user"
time="2026-11-14T09:01:22Z" level=warning msg="The cgroupv2 manager is set to systemd but there is no systemd user session available"
time="2026-11-14T09:01:22Z" level=warning msg="For using systemd, you may need to log in using a user session"
time="2026-11-14T09:01:22Z" level=warning msg="Alternatively, you can enable lingering with: `loginctl enable-linger 1002` (possibly as root)"
time="2026-11-14T09:01:22Z" level=warning msg="Falling back to --cgroup-manager=cgroupfs"
Trying to pull docker.io/library/alpine:latest...
Getting image source signatures
Copying blob sha256:881fc932939efef04ca120ad44bbd2c0917851eb247aa4995428afb1e80ede17
Error: unable to copy from source docker://alpine:latest: copying system image from manifest list: writing blob: adding layer with blob "sha256:881fc932939efef04ca120ad44bbd2c0917851eb247aa4995428afb1e80ede17"/""/"sha256:75f1d9657d880da5f75298e8f40e9928bb6e260c50d26f97af196845307e3064": unpacking failed (error: exit status 1; output: potentially insufficient UIDs or GIDs available in user namespace (requested 0:42 for /etc/shadow): Check /etc/subuid and /etc/subgid if configured locally and run "podman system migrate": lchown /etc/shadow: invalid argument)
time="2026-11-14T09:01:24Z" level=warning msg="Failed to add pause process to systemd sandbox cgroup: dbus: couldn't determine address of session bus"
exit=125

Two separate problems are tangled in that output. The subuid error is the fatal one. The systemd warnings come from sudo -iu, which switches user without starting a systemd user session, so Podman can’t reach the user’s D-Bus and falls back to cgroupfs. The fix takes three commands, in order:

  1. Add a range with usermod, picking a block that doesn’t overlap any line already in /etc/subuid.
  2. Enable lingering so the account keeps a systemd user manager and /run/user/<uid> even when nobody is logged in.
  3. Run podman system migrate so Podman restarts its pause process with the new mapping.
sudo usermod --add-subuids 231072-296607 --add-subgids 231072-296607 appsvc
sudo loginctl enable-linger appsvc
sudo -iu appsvc podman system migrate

When you switch to the account with sudo -iu, point it at its runtime directory so Podman finds the user session that lingering created. The UID map inside the container is the real test:

sudo -iu appsvc env XDG_RUNTIME_DIR=/run/user/$(id -u appsvc) podman run --rm docker.io/library/alpine:latest cat /proc/self/uid_map

Two lines means two mappings: container UID 0 to the account’s own UID, and UIDs 1 to 65536 to the new subordinate block. The pull succeeded and the systemd warnings were gone:

         0       1002          1
         1     231072      65536

The screenshot shows the failure and the repaired run side by side, which is useful to keep for comparing against your own logs.

Podman no subuid ranges found error and usermod add-subuids fix on Ubuntu 26.04

An SSH login as the account itself gets a proper session from systemd, so the XDG_RUNTIME_DIR workaround is only needed for the sudo -iu case. Service accounts that never log in still need lingering, because without it there is no user manager to run their containers at boot.

How rootless networking works with pasta and netavark

A rootless podman run without --network runs in pasta mode: each container gets its own private network namespace, and pasta, a user-space process running as you, copies traffic between it and the host. Published ports are plain sockets that pasta opens as your user. On a network you create, netavark builds a bridge inside the rootless namespace and a helper called rootlessport forwards the ports, still as your user. Two consequences follow, and both produce errors Docker users don’t expect.

Error: pasta failed with exit code 1: Listen failed for HOST TCP port */80: Permission denied

Because pasta binds the host port as your user, the kernel rule for ports under 1024 applies to it like any other unprivileged program. Docker never hits this, since its daemon runs as root and binds ports on behalf of every container.

podman run -d --name web80 -p 80:80 docker.io/library/nginx:latest

The container never starts. Podman exits with 126 and passes the pasta error through unchanged, so the real cause is the third line rather than the first.

Error: pasta failed with exit code 1:
Listen failed for HOST TCP port */80: Permission denied
Couldn't listen on requested TCP ports

The kernel reserves everything below net.ipv4.ip_unprivileged_port_start, which is 1024 by default. Lower it to 80 so unprivileged users can bind HTTP and HTTPS, and keep it there across reboots with a sysctl drop-in. This applies to every user on the host, so don’t do it on a shared machine where you don’t trust local accounts with web ports:

echo "net.ipv4.ip_unprivileged_port_start=80" | sudo tee /etc/sysctl.d/99-rootless-ports.conf
sudo sysctl --system

The failed attempt leaves web80 behind in the Created state, so remove it with podman rm -f web80 first, otherwise the second run stops on a name clash. Running the same podman run again then returned HTTP 200 on port 80. If lowering the port floor feels too broad, keep containers on high ports and let a reverse proxy on the host take 80 and 443, which also gives you one place to manage TLS.

wget: bad address: rootless containers don’t resolve each other by name

In pasta mode every container sits in its own namespace with no shared DNS server, so a second container has no way to look up the first one by name. The built-in podman bridge, which rootful containers join by default, doesn’t help either, because it has DNS turned off for Docker compatibility. A container named web was running when we tried this from a second container:

podman network inspect podman --format "dns_enabled={{.DNSEnabled}}"
podman run --rm docker.io/library/alpine:latest wget -qO- -T 3 http://web

The bridge reports DNS off, and the lookup from the pasta-mode container fails even though the target is running a few milliseconds away.

dns_enabled=false
wget: bad address 'web'

Any network you create yourself gets aardvark-dns, which answers for every container attached to it. Create one, start a service on it and query it by name:

podman network create appnet
podman run -d --name api --network appnet docker.io/traefik/whoami:latest
podman network inspect appnet --format "dns_enabled={{.DNSEnabled}} subnet={{range .Subnets}}{{.Subnet}}{{end}}"
podman run --rm --network appnet docker.io/library/alpine:latest wget -qO- -T 3 http://api | head -4

Now the network reports DNS enabled on its own subnet, and the whoami service answers by name. The 10.89.0.2 line is the address aardvark-dns handed back for api.

appnet
d45f1aa062873c3cca3fa239732a0b3e4c8f902b751feb3e6d4335c8c3828903
dns_enabled=true subnet=10.89.0.0/24
Hostname: d45f1aa06287
IP: 127.0.0.1
IP: ::1
IP: 10.89.0.2

Both halves of the test fit in one capture, so the difference between the default network and a named one is easy to see. The screenshot comes from a second run in which the target container was named web2, so its failed lookup reads web2 instead of web.

Podman default network without DNS versus a user network with aardvark-dns name resolution on Ubuntu 26.04

Docker behaves the same way on its default bridge, which is why compose files always get their own network. Podman compose does that for you too, as the compose section shows.

How Quadlet turns a container into a systemd service

Quadlet is a systemd generator: you write a short .container file, and on every daemon-reload Podman translates it into a full service unit. That replaces podman generate systemd, and it’s the way to keep a container running across reboots without a daemon. For a user service the files live in ~/.config/containers/systemd/, and the user needs lingering so the service starts at boot rather than at first login:

sudo loginctl enable-linger $USER
mkdir -p ~/.config/containers/systemd
vim ~/.config/containers/systemd/whoami.container

Paste this unit. AutoUpdate=registry lets podman auto-update pull a newer image later, and the [Install] section is what makes it start at boot, so leave it in even though you will never run enable on this unit.

[Unit]
Description=whoami test service

[Container]
Image=docker.io/traefik/whoami:latest
ContainerName=whoami
PublishPort=8081:80
AutoUpdate=registry

[Service]
Restart=always

[Install]
WantedBy=default.target

Before starting anything, ask the generator what it will produce. A typo in a key shows up here as a warning, whereas after a reload it shows up only as a service that silently does not exist.

/usr/libexec/podman/quadlet -dryrun -user

The generated unit shows the mechanism: Quadlet turned the four [Container] keys into a single podman run command line, added --sdnotify=conmon so systemd knows when the container is up, and kept your [Install] section:

quadlet-generator[4225]: Loading source unit file /home/gedion/.config/containers/systemd/whoami.container
---whoami.service---
[Unit]
Wants=podman-user-wait-network-online.service
After=podman-user-wait-network-online.service
Description=whoami test service
SourcePath=/home/gedion/.config/containers/systemd/whoami.container
RequiresMountsFor=%t/containers

[X-Container]
Image=docker.io/traefik/whoami:latest
ContainerName=whoami
PublishPort=8081:80
AutoUpdate=registry

[Service]
Restart=always
Environment=PODMAN_SYSTEMD_UNIT=%n
KillMode=mixed
ExecStop=/usr/bin/podman rm -v -f -i whoami
ExecStopPost=-/usr/bin/podman rm -v -f -i whoami
Delegate=yes
Type=notify
NotifyAccess=all
SyslogIdentifier=%N
ExecStart=/usr/bin/podman run --name whoami --replace --rm --cgroups=split --sdnotify=conmon -d --label io.containers.autoupdate=registry --publish 8081:80 docker.io/traefik/whoami:latest

[Install]
WantedBy=default.target

Reload the user manager so the generator runs, then start the service and check it. No sudo is involved, because the unit belongs to your own systemd user instance.

systemctl --user daemon-reload
systemctl --user start whoami.service
systemctl --user status whoami.service --no-pager

Look at the Loaded line. It says generated and points back at your .container file, and that is how you recognise a Quadlet service on any host you inherit. The excerpt below stops before the process tree under CGroup, which lists pasta, conmon and the whoami binary.

● whoami.service - whoami test service
     Loaded: loaded (/home/gedion/.config/containers/systemd/whoami.container; generated)
     Active: active (running) since Sat 2026-11-14 09:02:14 UTC; 3s ago
 Invocation: ec096fea456747d3b38ff23b9d521bb9
   Main PID: 4333 (conmon)
      Tasks: 6 (limit: 8424)
     Memory: 19.2M (peak: 28.7M)
        CPU: 163ms
     CGroup: /user.slice/user-1001.slice/[email protected]/app.slice/whoami.service

The CGroup path under [email protected] confirms the container lives in your user slice, not in the system slice that root services use.

Failed to enable unit: Unit … is transient or generated

Habit says to run systemctl --user enable whoami.service next, and systemd refuses with an error that looks far more serious than it is.

Failed to enable unit: Unit /run/user/1001/systemd/generator/whoami.service is transient or generated

Nothing is broken. Generated units are rebuilt on every reload, so there’s no unit file for enable to link. The generator applies the [Install] section itself at generation time, which the podman-systemd.unit documentation describes under “Enabling unit files”. Keep WantedBy=default.target in the file and the service starts at boot; systemctl --user is-enabled reports generated rather than enabled.

Podman Quadlet whoami user service active with the generated unit enable error on Ubuntu 26.04

The last command in that capture, podman auto-update --dry-run, lists the unit with policy registry, so a scheduled podman auto-update would pull and restart it when the tag moves. The Podman cheat sheet keeps the Quadlet keys and auto-update flags on one page.

How podman compose finds a compose provider

podman compose is a thin wrapper, not a compose implementation. It looks for an external provider, first Docker’s docker-compose plugin and then podman-compose, and hands the whole command over. A fresh install has neither, so the first try fails with the search path printed:

podman compose version

Podman checked seven places and found nothing. Five are Docker CLI plugin paths, which is why installing Docker Compose alone would also satisfy it.

Error: looking up compose provider failed
7 errors occurred:
	* exec: "/home/gedion/.docker/cli-plugins/docker-compose": stat /home/gedion/.docker/cli-plugins/docker-compose: no such file or directory
	* exec: "/usr/local/lib/docker/cli-plugins/docker-compose": stat /usr/local/lib/docker/cli-plugins/docker-compose: no such file or directory
	* exec: "/usr/local/libexec/docker/cli-plugins/docker-compose": stat /usr/local/libexec/docker/cli-plugins/docker-compose: no such file or directory
	* exec: "/usr/lib/docker/cli-plugins/docker-compose": stat /usr/lib/docker/cli-plugins/docker-compose: no such file or directory
	* exec: "/usr/libexec/docker/cli-plugins/docker-compose": stat /usr/libexec/docker/cli-plugins/docker-compose: no such file or directory
	* exec: "docker-compose": executable file not found in $PATH
	* exec: "podman-compose": executable file not found in $PATH

The archive’s podman-compose is the natural provider on a Podman-only host, because it talks to Podman directly and needs no socket. If you already run Docker’s Compose plugin from the Docker and Docker Compose install guide, Podman would pick that up first instead.

sudo apt install -y podman-compose
podman compose version

Podman now announces which provider it is delegating to before it prints both versions. That banner is your confirmation that the archive package, not a Docker plugin, is doing the work.

>>>> Executing external compose provider "/usr/bin/podman-compose". Please see podman-compose(1) for how to disable this message. <<<<

podman version 5.7.0
podman-compose version 1.5.0

That banner prints on every compose command. The podman-compose(1) man page documents PODMAN_COMPOSE_WARNING_LOGS=false in your shell profile, or compose_warning_logs=false under [engine] in containers.conf, to silence it. Next, a two-service stack in its own directory:

mkdir -p ~/stack && cd ~/stack
vim compose.yaml

The file defines an nginx front end on port 8090 and a Redis cache with a named volume. Both use fully qualified image names, so the stack behaves the same whether or not a host has search registries configured.

services:
  web:
    image: docker.io/library/nginx:latest
    ports:
      - "8090:80"
    depends_on:
      - cache
  cache:
    image: docker.io/library/redis:latest
    volumes:
      - redis-data:/data

volumes:
  redis-data:

Bring it up, then check both containers and the name lookup between them. Each check proves a different layer, from container state to DNS to the Redis protocol itself.

podman compose up -d
podman compose ps
podman exec stack_web_1 getent hosts cache
podman exec stack_cache_1 redis-cli ping

The block below is an excerpt that starts at the ps call; up -d printed the same banner, the three new IDs and the container names. podman-compose created a project network with DNS, so cache resolves from the web container on a 10.89.1.x address, and Redis answers PONG:

>>>> Executing external compose provider "/usr/bin/podman-compose". Please see podman-compose(1) for how to disable this message. <<<<

CONTAINER ID  IMAGE                           COMMAND               CREATED                 STATUS       PORTS                 NAMES
c2d59c25fbbf  docker.io/library/redis:latest  redis-server          1 second ago            Up 1 second  6379/tcp              stack_cache_1
7e784ae790f2  docker.io/library/nginx:latest  nginx -g daemon o...  Less than a second ago  Up 1 second  0.0.0.0:8090->80/tcp  stack_web_1
10.89.1.2       cache.dns.podman
PONG

The full compose session, from up -d through the Redis check, is captured below.

podman compose up with podman-compose running nginx and redis on Ubuntu 26.04

Container names follow the project_service_index pattern (stack_web_1), which differs from Docker Compose v2’s hyphenated stack-web-1, so scripts that grep for container names need adjusting. A Redis container is fine for development; for a database host, the native Redis install on Ubuntu 26.04 avoids the container layer entirely.

How fast Podman is next to Docker on the same VM

On the same Ubuntu 26.04 VM, Podman started containers faster than Docker in every test, and image pulls were mixed: rootless Podman pulled nginx fastest, both Podman modes tied at about 2.7 s on python:3.14-slim against 4.41 s for Docker, and rootful Podman was the slowest of the three on nginx. We installed docker.io from the same archive so both engines came from Ubuntu (do this on a throwaway VM, since dockerd rewrites host firewall rules), and ran each test with the engines interleaved so network jitter hit all three equally.

sudo apt install -y docker.io hyperfine bc
docker --version

Docker came from the archive build. It runs runc and the containerd image store, which is a different runtime from Podman’s crun, so these numbers compare whole stacks rather than one component.

Docker version 29.1.3, build 29.1.3-0ubuntu4.1

The readiness test measures what you actually wait for after a deploy: the time from run -d with a published port until nginx returns HTTP 200. Save it as a script:

vim bench-ready.sh

The script runs 10 rounds per engine and prints milliseconds. Rootless runs go through the gedion account with sudo -iu, so all three engines start from the same root shell.

#!/bin/bash
# time from "run -d" to first HTTP 200 on the published port; 10 rounds per engine
IMG=docker.io/library/nginx:latest
ready() { # $1 = engine command, $2 = port
  local s=$(date +%s%N)
  $1 run -d --name rt -p $2:80 $IMG >/dev/null
  until curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:$2/ | grep -q 200; do :; done
  local e=$(date +%s%N)
  $1 rm -f rt >/dev/null
  echo $(( (e - s) / 1000000 ))
}
for eng in "docker" "podman" "sudo -iu gedion podman"; do
  vals=""; for r in $(seq 10); do vals="$vals $(ready "$eng" 8181)"; done
  echo "$eng:$vals" | sed 's/sudo -iu gedion podman/podman-rootless/'
done

Replace gedion with your own login and pull the nginx image in all three stores first, so no round includes a download. Then run it as root.

sudo bash bench-ready.sh

Docker’s first round was a cold outlier at 1212 ms. Every later round settled around 470 ms, against about 320 ms for rootful Podman and 345 ms for rootless.

docker: 1212 465 473 446 462 492 479 468 472 454
podman: 323 309 347 334 345 314 316 313 323 339
podman-rootless: 324 339 340 348 349 342 364 375 332 351

For pull time, a second script removed the image from all three stores before each round and timed a cold pull five times per engine, on two images. Raw container start, without networking, came from hyperfine with 3 warmups and 20 runs of run --rm alpine true. The medians:

Test (same VM, archive packages)DockerPodman rootfulPodman rootless
Cold pull, nginx:latest (median of 5)5.25 s5.84 s3.97 s
Cold pull, python:3.14-slim (median of 5)4.41 s2.66 s2.70 s
run -d to HTTP 200, nginx (median of 10)470 ms323 ms345 ms
run –rm alpine true (hyperfine mean of 20)542 ms385 ms238 ms
Resident memory of idle daemons158 MiB (dockerd + containerd)0 (no daemon)0 (no daemon)
Podman versus Docker image pull time and container start time measured on one Ubuntu 26.04 VM

The start gap follows from the architecture. A Docker start is a client call to dockerd, which asks containerd, which spawns a shim and then runc, while Podman forks conmon and crun directly from the CLI you typed. CPU per run tells the other half of the story. Podman spent about 100 ms of user CPU per run against 19 ms for Docker, because the work dockerd does in its long-running process happens inside each podman invocation instead.

Rootless winning the raw start test surprised us, and so did rootful Podman losing the nginx pull. We did not chase either cause, so treat the pull row as a measurement on this VM rather than a law. What holds across every row is that 150 ms of start time will not decide anything for a long-running service, while 158 MiB of idle daemon memory and a root-owned socket might. If you need Docker itself on this release, the Docker CE install for Ubuntu 26.04 covers the upstream packages.

Common misconceptions about Podman as a Docker replacement

Most trouble in the first week comes from assuming Podman is Docker with a different name. Every item below is something we hit or measured on this VM, so each one comes with the fix shown earlier.

  • “Short names work like Docker”: they don’t until you add unqualified-search-registries, and even then a script silently takes the first registry that answers. Fully qualified names are the only predictable form.
  • “Every user can run rootless”: only users with a subuid and subgid range. Local service accounts made with SUB_UID_COUNT=0 need usermod --add-subuids and podman system migrate first, and directory accounts need their ranges added by hand or served by SSSD.
  • “Containers find each other by name”: not in the default rootless pasta mode, and not on the built-in podman bridge, where DNS is off. Create a network, or let compose create one.
  • “systemctl enable makes a Quadlet start at boot”: it errors out. The [Install] section plus lingering does that job.
  • “Rootless is slow”: in our runs rootless started containers in 238 ms against Docker’s 542 ms, and it pulled nginx fastest of the three.

The one place Podman still asks more of you is the move off this archive build. Upstream has since shipped Podman 6 with breaking changes, so read the Podman 6 breaking changes guide before you replace the Ubuntu package with a newer build, and keep your Quadlet files and fully qualified image names, because those carry across unchanged. We rebuilt this page from fresh lab runs after Google Search Console listed the earlier version as Crawled - currently not indexed, so every command, error and timing above comes from that new run.

Keep reading

Upgrade Ubuntu 24.04 to Ubuntu 26.04 LTS (Step by Step) Ubuntu Upgrade Ubuntu 24.04 to Ubuntu 26.04 LTS (Step by Step) UFW Firewall Commands with Examples on Ubuntu 26.04 / 24.04 Security UFW Firewall Commands with Examples on Ubuntu 26.04 / 24.04 Backup and Restore Linux Systems with Timeshift Debian Backup and Restore Linux Systems with Timeshift Deploy Collabora Online Office on Ubuntu with Let’s Encrypt SSL Cloud Deploy Collabora Online Office on Ubuntu with Let’s Encrypt SSL Install CyberPanel on Ubuntu 26.04 / 24.04 with Let’s Encrypt Ubuntu Install CyberPanel on Ubuntu 26.04 / 24.04 with Let’s Encrypt Install Local OpenShift Cluster using CRC (OpenShift Local) Containers Install Local OpenShift Cluster using CRC (OpenShift Local)

Leave a Comment

Press ESC to close