How to Install Podman on Ubuntu 26.04, 24.04 and 22.04

Rootless containers are the main reason to install Podman on Ubuntu instead of treating Docker as the only local container workflow. Ubuntu’s repository package gives you a complete daemonless engine, while Homebrew and upstream GitHub releases fill narrower gaps for users who need a newer branch or a remote client.

The current Ubuntu path is not the old Kubic repository most older tutorials mention. The official Podman installation page points Ubuntu users to the distro package, while the newer Homebrew formula and the Podman GitHub releases page serve different jobs that should stay separate from the local APT engine.

Install Podman on Ubuntu

Choose a Podman Installation Method on Ubuntu

Ubuntu 26.04, 24.04, and 22.04 all package Podman in the universe component, but the branch differs by release. Match the source to the workflow before installing anything:

Method	What You Get	Choose It When
Ubuntu APT package	Full local Podman Engine from universe. Current branches are Podman 5.7 on Ubuntu 26.04, 4.9 on Ubuntu 24.04, and 3.4 on Ubuntu 22.04.	You want the recommended local engine with APT-managed updates.
Homebrew formula	A brew-managed Podman package under the Homebrew prefix, with Homebrew’s Linux dependency tree.	You already use Homebrew on Ubuntu and intentionally want the Homebrew Podman branch outside APT.
GitHub release asset	podman-remote only. The Linux release tarballs are remote clients, not complete local engine packages.	You need a client for an existing Podman API service on another host or user socket.
OBS/Kubic repositories	Old community repositories with stale stable packages and incomplete current Ubuntu coverage.	Avoid this path for normal Ubuntu installs.

If you are installing Podman to run local containers on Ubuntu, choose APT. It installs the engine, runtime, networking helpers, rootless storage support, and APT-managed package updates together. If you need a newer branch and already maintain Homebrew on Ubuntu, the brew formula is cleaner than reviving obsolete Kubic instructions, but it moves Podman updates and many runtime dependencies outside APT.

If APT cannot find podman, enable the Ubuntu component that contains community-maintained packages. The troubleshooting section includes the command, and the separate guide to enable Universe on Ubuntu explains the component layout in more detail.

Update Ubuntu Before Installing Podman

Refresh the package index before installing Podman so APT sees the current repository metadata:

sudo apt update

These commands use sudo for package installation and system-wide changes. If your account cannot run sudo yet, run the commands as root or follow the guide on how to add a user to sudoers on Ubuntu.

Install Podman with APT on Ubuntu

Install the main Podman package from Ubuntu’s repositories:

sudo apt install podman

APT also installs the helper packages Podman needs for normal rootless work. Ubuntu 26.04 pulls in current container tooling such as buildah, conmon, crun, netavark, aardvark-dns, passt, slirp4netns, fuse-overlayfs, and uidmap. Ubuntu 24.04 uses the Podman 4.9 family with similar modern networking helpers, while Ubuntu 22.04 stays on the older 3.4 branch and CNI-era companion packages.

Verify Podman Rootless Operation

Check the installed Podman version:

podman --version

Ubuntu 26.04 currently returns:

podman version 5.7.0

Confirm that your normal user gets rootless storage under your home directory:

podman info --format 'rootless={{.Host.Security.Rootless}} graphDriver={{.Store.GraphDriverName}} graphRoot={{.Store.GraphRoot}}'

A healthy rootless install looks like this, with the username and home path changed for your account:

rootless=true graphDriver=overlay graphRoot=/home/joshua/.local/share/containers/storage

Run a Podman Hello Container

Run Podman’s hello image from Quay to verify image pulls, rootless execution, storage, and registry access in one short test:

podman run --rm quay.io/podman/hello

Relevant output includes the greeting and project links:

!... Hello Podman World ...!

Project:   https://github.com/containers/podman
Website:   https://podman.io
Desktop:   https://podman-desktop.io
Documents: https://docs.podman.io

Install Podman with Homebrew on Existing Brew Setups

Homebrew is an optional path for developers who already use brew on Linux and intentionally want Podman to track the Homebrew formula instead of Ubuntu’s package. Do not install Homebrew only to replace a working APT Podman setup on a server; it brings its own dependency tree and update cadence. If Homebrew is not installed yet, set it up first with the guide to install Homebrew on Ubuntu.

Do not mix the APT and Homebrew Podman binaries casually. Check command -v podman before switching methods so you know whether your shell is using /usr/bin/podman from Ubuntu or the Homebrew prefix.

Install Ubuntu’s rootless ID helpers first. The Homebrew formula’s Linux caveat requires the system newuidmap and newgidmap binaries, which Ubuntu provides through uidmap:

sudo apt install uidmap

Refresh Homebrew’s formula metadata, then install Podman from the Homebrew formula:

brew update
brew install podman

Check which Podman binary your shell will run:

command -v podman

If command -v podman still shows /usr/bin/podman, your shell is still finding the Ubuntu package first. Reload Homebrew’s shell environment from your Homebrew installation notes, then rerun the path check.

After the path points at the Homebrew prefix, verify the Podman version from both tools:

podman --version
brew list --versions podman

After the path points at the Homebrew prefix, run the same rootless checks used for the APT install:

podman info --format 'rootless={{.Host.Security.Rootless}} graphDriver={{.Store.GraphDriverName}}'
podman run --rm quay.io/podman/hello

If these runtime checks fail after a brew install, confirm that uidmap is installed and that your active shell uses Homebrew’s environment before changing Ubuntu packages.

Install the Upstream Podman Remote Client from GitHub

The Linux files on the GitHub release page are remote-client tarballs. They do not install the local Podman Engine, networking helpers, storage configuration, or systemd units needed to run containers directly on Ubuntu. Use this method only when you need podman-remote to connect to an existing Podman service.

Install the download and certificate helpers first:

sudo apt install wget ca-certificates

The installer script detects x86_64 or arm64, downloads the current remote-client tarball and the matching shasums file, verifies the checksum, then installs the binary as /usr/local/bin/podman-remote. It uses wget for the download and grep to select the matching checksum line.

cat > /tmp/install-podman-remote.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

case "$(uname -m)" in
  x86_64) podman_arch=amd64 ;;
  aarch64|arm64) podman_arch=arm64 ;;
  *) echo "Unsupported architecture: $(uname -m)" >&2; exit 1 ;;
esac

workdir="$(mktemp -d)"
trap 'rm -r "$workdir"' EXIT

asset="podman-remote-static-linux_${podman_arch}.tar.gz"
cd "$workdir"

wget -q "https://github.com/containers/podman/releases/latest/download/${asset}"
wget -q "https://github.com/containers/podman/releases/latest/download/shasums"
grep "  ${asset}$" shasums | sha256sum -c -
tar -xzf "$asset"
sudo install -m 0755 "bin/podman-remote-static-linux_${podman_arch}" /usr/local/bin/podman-remote
EOF
bash /tmp/install-podman-remote.sh
rm -f /tmp/install-podman-remote.sh

On amd64, the checksum step and version check currently look like this:

podman-remote-static-linux_amd64.tar.gz: OK

podman-remote --version

podman-remote version 5.8.2

Add a connection only after a Podman service exists on the remote host or user socket. Without a reachable service, podman-remote can report its version but cannot run local containers by itself.

Start Using Podman on Ubuntu

Learn Basic Podman Commands on Ubuntu

Podman uses Docker-style command patterns, but the default rootless mode keeps containers, images, and volumes under the current user’s container storage. A container started as your normal user is separate from any container started later with sudo podman, so stay consistent unless you specifically need root-owned containers.

Use fully qualified image names in examples and scripts. For example, docker.io/library/nginx:alpine names the registry, namespace, image, and tag directly, which avoids short-name prompts or registry ambiguity on fresh systems.

Task	Command	What It Checks or Changes
Search a registry	podman search nginx	Looks for matching images before you pull one.
Pull an image	podman pull docker.io/library/nginx:alpine	Downloads the image into your rootless image store.
List local images	podman images	Shows images available to the current user.
List running containers	podman ps	Shows only containers that are currently running.
List all containers	podman ps -a	Shows running and stopped containers.
View container logs	podman logs CONTAINER	Prints stdout and stderr from a named container.
Stop a container	podman stop CONTAINER	Gracefully stops a running container.
Remove a container	podman rm CONTAINER	Deletes a stopped container while keeping its image.
Remove an image	podman image rm IMAGE	Deletes an image when no container still depends on it.

Use podman --help or podman COMMAND --help when you need flags for a specific action. The examples below use these basics in a practical Nginx container and a small custom image build.

Run a Rootless Nginx Container

This example runs Nginx without sudo and maps container port 80 to host port 8080. Rootless users can bind high ports such as 8080 without changing privileged-port settings.

podman run -d --name lc-nginx -p 8080:80 docker.io/library/nginx:alpine

Confirm the container name and port mapping:

podman ps --filter name=lc-nginx --format 'name={{.Names}} ports={{.Ports}}'

name=lc-nginx ports=0.0.0.0:8080->80/tcp

Check the web response from the host:

wget -qO- http://127.0.0.1:8080 | grep -m1 '<title>'

<title>Welcome to nginx!</title>

Remove the demo container when you are done:

podman rm -f lc-nginx

This port mapping listens on the Ubuntu host. If you want other machines to reach that port, configure your firewall deliberately instead of opening broad access by accident; the guide to configure UFW on Ubuntu covers scoped firewall rules.

Build a Small Podman Image

Podman builds images from a Containerfile or Dockerfile-style file. Create a tiny Nginx image that replaces the default page with one custom line:

mkdir -p ~/podman-demo
cd ~/podman-demo
printf '%s\n' 'Hello from Podman on Ubuntu' > index.html

Create the Containerfile. This file tells Podman to use the official Nginx Alpine image and copy your custom page into the web root:

cat > Containerfile <<'EOF'
FROM docker.io/library/nginx:alpine
COPY index.html /usr/share/nginx/html/index.html
EOF

Build the image:

podman build -t localhost/lc-podman-demo:latest .

The final lines should include the local image tag:

COMMIT localhost/lc-podman-demo:latest
Successfully tagged localhost/lc-podman-demo:latest

Run the image as a container:

podman run -d --name lc-demo -p 8080:80 localhost/lc-podman-demo:latest

Request the page from the host to verify that the container is serving your custom file:

wget -qO- http://127.0.0.1:8080

Hello from Podman on Ubuntu

Clean up the demo container and image:

podman rm -f lc-demo
podman image rm localhost/lc-podman-demo:latest

The next command deletes only the demo directory created in this section. Keep it if you changed the files for your own project.

rm -r ~/podman-demo

Use Docker-Compatible Podman Commands

The optional podman-docker package makes the docker command call Podman. Install it only after the full podman package is installed, because installing the wrapper by itself with minimal recommendations can miss rootless helper binaries on some systems.

Check whether Docker Engine already owns the command name:

command -v docker

No output means the command name is currently unused. If the command already points to Docker Engine, leave it alone unless you intentionally want Podman to replace that workflow. For a real Docker daemon, use the separate guide to install Docker on Ubuntu.

Install the wrapper without pulling unrelated recommended packages:

sudo apt install --no-install-recommends podman-docker

Verify that docker now resolves to Podman:

docker --version

podman version 5.7.0

Run the hello test through the Docker-compatible command name so you verify routing, image pulls, and rootless execution through the wrapper:

docker run --rm quay.io/podman/hello

The first Docker-compatible run prints Podman’s emulation notice before the container output:

Emulate Docker CLI using podman. Create /etc/containers/nodocker to quiet msg.
!... Hello Podman World ...!

Create the marker file after you understand the compatibility layer and want to hide that notice:

sudo touch /etc/containers/nodocker

Manage the Podman User Socket on Ubuntu

Normal podman run, podman build, and podman ps commands do not need a daemon. Enable the user socket only when another tool needs a Docker-compatible API endpoint for your rootless containers.

systemctl --user enable --now podman.socket

Confirm that the socket is active:

systemctl --user is-active podman.socket

active

Confirm that the socket file exists under the current user’s runtime directory:

test -n "${XDG_RUNTIME_DIR:-}" && test -S "${XDG_RUNTIME_DIR}/podman/podman.sock" && echo "Podman user socket is ready"

Podman user socket is ready

Tools that accept Docker socket URLs can use unix://${XDG_RUNTIME_DIR}/podman/podman.sock for the current login session. Use the system-wide Podman socket only for root-owned API workflows, because that socket exposes root’s Podman storage instead of your rootless containers.

Disable the user socket later if you no longer need API access:

systemctl --user disable --now podman.socket

Manage Podman Updates and Removal on Ubuntu

Update Podman by Installation Method

APT-installed Podman updates through Ubuntu’s normal package flow. Upgrade only Podman and the Docker wrapper with:

sudo apt update
sudo apt install --only-upgrade podman podman-docker

For Homebrew installs, update the formula index and upgrade the brew package:

brew update
brew upgrade podman

For the GitHub remote client, rerun the installer script from the GitHub section. The script resolves the current release through GitHub’s latest-release redirect and verifies the new tarball before replacing /usr/local/bin/podman-remote.

Remove Podman Packages and Data

If you enabled the user socket, stop it before removing Podman:

systemctl --user disable --now podman.socket

Remove the Ubuntu packages. The wrapper package can stay in the command even when it was never installed:

sudo apt remove podman podman-docker

Confirm neither package remains installed:

dpkg -l podman podman-docker 2>/dev/null | grep '^ii' || true

No output means APT no longer has either package installed. Preview orphaned dependencies before removing them, because container helper packages can also be used by Buildah, Skopeo, or other tooling:

sudo apt autoremove --dry-run

Continue only if the preview lists packages you no longer need:

sudo apt autoremove

Remove a Homebrew-installed Podman package with brew:

brew uninstall podman
brew autoremove

Remove the GitHub remote client binary if you installed it:

sudo rm -f /usr/local/bin/podman-remote
hash -r
command -v podman-remote || echo "podman-remote removed"

podman-remote removed

The following commands permanently delete local container images, containers, volumes, registry settings, and caches for the selected scope. Export anything you need before deleting these paths.

Remove rootless container data for the current user:

rm -rf ~/.local/share/containers ~/.config/containers ~/.cache/containers

Remove root-owned container data only if you ran containers with sudo podman and no longer need those images, containers, or volumes:

sudo rm -rf /var/lib/containers

Troubleshoot Podman on Ubuntu

APT Cannot Locate the Podman Package

If sudo apt install podman returns this error, Ubuntu’s universe component is probably disabled:

E: Unable to locate package podman

Install the repository helper if your system does not already have it:

sudo apt install software-properties-common

Enable universe without immediately refreshing APT:

sudo add-apt-repository -y -n universe

Refresh package metadata, then retry the Podman install:

sudo apt update
sudo apt install podman

Rootless Podman Reports Missing newuidmap

This error appears when Podman needs subordinate ID helpers but newuidmap is missing from the active method’s dependency set:

Error: command required for rootless mode with multiple IDs: exec: "newuidmap": executable file not found in $PATH

Install uidmap first:

sudo apt install uidmap

Then confirm your account has subordinate user and group ID ranges and that unprivileged user namespaces are enabled:

grep "^${USER}:" /etc/subuid /etc/subgid
sysctl kernel.unprivileged_userns_clone

Example output shows one ID range in each file and unprivileged user namespaces enabled:

/etc/subuid:joshua:100000:65536
/etc/subgid:joshua:100000:65536
kernel.unprivileged_userns_clone = 1

If the ID files do not list your user, add a subordinate ID range:

sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 "$USER"

Sign out and back in so your session sees the new range, then migrate Podman’s rootless storage metadata:

podman system migrate

GitHub podman-remote Cannot Run Local Containers

The static Linux asset from GitHub is a remote client. If podman-remote run cannot connect, that does not mean the tarball is broken; it means no Podman API service is available for the client to use. Install the local engine with APT or Homebrew, or add a remote connection to an existing service.

podman-remote system connection list

An empty connection list means the remote client has nowhere to send container commands yet.

Docker Commands Still Use Docker Engine

If docker --version still reports Docker Engine after installing podman-docker, another package or custom path entry owns the docker command. Check the active command path and package owner:

command -v docker
dpkg -S "$(command -v docker)"

Keep Docker Engine if your workflow needs the Docker daemon, Docker’s Compose plugin, Buildx, or Docker-specific socket behavior. Use podman-docker only when you want Docker-compatible command names to call Podman instead.

Conclusion

Podman is running on Ubuntu with rootless storage, a verified container workflow, and separate update paths for APT, Homebrew, or the upstream remote client. Keep using Podman when daemonless containers fit the job; switch to Docker on Ubuntu only when a real Docker daemon is required.