Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 37 ยท Getting Started

What Is Podman?

Meet Podman, the daemonless container engine: what it does, how it differs from a client-server design, why rootless matters, and what this course covers.

Podman is a tool for finding, running, building and sharing containers. A container is a normal Linux process that is started with its own view of the file system, process list, network and users, so it behaves like a tiny separate machine while still sharing the host's kernel. If you have used other container tools, most of what you know carries over: you pull an image, run a container from it, publish a port, mount a folder.

What makes Podman different is how it does this. There is no always-running background service that owns your containers. When you type podman run, the podman program itself prepares the container, starts it, and gets out of the way. That design choice has big consequences for security, for system integration, and for how you run containers on servers. This lesson explains the idea, so that the rest of the course makes sense.

Podman cannot run on this website, because it needs a Linux kernel and real container features. Every command here is shown in read-only blocks, and the runnable examples are small JavaScript stand-ins that model an idea (a process tree, a command parser). They are labelled each time, and they never pretend to be Podman's output.

The short history

Podman was created by Red Hat engineers and is developed in the open as part of the containers projects (containers/podman, containers/buildah, containers/skopeo, containers/storage, containers/image). The name comes from "pod manager": from the start it understood pods, groups of containers that share a network, the same idea Kubernetes uses. It follows the open standards of the Open Container Initiative (OCI), so an image built by one tool runs in another, and any registry that speaks the OCI distribution protocol works.

Daemon or no daemon?

A traditional container engine has two parts. A client (the command you type) sends requests to a daemon, a long-lived service that does the real work and owns every container.

Podman has a different model. Each podman command is its own process. It talks to the Linux kernel through a small helper called an OCI runtime (usually crun), and it leaves a tiny monitor process called conmon next to each running container. conmon holds the container's output and exit code; the container is a child of conmon, not of Podman.

flowchart LR
    subgraph DAEMON["Client-server engine"]
        direction TB
        C1["CLI"] --> D["long-lived daemon<br/>(runs as root)"]
        D --> K1["container A"]
        D --> K2["container B"]
    end
    subgraph FORK["Podman (fork and exec)"]
        direction TB
        C2["podman run"] --> M1["conmon"]
        M1 --> K3["container A"]
        C3["podman run"] --> M2["conmon"]
        M2 --> K4["container B"]
    end

Left: one daemon owns all containers. Right: each container hangs under its own tiny monitor, and no central service has to stay alive.

Here is a stand-in that builds both process trees as text so you can compare them. It is plain JavaScript, not Podman.

JS Stand-in: two process trees

Press Run (or Ctrl + Enter) to see the console output here.

No output.

In the Podman model the containers are children of systemd (through conmon), so if you restart a tool, upgrade a package, or even crash a CLI command, running containers are unaffected. There is nothing to restart and nothing that a bug can take down for all containers at once.

Rootless by design

The second big idea is that normal users can run containers without administrator rights. Podman uses Linux user namespaces so that "root" inside your container is mapped to your ordinary user outside. If a program escapes the container, it lands as an unprivileged user and not as root on the machine.

Terminal
# As a normal user, no sudo needed:
podman run --rm docker.io/library/alpine:latest id

Inside that container the program believes it is user 0 (root). On the host it is just you. You will learn exactly how this mapping works in Rootless and User Namespaces. Podman can also run as real root (rootful mode) when you need it, for example to bind low ports or attach special devices, and both modes use the same commands.

What Podman can do

Job Command family
Run containers podman run, podman start, podman exec
Manage images podman pull, podman images, podman build, podman push
Group containers into pods podman pod create, podman run --pod
Store data podman volume, bind mounts
Talk to Kubernetes YAML podman kube generate, podman kube play
Run as system services Quadlet files and systemd units
Move images around podman save, podman load, podman image scp

Podman is the main tool, and two sibling projects fill in the rest. Buildah builds images with finer control than a Dockerfile alone, and Skopeo inspects and copies images between registries without pulling them. Podman uses their libraries internally, so you rarely call them yourself at first.

The mental model for this course

Keep four words in mind:

  • Image: a read-only template, a stack of file-system layers plus configuration.
  • Container: a running (or stopped) instance of an image with its own writable layer.
  • Pod: a group of containers that share network and some other namespaces.
  • Volume: storage that outlives a container.

Here is one more stand-in. It splits a podman run command into its parts, which is a skill you will use for every command in this course.

JS Stand-in: reading a podman command

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The rule it shows is important: flags for Podman go before the image name; anything after the image name is handed to the program inside the container. Putting --rm after the image is one of the most common beginner mistakes.

Where Podman fits

You can use Podman on a laptop for development, on a server to run long-lived services, and inside CI jobs. On Linux it is a native tool. On macOS and Windows the containers still need a Linux kernel, so Podman starts a small managed Linux virtual machine for you (see Installing Podman). Its design is attractive when you care about running without root, integrating with systemd, or moving later to Kubernetes, because the YAML formats are close.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is the main architectural difference of Podman compared with a client-server container engine?

    Podman forks and execs. Each container gets a small conmon monitor, so there is no long-lived daemon that owns every container.
  2. 2. What does rootless mean in Podman?

    User namespaces map container UID 0 to your unprivileged UID, so an escape from the container does not give root on the host.
  3. 3. In podman run --rm alpine echo hi, which part is passed to the program inside the container?

    Everything after the image name is the container command. Flags for Podman itself must come before the image.
  4. 4. Which tool builds images with fine control and is used by Podman internally?

    Buildah builds OCI images. Skopeo copies and inspects images, conmon monitors containers, and crun is an OCI runtime.

Summary

  • Podman runs, builds and manages OCI containers and pods without a central daemon.
  • Each container is supervised by its own small conmon process, and crun talks to the kernel.
  • Rootless mode maps container root to your normal user, which limits the damage of an escape.
  • Buildah and Skopeo are sibling tools for building and copying images.
  • Flags for Podman go before the image name; the container command goes after it.
  • On macOS and Windows, Podman manages a small Linux virtual machine for you.

Next: Installing Podman