Skip to content
Blog

Podman and systemd as a Lightweight Alternative to Orchestration

Rootless Podman plus systemd Quadlet units, socket activation, and auto-update cover small fleets without an API server — and here is where the pattern stops scaling.

Published on • November 15, 2026

AI Assistant

Not every small deployment needs an orchestrator. A handful of services on one or two boxes — a reverse proxy, an app, a database, a cron-ish worker — often gets wrapped in Kubernetes purely because “containers go on Kubernetes” has become the default reflex. Podman plus systemd offers a genuinely different answer: a daemonless, rootless container engine whose units are managed by the same systemctl your operating system already uses for everything else. No API server to upgrade, no datastore to back up, no scheduler to reason about. This post walks through the pattern — rootless pods, Quadlet unit files, socket activation, and podman auto-update — and then draws the honest line where it stops being enough.

Daemonless and rootless by default

Podman (currently at 6.x, Apache 2.0) has no long-running daemon. Each container is supervised by a small conmon process, and the CLI talks directly to it — which means systemd is already your process supervisor, not a container runtime wrapped inside another one. The practical consequences:

  • No single daemon to crash. If the Podman CLI or a container exits, nothing else is affected. Killing the container’s parent shell does not orphan it the way it can with a socket-attached client.
  • Rootless works properly. With cgroups v2, an unprivileged user runs containers in their own user namespace, with pasta (or slirp4netns) providing networking. Files written by containers belong to the mapped host UID — no root-owned surprises in your home directory.
  • systemd integration is native, not bolted on. The unit dependency graph (After=network-online.target, Wants=, Requires=) governs startup order for free.

Verify the basics:

podman info --format '{{.Host.Security.Rootless}}'
podman run --rm docker.io/library/alpine:latest uname -m

Quadlet: containers as first-class systemd units

The production mechanism is Quadlet — Podman’s systemd unit generator. You write unit fragments in Podman’s native format, and systemd generates the real service units from them:

  • System-wide: /etc/containers/systemd/
  • Per-user: ~/.config/containers/systemd/

Supported suffixes include .container, .pod, .network, .volume, and .kube (the last one applies a Kubernetes YAML file through Podman). A service unit:

# ~/.config/containers/systemd/shop-api.container
[Unit]
Description=Shop API
After=network-online.target

[Container]
Image=registry.example.com/shop-api:1.4.2
PublishPort=8080:8080
Environment=SHOP_ENV=production
AutoUpdate=registry
Restart=always

[Install]
WantedBy=default.target

Then:

systemctl daemon-reload
systemctl --user enable --now shop-api
systemctl --user status shop-api
journalctl --user -u shop-api -f

Useful details that make this more than a novelty:

  • Quadlet also supports .pod units (a Podman pod — shared network namespace, the closest thing to a Kubernetes pod on one host), .network units for custom networks, and .volume units for named volumes with driver options.
  • Pod-to-pod dependencies map to systemd ordering: After=shop-db.service in the .container unit, or Quadlet’s Pull/Notify conventions for readiness (a container can sd_notify READY through the socket when it uses the notify health mechanism).
  • podman generate systemd is history. It was deprecated in Podman 4.5 and removed in Podman 5.0 in favour of Quadlet. If you find blog posts emitting podman generate systemd --new files, they are describing a dead end — Quadlet is the supported path.

The compose escape hatch exists too: podman-compose (the Python implementation) or podman compose (a wrapper that delegates to an installed compose provider) will ingest a Compose file for multi-container projects. For anything long-lived, though, converting to .container units buys you restart ordering, journal integration, and socket activation — things Compose files do not provide.

Auto-update: the patch channel

Small fleets die of unpatched images, not of missing schedulers. Podman’s answer is label-driven auto-update:

podman pull registry.example.com/shop-api:1.4.2
podman inspect --format '{{.Config.Labels}}' registry.example.com/shop-api:1.4.2

Label images at build time with io.containers.autoupdate=registry (the image reference is re-resolved against the registry) or io.containers.autoupdate=image (the exact tag is re-pulled). Then:

podman auto-update --dry-run --authfile /run/containers/0/auth.json

Or, for the real cadence, enable the shipped timer:

systemctl --user enable --now podman-auto-update.timer

The timer runs podman auto-update periodically; for every labeled container whose registry copy has a new digest, it pulls and restarts the container through systemd. Two constraints to internalize:

  1. Registry auto-update requires a registry-pulled image. Locally built images (no digest to compare) are skipped.
  2. A restart is not a rolling update. There is one instance on one host; systemd restarts it in place. Plan a maintenance window or a dual-instance pattern (two containers plus a proxy) if zero-downtime matters.

Socket activation and API compatibility

Podman ships a socket unit (podman.socket, podman.socket for rootless users too) that systemd activates on demand, exposing the Docker-compatible API over a Unix socket ($XDG_RUNTIME_DIR/podman/podman.sock). This buys two things:

  • On-demand activation — the API only exists when a client connects, which is the systemd-native way to avoid idle daemons.
  • Tool compatibility — anything speaking the Docker API (DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock docker ..., monitoring agents, CI helpers) works against Podman without a daemon running full-time.

For a small fleet, the operational shape becomes: Ansible (or your config-management tool of choice) drops the same set of unit files and image updates onto N hosts, each host runs systemctl daemon-reload && systemctl restart, and journald collects the logs. There is no control plane because there is nothing to control — each box is an independent, identical unit of deployment.

When systemd + Podman covers a small fleet — and when it doesn’t

It covers you when: you have one to a handful of hosts; services are independently restartable; “deploy” means “roll out a new image digest to N identical boxes”; state is either external, replicated by the database, or acceptable to lose; and your team already thinks in systemctl and journals. Home labs, single-box appliances, small internal tools, on-prem edge boxes, and legacy hosts being containerized without a platform team all live comfortably here.

It stops covering you at predictable boundaries:

  • No cross-host scheduling. Nothing places a workload where capacity, labels, or anti-affinity say it should go. If a host dies, its containers do not relocate — a human or your config-management re-runs the rollout elsewhere.
  • Weak rolling-update semantics. No readiness gates shifting traffic, no maxSurge/maxUnavailable, no PDB-equivalent. Restart in place, or hand-roll blue/green with two unit files and a proxy. Healthchecks (--health-cmd) plus Restart=on-failure give you crash recovery, not zero-downtime delivery.
  • No reconciliation. If someone runs podman rm -f on a host, systemd only knows the service failed — it will not recreate the container from the spec unless the unit is written to run the container itself (Quadlet does this, which is exactly why the unit file, not a hand-run podman run, must be the source of truth).
  • Networking stays host-local. No cluster-wide Service discovery or overlay; inter-service addressing is hostnames and ports you manage yourself (or a small Consul/Redis-style registry if you insist).
  • Secrets and config are file drops. EnvironmentFile= and Podman secrets work, but there is no central secret rotation story.

The pragmatic dividing line: if your mental model of a deploy is “copy files and restart services on these five hosts,” Podman + systemd is not a compromise — it is the right-sized tool, and Kubernetes would be an expensive way to get a worse systemctl. When you find yourself writing scripts to coordinate rollouts across hosts, checking capacity before restarting, or wishing pods would move when a box dies — that is the migration signal, and by then your containers are already OCI images that a real cluster can pull.

References