Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Socket, Compose und Terminal-Oberflächen

Ziel: Podman eine Docker-kompatible API geben, notes mit podman compose starten und die Container mit lazydocker, ctop und podman stats/events beobachten. · Dauer: ca. 60 min · Voraussetzung: Tag 3

Briefing

  • Podman hat keinen Daemon – aber auf Wunsch einen Socket. systemd lauscht und startet podman system service erst bei der ersten Anfrage.
  • Der Socket spricht die Docker-API (und die eigene libpod-API). Werkzeuge für Docker finden ihn über DOCKER_HOST.
  • podman compose ist nur ein Wrapper: Es ruft docker-compose oder podman-compose auf. Einen davon musst du installieren.
  • lazydocker und ctop sind Terminal-Oberflächen über der Docker-API. ctop ist seit 2022 ohne Release – Nachfolger sind lazydocker und podman stats.
 lazydocker, ctop, docker-compose, curl
          │  DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock
          ▼
 podman.socket ──(erste Anfrage)──► podman.service ──► Container, Pods, Images
                                    (podman system service)
 podman compose ──► podman-compose ──► podman-CLI (ohne Socket)

Drill 1: Der Podman-Socket

Tagesstart mit dem Stand von Tag 3 – der Quadlet-Pod läuft:

source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag04 && cd ~/ct-lab/tag04
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag03/notes/." .
systemctl --user cat podman.socket --no-pager | grep -v -E '^#|^$'
systemctl --user enable --now podman.socket
systemctl --user status podman.socket --no-pager | sed -n 1,5p
ls -l "$XDG_RUNTIME_DIR/podman/podman.sock"

Erwartet (gekürzt, Zeiten weichen bei dir ab):

[Unit]
Description=Podman API Socket
Documentation=man:podman-system-service(1)
[Socket]
ListenStream=%t/podman/podman.sock
SocketMode=0660
[Install]
WantedBy=sockets.target
Created symlink '/home/ubuntu/.config/systemd/user/sockets.target.wants/podman.socket' …
● podman.socket - Podman API Socket
     Loaded: loaded (/usr/lib/systemd/user/podman.socket; enabled; preset: enabled)
     Active: active (listening) since Fri 2026-10-30 19:07:21 UTC; 24ms ago
 Invocation: 135b8d7ff0894925aa205b0507659c30
   Triggers: ● podman.service
srw-rw---- 1 ubuntu ubuntu 0 Oct 30 19:07 /run/user/1000/podman/podman.sock

%t ist $XDG_RUNTIME_DIR, also /run/user/1000. Der Socket gehört dir, Modus 0660: Nur du (und root) sprechen mit deinem Podman. Rootful läge er unter /run/podman/podman.sock.

S="$XDG_RUNTIME_DIR/podman/podman.sock"
curl -s --unix-socket "$S" http://d/_ping; echo
curl -s --unix-socket "$S" http://d/version \
  | jq '{Version, ApiVersion, MinAPIVersion, Arch, C: [.Components[].Name]}'
systemctl --user is-active podman.service

Erwartet:

OK
{
  "Version": "5.7.0",
  "ApiVersion": "1.41",
  "MinAPIVersion": "1.24",
  "Arch": "arm64",
  "C": [
    "Podman Engine",
    "Conmon",
    "OCI Runtime (crun)"
  ]
}
active

ApiVersion 1.41 ist die Docker-API-Version, die Podman nachbildet. Der Hostname d in der URL ist beliebig – curl braucht einen, der Socket ignoriert ihn. Die erste Anfrage hat podman.service gestartet; nach einigen Sekunden ohne Anfragen beendet es sich wieder.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Docker-API und DOCKER_HOST

Zwei APIs am selben Socket: /v1.41/… (Docker) und /v5.0.0/libpod/… (Podman, kennt Pods):

curl -s --unix-socket "$S" http://d/v1.41/containers/json \
  | jq -r '.[] | "\(.Names[0]) \(.State)"'
curl -s --unix-socket "$S" http://d/v5.0.0/libpod/pods/json \
  | jq -r '.[] | "\(.Name) \(.Status) \(.Containers | length)"'
echo "export DOCKER_HOST=unix://\$XDG_RUNTIME_DIR/podman/podman.sock" >> ~/.bashrc
export DOCKER_HOST="unix://$XDG_RUNTIME_DIR/podman/podman.sock"
podman --remote ps --format '{{.Names}}'

Erwartet:

/notes-infra running
/notes-db running
/notes-api running
/notes-web running
notes Running 4
notes-infra
notes-db
notes-web
notes-api

podman --remote ist Podman als reiner Client über den Socket – genau so arbeitet Podman auf dem Mac mit seiner VM. DOCKER_HOST steht ab jetzt in ~/.bashrc; alle Werkzeuge in diesem Kapitel lesen die Variable.

Fortschritt speichern? Kostenlos registrieren

Drill 3: podman compose und sein Provider

podman compose version 2>&1 | tail -3

Erwartet:

    * exec: "/usr/libexec/docker/cli-plugins/docker-compose": stat /usr/libexec/docker/c…
    * exec: "docker-compose": executable file not found in $PATH
    * exec: "podman-compose": executable file not found in $PATH

podman compose sucht zuerst das Docker-Compose-Plugin (~/.docker/cli-plugins, /usr/libexec/docker/cli-plugins …), dann docker-compose und podman-compose im PATH. Auf Ubuntu 26.04 gibt es zwei Pakete:

apt-cache policy podman-compose docker-compose-v2 | grep -E '^[a-z]|Candidate'
apt-get install -s docker-compose-v2 | grep '^Inst' | cut -d' ' -f2

Erwartet:

podman-compose:
  Candidate: 1.5.0-2
docker-compose-v2:
  Candidate: 2.40.3+ds1-0ubuntu1
pigz
bridge-utils
runc
containerd
dns-root-data
dnsmasq-base
docker-compose-v2
docker.io
ubuntu-fan

docker-compose-v2 zieht die ganze Docker-Engine samt containerd nach – das würde sich mit Tag 6 beißen. Also podman-compose, ein Python-Programm, das die Compose-Datei in podman-Aufrufe übersetzt:

Steckbrief podman-compose
Aufgabe Compose-Dateien mit Podman ausführen (Provider für podman compose)
Besonderheit ruft die podman-CLI direkt auf, braucht keinen Socket
Projekt github.com/containers/podman-compose
Version im Buch 1.5.0 (Ubuntu-Paket podman-compose)
sudo apt-get install -y podman-compose
podman compose version

Erwartet (gekürzt):

>>>> Executing external compose provider "/usr/bin/podman-compose". Please see podman…
podman version 5.7.0
podman-compose version 1.5.0

Den Hinweis auf den externen Provider schaltest du in containers.conf ab:

mkdir -p ~/.config/containers
cat > ~/.config/containers/containers.conf <<'EOF'
# ~/.config/containers/containers.conf – Stand Ende Tag 4
[engine]
compose_warning_logs = false
EOF
podman compose version

Erwartet:

podman version 5.7.0
podman-compose version 1.5.0

Fortschritt speichern? Kostenlos registrieren

Drill 4: notes mit podman compose

Dieselben Container wie der Quadlet-Pod, diesmal als Compose-Datei. Das Volume ist das von Tag 2 und 3 (external):

cat > compose.yaml <<'EOF'
# compose.yaml – Stand Ende Tag 4
name: notes

services:
  db:
    image: docker.io/library/postgres:18.6-alpine
    environment:
      POSTGRES_USER: notes
      POSTGRES_DB: notes
      POSTGRES_PASSWORD: lab-db-pw-123
    volumes:
      - pgdata:/var/lib/postgresql
    healthcheck:
      test: ["CMD", "pg_isready", "-h", "127.0.0.1", "-U", "notes", "-d", "notes"]
      interval: 2s
      retries: 30

  migrate:
    image: localhost/notes-api:0.1.0
    command: ["migrate"]
    environment:
      NOTES_DB_URL: postgres://notes:lab-db-pw-123@db:5432/notes
    depends_on:
      db:
        condition: service_healthy

  api:
    image: localhost/notes-api:0.1.0
    environment:
      NOTES_API_KEY: lab-api-key-123
      NOTES_DB_URL: postgres://notes:lab-db-pw-123@db:5432/notes
    ports:
      - "127.0.0.1:8080:8080"
    depends_on:
      migrate:
        condition: service_completed_successfully

  web:
    image: localhost/notes-web:0.1.0
    environment:
      NOTES_API_URL: http://api:8080
      NOTES_API_KEY: lab-api-key-123
    ports:
      - "127.0.0.1:3000:3000"
    depends_on: [api]

  worker:
    image: localhost/notes-worker:0.1.0
    environment:
      NOTES_API_URL: http://api:8080
      NOTES_API_KEY: lab-api-key-123
    depends_on: [api]

volumes:
  pgdata:
    external: true
    name: notes-pgdata   # dasselbe Volume wie der Quadlet-Pod (Tag 3)
EOF
systemctl --user stop notes-pod.service
sleep 3
podman compose up -d
sleep 3
podman ps -a --format '{{.Names}}\t{{.Status}}'
curl -s -X POST 127.0.0.1:3000/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"Tag 4 mit podman compose"}'; echo
sleep 10
podman compose logs worker | tail -1
podman pod ps --format '{{.Name}} {{.Status}} {{.NumberOfContainers}}'

Erwartet (gekürzt):

e9f39aea43f8…
…
notes_db_1
notes_migrate_1
notes_api_1
notes_web_1
notes_worker_1
notes_db_1  Up 11 seconds (healthy)
notes_migrate_1 Exited (0) 4 seconds ago (stopped)
notes_api_1 Up 6 seconds (healthy)
notes_web_1 Up 5 seconds
notes_worker_1  Up 4 seconds
{"id":"f498e6c0-…","text":"Tag 4 mit podman compose"}
summary: 3 notes, 13 words
pod_notes Degraded 5
  • Der Quadlet-Pod muss vorher weg: Er belegt dieselben Ports. Die drei Sekunden Pause braucht es, bis pasta die Ports freigegeben hat – sonst scheitert up mit internal libpod error.
  • depends_on mit service_healthy und service_completed_successfully versteht podman-compose 1.5 – migrate läuft erst nach dem Healthcheck, api erst nach migrate.
  • podman-compose nennt Container <projekt>_<dienst>_1 und steckt sie in einen Pod pod_notes ohne Infra-Container. Degraded heißt: Nicht alle Container laufen (migrate ist fertig).

Abbauen und den Quadlet-Pod zurückholen:

podman compose down >/dev/null 2>&1
podman volume ls -q
systemctl --user start notes-pod.service

Erwartet:

notes-pgdata

down lässt das externe Volume in Ruhe – die Notiz von heute siehst du gleich im Quadlet-Pod.

Fortschritt speichern? Kostenlos registrieren

Drill 5: lazydocker

Steckbrief lazydocker
Aufgabe Container, Images, Volumes, Netze und Compose-Projekte im Terminal verwalten
Besonderheit spricht nur die Docker-API; Logs, Stats und Aktionen auf einen Tastendruck
Projekt github.com/jesseduffield/lazydocker
Version im Buch 0.25.2 (Release-Binary)

Installiert mit dem Prinzip von Tag 0 – laden, prüfen, auspacken, installieren:

mkdir -p /tmp/dl && cd /tmp/dl
B=https://github.com/jesseduffield/lazydocker/releases/download/v0.25.2
curl -fsSLO "$B/lazydocker_0.25.2_Linux_arm64.tar.gz"
curl -fsSLO "$B/checksums.txt"
sha256sum -c --ignore-missing checksums.txt
grep '^lazydocker arm64' ~/ct-lab/setup/tools.lock | awk '{print $4}'
tar -xzf lazydocker_0.25.2_Linux_arm64.tar.gz lazydocker
sudo install -m 0755 lazydocker /usr/local/bin/
cd ~ && rm -rf /tmp/dl
lazydocker --version | head -1

Erwartet:

lazydocker_0.25.2_Linux_arm64.tar.gz: OK
005c38b685aaa557e7d646d83a3dadb5024340eeed8c6a2e1949eee6f530de23
Version: 0.25.2

Dieselbe Prüfsumme steht in tools.lock; an Tag 0 hast du lazydocker schon so installiert. So funktioniert lazydocker: Es liest über DOCKER_HOST Container, Images, Volumes und Netze, zeigt Logs und Statistiken live und führt Aktionen als API-Aufrufe aus. Starten:

lazydocker

Erwartet (gekürzt, Ausschnitt des Bildschirms):

╭─[3]─Containers────────────────────╮╭─Logs - Stats - Env - Config - Top──────────────
│running (healthy) notes-api   0.00%││time=2026-10-30T19:10:24.645Z level=INFO msg="ap…
│running (healthy) notes-db    0.00%││source=env
│running           notes-infra 0.00%││time=2026-10-30T19:10:24.688Z level=INFO msg="st…
│running           notes-web   0.00%││store=postgres
╰───────────────────────────────────╯│
╭─[4]─Images────────────────────────╮│
│docker.io/library/golang   1.27-alp▐│
│docker.io/library/nginx    1.30.6-a▐│
╭─[5]─Volumes───────────────────────╮│
│local notes-pgdata                 ││
╭─[6]─Networks──────────────────────╮│
│bridge bridge                      ││
│bridge notes                       ││
PgUp/PgDn: scroll, b: view bulk commands, q: quit, x: menu, ← → ↑ ↓: navigate   …
Taste Wirkung
1…6 Panel wählen (Projekt, Dienste, Container, Images, Volumes, Netze)
[ ] Reiter rechts wechseln: Logs, Stats, Env, Config, Top
s r d Container stoppen, neu starten, entfernen
E Shell im Container (nicht bei notes-api: scratch)
x Menü mit allen Tasten des Panels, q beendet

Wähle mit 3 und den Pfeiltasten notes-db, dann zweimal ]: Der Reiter Stats zeichnet CPU und Speicher als Kurve. Das Netz podman heißt in der Docker-API bridge.

Achtung: Stoppst du in lazydocker einen Quadlet-Container, startet systemd ihn nicht neu (Restart=on-failure, ein Stopp ist kein Fehler) – und der Pod gilt danach als verändert. Dienste unter systemd steuerst du mit systemctl --user.

Für Compose-Projekte ruft lazydocker docker compose auf. Mit Podman stellst du das in der Konfiguration um:

mkdir -p ~/.config/lazydocker
cat > ~/.config/lazydocker/config.yml <<'EOF'
# ~/.config/lazydocker/config.yml – Stand Ende Tag 4
commandTemplates:
  dockerCompose: podman compose
EOF
lazydocker -c | grep -E '^commandTemplates:|dockerCompose:'

Erwartet:

commandTemplates:
  dockerCompose: docker compose

lazydocker -c zeigt die Standardwerte – nützlich, um Schlüssel nachzuschlagen. Deine Datei überschreibt davon nur, was in ihr steht.

Fortschritt speichern? Kostenlos registrieren

Drill 6: ctop – kurz, und warum veraltet

Steckbrief ctop
Aufgabe top für Container: CPU, Speicher, Netz, I/O je Container
Besonderheit sehr schlank; letzter Release März 2022, Docker-Client von damals
Projekt github.com/bcicen/ctop
Version im Buch 0.7.7 (Release-Binary, veraltet)

ctop liefert ein einzelnes Binary und eine sha256sums.txt:

mkdir -p /tmp/dl && cd /tmp/dl
B=https://github.com/bcicen/ctop/releases/download/v0.7.7
curl -fsSLO "$B/ctop-0.7.7-linux-arm64"
curl -fsSLO "$B/sha256sums.txt"
sha256sum -c --ignore-missing sha256sums.txt
sudo install -m 0755 ctop-0.7.7-linux-arm64 /usr/local/bin/ctop
cd ~ && rm -rf /tmp/dl
ctop -v
ctop

Erwartet (gekürzt):

ctop-0.7.7-linux-arm64: OK
ctop version 0.7.7, build 11a1cb1 go1.18
  ctop - 19:11:23 UTC   4 containers

     NAME              CID          CPU        MEM        NET RX/TX  IO R/W     PIDS
 ☼ ⏵ notes-api         f48edfd6bc33      0%      2M / 4G  2K / 768B  0B / 0B    8
 ☼ ⏵ notes-db          4cc55748f48a      0%      26M / 4G 2K / 768B  0B / 0B    10
   ⏵ notes-infra       a257f0f173d1      0%     228K / 4G 2K / 768B  0B / 0B    1
   ⏵ notes-web         ae2cdb9f404c      0%      20M / 4G 2K / 768B  0B / 0B    7

ctop läuft gegen den Podman-Socket, q beendet. ☼ markiert Container mit Healthcheck. Warum trotzdem nur kurz? Seit Version 0.7.7 (März 2022) gibt es keinen Release mehr, gebaut mit Go 1.18 – Sicherheitskorrekturen in Go und im Docker-Client kommen nie an, und neue API-Felder kennt es nicht. ctop -h zeigt außer docker nur noch den Connector runc. Alles, was ctop kann, kann lazydocker im Stats-Reiter – oder Podman selbst.

Fortschritt speichern? Kostenlos registrieren

Drill 7: podman stats und podman events

podman stats --no-stream --format 'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}'
podman pod stats --no-stream --format '{{.Pod}} {{.Name}} {{.MemUsage}}'

Erwartet (gekürzt, Werte weichen ab):

NAME         CPU %       MEM USAGE / LIMIT
notes-infra  0.01%       233.5kB / 4.199GB
notes-db     1.28%       27.01MB / 4.199GB
notes-api    0.26%       2.105MB / 4.199GB
notes-web    0.66%       20.46MB / 4.199GB
POD NAME MEM USAGE/ LIMIT
3e0841db589b notes-api 2.003MB / 4.199GB
3e0841db589b notes-infra 344.1kB / 4.199GB
3e0841db589b notes-db 25.31MB / 4.199GB
3e0841db589b notes-web 26.62MB / 4.199GB

Ohne --no-stream aktualisiert sich die Anzeige wie bei ctop. Events erzählen, was passiert – live in einem zweiten Terminal oder rückblickend:

podman kill notes-api >/dev/null
sleep 15
podman events --since 30s --until 1s --filter container=notes-api \
  --format '{{.Status}} {{.Name}}'
podman events --since 30s --until 1s --filter container=notes-api \
  --filter event=died --format json | jq -c '{Name, ContainerExitCode}'

Erwartet (gekürzt):

kill notes-api
died notes-api
remove notes-api
create notes-api
init notes-api
start notes-api
health_status notes-api
{"Name":"notes-api","ContainerExitCode":137}

Der ganze Neustart aus Tag 3 in Ereignissen: getötet, entfernt (--rm), neu angelegt, gestartet, Healthcheck. Ohne --until läuft podman events weiter und zeigt neue Ereignisse, bis du es mit Strg+C beendest.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Der Podman-Socket ist aktiviert und antwortet:

cd ~/ct-lab/tag04
systemctl --user is-enabled podman.socket
curl -s --unix-socket "$XDG_RUNTIME_DIR/podman/podman.sock" http://d/_ping; echo
grep DOCKER_HOST ~/.bashrc

Erwartet:

enabled
OK
export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock

Compose-Provider und gültige Datei:

podman compose version
podman compose config -q; echo "Exit: $?"

Erwartet (gekürzt):

Docker Compose version v5.6.1
Exit: 0

Die beiden TUIs:

lazydocker --version | head -1
ctop -v

Erwartet:

Version: 0.25.2
ctop version 0.7.7, build 11a1cb1 go1.18

Der Quadlet-Pod läuft und hat die Notiz aus Drill 4:

systemctl --user is-active notes-pod.service
curl -s 127.0.0.1:8080/notes | jq -r '.[].text'

Erwartet:

active
Tag 2 im Pod
Tag 3 mit Quadlet
Tag 3 mit Quadlet
Tag 4 mit podman compose

Challenge

Starte dieselbe compose.yaml mit dem Original Docker Compose über den Podman-Socket – ohne Docker-Engine und ohne docker-compose-v2 aus apt.

Hinweis: Docker Compose gibt es als einzelnes Binary bei github.com/docker/compose/releases; podman compose sucht es zuerst in ~/.docker/cli-plugins/.

Lösung

mkdir -p /tmp/dl && cd /tmp/dl
B=https://github.com/docker/compose/releases/download/v5.6.1
curl -fsSLO "$B/docker-compose-linux-aarch64"
curl -fsSLO "$B/checksums.txt"
sha256sum -c --ignore-missing checksums.txt
mkdir -p ~/.docker/cli-plugins
install -m 0755 docker-compose-linux-aarch64 ~/.docker/cli-plugins/docker-compose
cd ~/ct-lab/tag04 && rm -rf /tmp/dl
podman compose version
systemctl --user stop notes-pod.service
sleep 3
podman compose up -d 2>&1 | tail -3
sleep 2
podman ps -a --format '{{.Names}}\t{{.Status}}'

Erwartet (gekürzt):

docker-compose-linux-aarch64: OK
Docker Compose version v5.6.1
 Container notes-worker-1 Starting
 Container notes-web-1 Started
 Container notes-worker-1 Started
notes-db-1  Up 4 seconds (healthy)
notes-migrate-1 Exited (0) 3 seconds ago (starting)
notes-api-1 Up 3 seconds (healthy)
notes-worker-1  Up 2 seconds
notes-web-1 Up 2 seconds

Docker Compose spricht über DOCKER_HOST mit dem Socket und nennt die Container wie gewohnt notes-db-1. Zurück zum Stand des Tages – down zweimal wegen der AppArmor-Falle aus Tag 2 (eigenes Netz notes_default):

podman compose down 2>&1 | tail -1
podman compose down 2>&1 | tail -1
rm ~/.docker/cli-plugins/docker-compose
systemctl --user start notes-pod.service
podman compose version | tail -1

Erwartet (gekürzt):

Error: executing /home/ubuntu/.docker/cli-plugins/docker-compose down: exit status 1
 Network notes_default Removed
podman-compose version 1.5.0

Ohne Plugin ist wieder podman-compose der Provider.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Der Socket ist root-gleich für den User, dem er gehört: Wer ihn erreicht, startet beliebige Container. Nie per TCP ohne mTLS freigeben, nie in Container mounten, die das nicht unbedingt brauchen.
  • Für Server ist Quadlet (Tag 3) der bessere Weg als Compose: systemd-Abhängigkeiten, Neustart, Logs im Journal, kein zusätzliches Python-Programm.
  • Teams mit bestehenden compose.yaml fahren mit Docker Compose über den Podman-Socket meist kompatibler als mit podman-compose; die Version gehört dann in eine Lock-Datei.
  • TUIs wie lazydocker sind Werkzeuge für Menschen. Für Betrieb gehören Metriken in ein Monitoring (Prometheus über podman system service oder cAdvisor) und Ereignisse in das zentrale Logging.
  • Werkzeuge ohne Releases (ctop) fliegen aus der Lock-Datei: Ein unbewegtes Binary sammelt nur noch Schwachstellen.