{"canonical_url":"https://engineer.company/glossary/podman/","content_markdown":"# Podman\n\n## What it is\n\nPodman is a container engine for Linux that builds, pulls and runs the same OCI images Docker does,\nbut with no central server in the middle. Each `podman` command does its work in its own process and\nexits. A started container keeps running under a small monitor process called conmon, and that\nmonitor is a child of whatever launched it: a shell, a script, or systemd. The project describes\nitself as daemonless, open source and Linux-native, and says most users can alias `docker` to\n`podman` and carry on.\n\nThe name is short for pod manager. A pod, borrowed from Kubernetes, is a group of containers that\nshare a network namespace and so reach each other on localhost. Podman can create pods by hand, and\n`podman kube play` starts containers and pods from a Kubernetes YAML file, which makes it a\nreasonable place to try a manifest before it goes near a cluster.\n\nTwo features set it apart in daily use. The first is rootless operation. An ordinary user can run\ncontainers, with the kernel's user namespaces mapping that user to UID 0 inside the container and\nthe user's subordinate ID range, from `/etc/subuid` and `/etc/subgid`, to every other UID.\nNetworking for rootless containers goes through pasta, a user-space network stack, since an\nunprivileged user has no right to rewrite the host's packet filter.\n\nThe second is Quadlet. A Quadlet file is a short declarative description of a container, volume,\nnetwork, pod or image build, written in the same ini syntax as a systemd unit and saved under\n`/etc/containers/systemd/` for the system or `~/.config/containers/systemd/` for one user. At boot,\nand on every `systemctl daemon-reload`, a systemd generator turns `web.container` into an ordinary\n`web.service`. The older `podman generate systemd` command still works, and the project marks it\ndeprecated in favour of Quadlet.\n\n## Why it matters\n\nThe question Podman puts on the table is who owns the process tree. Docker manages containers through `dockerd`, with its own restart policies, logging and container health checks. On a server that already runs systemd, that is a second supervisor\nbeside the first, and the two do not share a vocabulary.\n\nUnder Podman with Quadlet, systemd is the only supervisor. A container is a service like any other:\n`systemctl status` shows it, journald holds its output, `After=` and `Requires=` order it against\nthe database it needs, and `Restart=` and the cgroup limits systemd already understands apply to it\nunchanged. An operator who knows how to read a unit file already knows how to read the container\nplane.\n\nThere is a security angle too. The Docker daemon runs as root unless its rootless mode is chosen,\nand Docker's own security guide says only trusted users should be allowed to control it, because a\ncontainer can be handed any directory on the host. Podman keeps no privileged daemon running between\ncommands. A rootless setup narrows things further: a process that escapes its container lands as an\nunprivileged user.\n\nDocker vs Podman is therefore less a contest of features than a question of fit. Docker is the\nsmoother choice on a developer laptop with Docker Desktop, for teams whose workflow is built around\nCompose, and for tools that expect a Docker socket, though Podman can serve a compatible API on\nrequest. Podman tends to win on servers where systemd is already the source of truth, and where a\ndaemon that rewrites the firewall is a liability rather than a convenience.\n\n## What it looks like in practice\n\nPodman carries the container plane in two recent projects, and before that it was the debugging tool\nfor a fleet built on Docker.\n\nOn one host,\n[containers run as Quadlet units under systemd, with Podman in place of Docker](/portfolio/ran-containers-on-podman-and-quadlet/).\nThe reason is the firewall: Docker's default publishes container ports above the rules the hardening\nrole installs, while these containers use the host's network with no published ports at all. The\nunits run at the system level rather than rootless, and the page records that as a trade, simpler\nautomation against the stricter isolation rootless would give, along with a note on which way to\nmove if container escape ever matters more. Deployment is split from provisioning. Root sets up the\ndeployment path once. Every later release is one fixed script that a user without privileges is\nallowed to run through a scoped rule, and the script does two things only: build the image and\nrestart the service.\n\nThe same arrangement holds up on very little hardware. A single-core host with 512 MB of memory\n[runs the company's public TLS endpoints, git forge and onion service](/portfolio/a-whole-company-on-one-small-server/),\nwith backup automation implemented separately. Its container plane is Quadlet units under the same\nsupervisor as everything else rather than a daemon with its own. Over a recorded day of samples,\nthe available memory never fell below about 310 MB of the 464 MB usable.\n\nEarlier, across twenty Docker-packaged applications spread over Google Cloud and AWS,\n[the troubleshooting went through Podman](/portfolio/ran-20-docker-apps-on-google-cloud-and-aws/),\nwith Kubernetes used for the orchestration side. The images were the same; the tool around them was\na choice.\n\n## Where it goes wrong\n\nMost Podman trouble comes from expecting it to behave like Docker, or like a plain systemd unit,\nwhen it is a little of both.\n\n**An edited Quadlet file changes nothing.** The generator runs at boot and on\n`systemctl daemon-reload`, so a change on disk is invisible until one of those happens. Then\n`systemctl enable` refuses the generated service, because systemd treats it as transient. Boot-time\nstart belongs in the file's own `[Install]` section:\n\n```ini\n# /etc/containers/systemd/web.container\n[Unit]\nDescription=Web front end\n\n[Container]\nImage=docker.io/library/nginx:1.27\nNetwork=host\n\n[Service]\nRestart=always\n\n[Install]\nWantedBy=multi-user.target\n```\n\nAfter saving it, run `systemctl daemon-reload` and `systemctl start web.service`.\n\n**A rootless service stops when its owner logs out.** User units live inside the user's own systemd\nmanager, which ends with the last session. Running `loginctl enable-linger` for that user keeps the\nmanager alive from boot, which any rootless service meant to survive a reboot needs.\n\n**A rootless web server asks for port 80 and is refused.** Ports below 1024 require root or the\n`CAP_NET_BIND_SERVICE` capability, and that rule applies to the user Podman runs as. Publish a high\nport and put a proxy in front, or lower the kernel's `ip_unprivileged_port_start` setting on\npurpose, knowing it applies to every user on the host.\n\n**Files in a bind mount belong to a stranger.** In rootless mode the user's own UID becomes root\ninside the container, and every other container UID maps into the subordinate range. A process\nrunning as UID 999 inside writes files the host sees as owned by something like 100998.\n`podman unshare` opens a shell inside the same mapping, where `chown` behaves as the container\nexpects, and the `U` option on a mount changes ownership to match the container automatically.\n\n## Further reading\n\n- [What is Podman?](https://docs.podman.io/en/latest/) — the project's own documentation, starting\n  from its definition of the tool.\n- [podman-systemd.unit](https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html) — the\n  Quadlet reference: file types, search paths and every key.\n- [Basic Setup and Use of Podman in a Rootless environment](https://github.com/podman-container-tools/podman/blob/main/docs/tutorials/rootless_tutorial.md)\n  — subordinate IDs, user namespaces and pasta networking.\n- [podman-unshare](https://docs.podman.io/en/latest/markdown/podman-unshare.1.html) — entering the\n  rootless user namespace to inspect or fix ownership.\n- [podman-generate-systemd](https://docs.podman.io/en/latest/markdown/podman-generate-systemd.1.html)\n  — the older way to make units, and its deprecation in favour of Quadlet.\n\n\u003chttps://engineer.company/glossary/podman/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"What Podman is, how it runs Docker images without a daemon, why systemd can supervise its containers, and the rootless surprises to expect first.","formats":{"gemtext":"https://engineer.company/glossary/podman/index.gmi","gopher":"https://engineer.company/glossary/podman/gophermap","html":"https://engineer.company/glossary/podman/","json":"https://engineer.company/glossary/podman/index.json","markdown":"https://engineer.company/glossary/podman/index.md","pdf":"https://engineer.company/glossary/podman/index.pdf"},"kind":"page","language":"en","title":"What is Podman?","url":"https://engineer.company/glossary/podman/","version":1}