Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 2: Rootless und Pods

Ziel: Verstehen, wie rootless Podman UIDs, Dateirechte und Ports abbildet, notes als Pod mit Postgres betreiben und den Pod als Kubernetes-YAML exportieren und wieder starten. · Dauer: ca. 75 min · Voraussetzung: Tag 1

Briefing

  • Rootless läuft jeder Container in einem User Namespace: UID 0 im Container ist dein User, alle anderen UIDs kommen aus deinem Bereich in /etc/subuid.
  • Dateien, die ein Container anlegt, gehören auf dem Host deshalb oft „fremden” UIDs wie 100069. podman unshare öffnet eine Shell in genau diesem Namespace.
  • Das Netz macht pasta: Es leitet Ports vom Host in den Container weiter. Ports unter 1024 darf ein normaler User nicht öffnen.
  • Ein Pod ist eine Gruppe von Containern mit gemeinsamem Netz: Alle erreichen sich über 127.0.0.1. Das Konzept stammt aus Kubernetes – podman kube spricht dessen YAML.
 Pod notes (Infra-Container hält Netz-Namespace)          Host
 ┌────────────────────────────────────────────────┐
 │ notes-db :5432 ◄─ notes-api :8080 ◄─ notes-web :3000 ◄──── 127.0.0.1:3000
 │      │            (127.0.0.1)                  │ ◄───────── 127.0.0.1:8080
 │      └── Volume notes-pgdata                   │
 └────────────────────────────────────────────────┘

Drill 1: subuid, subgid und newuidmap

Tagesstart mit dem Stand von Tag 1:

source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag02 && cd ~/ct-lab/tag02
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag01/notes/." .
id
grep "^$USER:" /etc/subuid /etc/subgid
ls -l /usr/bin/newuidmap /usr/bin/newgidmap

Erwartet (gekürzt):

uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),24(cdrom),27(sudo),…
/etc/subuid:ubuntu:100000:65536
/etc/subgid:ubuntu:100000:65536
-rwsr-xr-x 1 root root 41944 Feb  2  2026 /usr/bin/newgidmap
-rwsr-xr-x 1 root root 41944 Feb  2  2026 /usr/bin/newuidmap
  • ubuntu:100000:65536 heißt: Dein User darf die 65 536 UIDs ab 100000 benutzen. useradd trägt solche Bereiche bei jedem neuen User automatisch ein.
  • newuidmap und newgidmap sind setuid-root (s im Modus). Sie schreiben das Mapping in den Kernel – das einzige Stück root, das rootless Podman braucht.

Fortschritt speichern? Kostenlos registrieren

Drill 2: podman unshare und das UID-Mapping

cat /proc/self/uid_map
podman unshare cat /proc/self/uid_map
podman unshare id
podman run --rm docker.io/library/nginx:1.30.6-alpine cat /proc/self/uid_map

Erwartet:

         0          0 4294967295
         0       1000          1
         1     100000      65536
uid=0(root) gid=0(root) groups=0(root)
         0       1000          1
         1     100000      65536

Die drei Spalten: UID innen, UID außen, Anzahl. Außerhalb sieht dein Prozess alle UIDs 1:1. Im Namespace ist UID 0 = 1000 (du), UID 1 = 100000, UID 70 also 100000 + 70 − 1 = 100069. Prüfen mit Postgres, das als UID 70 läuft:

podman run --rm docker.io/library/postgres:18.6-alpine id postgres
podman run -d --name pg-test -e POSTGRES_PASSWORD=lab-db-pw-123 \
  docker.io/library/postgres:18.6-alpine
sleep 3
ps -o user,pid,args -u 100069 | head -3
podman rm -f -t 0 pg-test

Erwartet (gekürzt, PIDs weichen ab):

Trying to pull docker.io/library/postgres:18.6-alpine...
…
uid=70(postgres) gid=70(postgres) groups=70(postgres),70(postgres)
1f0c…
USER         PID COMMAND
100069     73958 bash /usr/local/bin/docker-entrypoint.sh postgres
100069     73988 initdb --username=postgres --pwfile=/dev/fd/63
pg-test

Postgres initialisiert gerade seine Datenbank – als 100069. Für ps ist das eine UID ohne Namen – sie gehört niemandem auf dem Host. Bricht ein Prozess aus dem Container aus, hat er nicht einmal deine Rechte.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Volumes und Rechte, :U

Ein Bind-Mount ist ein Ordner von dir. Postgres startet als root und richtet sich die Rechte selbst ein; viele Images starten aber direkt als normaler User. Das simulierst du mit --user 70:70:

mkdir pgdata-bind && ls -ldn pgdata-bind
podman run --name pg-bind --user 70:70 -e POSTGRES_PASSWORD=lab-db-pw-123 \
  -v ./pgdata-bind:/var/lib/postgresql docker.io/library/postgres:18.6-alpine \
  2>&1 | tail -1
podman rm pg-bind

Erwartet:

drwxr-xr-x 2 1000 1000 4096 Oct 30 19:00 pgdata-bind
mkdir: can't create directory '/var/lib/postgresql/18/': Permission denied
pg-bind

Der Ordner gehört dir (1000) – im Container also root. UID 70 darf dort nichts anlegen. Die Option :U passt den Besitzer vor dem Start an die Container-UID an:

podman run -d --name pg-bind --user 70:70 -e POSTGRES_PASSWORD=lab-db-pw-123 \
  -v ./pgdata-bind:/var/lib/postgresql:U docker.io/library/postgres:18.6-alpine
sleep 5
podman ps -a --filter name=pg-bind --format '{{.Names}} {{.Status}}'
ls -ldn pgdata-bind
podman unshare ls -ldn pgdata-bind

Erwartet (gekürzt):

915f7541…
pg-bind Up 5 seconds
drwxr-xr-x 3 100069 100069 4096 Oct 30 19:01 pgdata-bind
drwxr-xr-x 3 70 70 4096 Oct 30 19:01 pgdata-bind

Dieselbe Datei, zwei Sichten: außen 100069, im Namespace 70. Die Kehrseite: Du selbst kommst an die Dateien nicht mehr heran.

podman rm -f pg-bind
rm -rf pgdata-bind; echo "Exit: $?"
podman unshare rm -rf pgdata-bind && ls -d pgdata-bind

Erwartet (gekürzt):

pg-bind
rm: cannot remove 'pgdata-bind/18/docker': Permission denied
Exit: 1
ls: cannot access 'pgdata-bind': No such file or directory

Im Namespace bist du root und darfst alles, was in deinem Bereich liegt. Named Volumes (-v notes-pgdata:/…) haben das Problem nicht: Sie liegen unter ~/.local/share/containers/storage/volumes, und Podman richtet die Rechte beim ersten Mount selbst ein.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Netz mit pasta, Ports unter 1024

podman run --rm docker.io/library/nginx:1.30.6-alpine ip -4 addr show eth0
podman run --rm -p 127.0.0.1:80:80 docker.io/library/nginx:1.30.6-alpine true
echo "Exit: $?"
sysctl net.ipv4.ip_unprivileged_port_start

Erwartet (gekürzt, Adressen weichen ab):

2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 65520 qdisc fq_codel state UNKNOWN …
    inet 192.168.64.…/24 brd 192.168.64.255 scope global eth0
       valid_lft forever preferred_lft forever
Error: pasta failed with exit code 1:
Listen failed for HOST TCP port 127.0.0.1/80: Permission denied
Couldn't listen on requested TCP ports

Exit: 126
net.ipv4.ip_unprivileged_port_start = 1024
  • pasta gibt dem Container eine Kopie der Adresse deiner VM und übersetzt Verbindungen im User-Space. Kein Bridge-Interface, keine iptables-Regeln, kein root.
  • Ports unter 1024 sind privilegiert. Freischalten ginge systemweit per Sysctl net.ipv4.ip_unprivileged_port_start; im Labor bleiben wir bei 8080 und 3000.

Achtung: Ubuntu 26.04 schützt pasta mit einem AppArmor-Profil, das Signale von Podman ablehnt. Entfernst du rootless den letzten Container eines eigenen Netzes, meldet Podman rootless netns: kill network process: permission denied. Der Container ist trotzdem weg, die Meldung kannst du ignorieren. Pods im Standardnetz trifft das nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der Pod notes

podman pod create --name notes -p 127.0.0.1:8080:8080 -p 127.0.0.1:3000:3000
podman pod ps
podman ps -a --pod --format '{{.Names}}\t{{.PodName}}\t{{.Status}}'

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

16f6dcaf5f98…
POD ID        NAME        STATUS      CREATED                 INFRA ID      # OF CON…
16f6dcaf5f98  notes       Created     Less than a second ago  fedd3f40d7cc  1
16f6dcaf5f98-infra  notes   Created

Die Ports gehören dem Pod, nicht einem Container. Der Infra-Container tut nichts außer den Netz-Namespace zu halten. Jetzt die Datenbank mit named Volume:

podman volume create notes-pgdata
podman run -d --pod notes --name notes-db \
  -e POSTGRES_USER=notes -e POSTGRES_DB=notes -e POSTGRES_PASSWORD=lab-db-pw-123 \
  -v notes-pgdata:/var/lib/postgresql docker.io/library/postgres:18.6-alpine
until podman exec notes-db pg_isready -h 127.0.0.1 -U notes -d notes; do sleep 1; done

Erwartet (gekürzt):

notes-pgdata
c2f1c1c9…
127.0.0.1:5432 - no response
127.0.0.1:5432 - accepting connections

api und web finden die Datenbank und einander unter 127.0.0.1 – wie Prozesse auf derselben Maschine:

DB=postgres://notes:[email protected]:5432/notes
podman run --rm --pod notes -e NOTES_DB_URL=$DB localhost/notes-api:0.1.0 migrate
podman run -d --pod notes --name notes-api \
  -e NOTES_API_KEY=lab-api-key-123 -e NOTES_DB_URL=$DB localhost/notes-api:0.1.0
podman run -d --pod notes --name notes-web -e NOTES_API_URL=http://127.0.0.1:8080 \
  -e NOTES_API_KEY=lab-api-key-123 localhost/notes-web:0.1.0
sleep 4
podman ps --pod --format '{{.Names}}\t{{.PodName}}\t{{.Status}}'
curl -s -X POST 127.0.0.1:3000/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"Tag 2 im Pod"}'; echo
curl -s 127.0.0.1:8080/notes; echo
podman exec notes-db netstat -ltn

Erwartet (gekürzt):

time=… level=INFO msg="migration complete" table=notes
beea6244…
35374…
16f6dcaf5f98-infra  notes   Up 11 seconds
notes-db    notes   Up 11 seconds
notes-api   notes   Up 5 seconds (healthy)
notes-web   notes   Up 4 seconds
{"id":"1ac607e9-…","text":"Tag 2 im Pod"}
[{"id":"1ac607e9-…","text":"Tag 2 im Pod"}]
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:5432            0.0.0.0:*               LISTEN
tcp        0      0 :::3000                 :::*                    LISTEN
tcp        0      0 :::5432                 :::*                    LISTEN
tcp        0      0 :::8080                 :::*                    LISTEN

netstat im db-Container zeigt alle drei Dienste: ein Netz-Namespace für den ganzen Pod. Postgres lauscht auf 5432, ist aber nicht veröffentlicht – vom Host aus kommst du nur an 8080 und 3000.

Fortschritt speichern? Kostenlos registrieren

Drill 6: podman kube generate

podman kube generate notes -f notes-pod.yaml
grep -v -E '^#|SandboxID|creationTimestamp' notes-pod.yaml

Erwartet (gekürzt):

apiVersion: v1
kind: Pod
metadata:
  annotations:
  labels:
    app: notes
  name: notes
spec:
  containers:
  - args:
    - postgres
    env:
    - name: POSTGRES_DB
      value: notes
    - name: POSTGRES_USER
      value: notes
    - name: POSTGRES_PASSWORD
      value: lab-db-pw-123
    image: docker.io/library/postgres:18.6-alpine
    name: notes-db
    ports:
    - containerPort: 3000
      hostIP: 127.0.0.1
      hostPort: 3000
    - containerPort: 8080
      hostIP: 127.0.0.1
      hostPort: 8080
    volumeMounts:
    - mountPath: /var/lib/postgresql
      name: notes-pgdata-pvc
  - env:
    - name: NOTES_API_KEY
      value: lab-api-key-123
    - name: NOTES_DB_URL
      value: postgres://notes:[email protected]:5432/notes
    image: localhost/notes-api:0.1.0
    name: notes-api
    securityContext: {}
  - args:
    - node
    - server.js
    env:
    - name: NOTES_API_URL
      value: http://127.0.0.1:8080
    - name: NOTES_API_KEY
      value: lab-api-key-123
    image: localhost/notes-web:0.1.0
    name: notes-web
    securityContext: {}
  volumes:
  - name: notes-pgdata-pvc
    persistentVolumeClaim:
      claimName: notes-pgdata
  • Die Pod-Ports hängen am ersten Container (hostPort); Kubernetes hat keinen Infra-Container zum Anschreiben.
  • Das named Volume wird ein PersistentVolumeClaim mit claimName: notes-pgdata.
  • Die Passwörter stehen im Klartext – für Lab-Werte in Ordnung, in Produktion gehören sie in ein Secret (Enterprise-Notiz).

Fortschritt speichern? Kostenlos registrieren

Drill 7: podman kube play und kube down

Pod weg, YAML wieder abspielen:

podman pod rm -f notes
podman volume ls
podman kube play notes-pod.yaml
sleep 5
podman ps --pod --format '{{.Names}}\t{{.PodName}}\t{{.Status}}'
curl -s 127.0.0.1:8080/notes; echo

Erwartet (gekürzt):

16f6dcaf5f98…
DRIVER      VOLUME NAME
local       notes-pgdata
Pod:
9ac3b313…
Containers:
480e459f…
4cab69ee…
4e5da64e…

9ac3b3130d8f-infra  notes   Up 6 seconds
notes-notes-db  notes   Up 5 seconds
notes-notes-api notes   Up 5 seconds (starting)
notes-notes-web notes   Up 6 seconds
[{"id":"1ac607e9-…","text":"Tag 2 im Pod"}]
  • pod rm löscht Container, aber keine named Volumes. kube play findet den Claim notes-pgdata und hängt das bestehende Volume ein – die Notiz ist noch da.
  • Die Container heißen jetzt <pod>-<container>, also notes-notes-api.
  • kube play hängt Pods ins Netz podman-default-kube-network, nicht ins Standardnetz.

Abbauen geht mit derselben Datei:

podman kube down notes-pod.yaml
podman volume ls -q
podman kube play notes-pod.yaml >/dev/null

Erwartet (gekürzt):

Pods stopped:
Error: stopping container 4eae3488…: removing container 4eae3488… network: 1 error
occurred:
    * rootless netns: kill network process: permission denied

Pods removed:
9ac3b3130d8f…
Secrets removed:
Volumes removed:
notes-pgdata

Die Fehlermeldung ist die AppArmor-Falle aus Drill 4 (eigenes Netz) – der Pod ist trotzdem entfernt. kube down löscht Volumes nur mit --force. Für den Kontrollpunkt läuft der Pod wieder.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Dein User hat einen subuid-Bereich, unshare macht dich zu root im Namespace:

cd ~/ct-lab/tag02
grep "^$USER:" /etc/subuid
podman unshare id -u

Erwartet:

ubuntu:100000:65536
0

Volume, Pod-Definition und laufender Pod:

podman volume ls --format '{{.Name}}'
grep 'claimName' notes-pod.yaml
podman pod ps --filter name=notes --format '{{.Name}} {{.Status}}'

Erwartet (die erste Zeile ist ein anonymes Volume, ihre ID weicht ab):

07d0786783aa…
notes-pgdata
      claimName: notes-pgdata
notes Running

Die Notiz kommt aus dem Volume, der Bind-Ordner ist weg:

curl -s 127.0.0.1:8080/notes | jq -r '.[].text'
ls -d pgdata-bind

Erwartet:

Tag 2 im Pod
ls: cannot access 'pgdata-bind': No such file or directory

Challenge

Nimm notes-worker in den Pod auf – nur über das YAML, nicht per podman run. Der Worker soll alle 5 Sekunden zusammenfassen.

Hinweis: Der Worker liest NOTES_API_URL, NOTES_API_KEY und INTERVAL; kube play --replace ersetzt einen laufenden Pod.

Lösung

Kopie anlegen und vor volumes: einen vierten Container einfügen (ganze Datei: code/tag02/challenge/notes-pod-worker.yaml):

  - env:
    - name: NOTES_API_URL
      value: http://127.0.0.1:8080
    - name: NOTES_API_KEY
      value: lab-api-key-123
    - name: INTERVAL
      value: "5"
    image: localhost/notes-worker:0.1.0
    name: notes-worker
podman kube play --replace notes-pod-worker.yaml >/dev/null 2>&1
sleep 12
podman ps --pod --format '{{.Names}}\t{{.Status}}'
podman logs notes-notes-worker | tail -3

Erwartet (gekürzt):

0cb01d682f13-infra  Up 13 seconds
notes-notes-db  Up 13 seconds
notes-notes-api Up 12 seconds (healthy)
notes-notes-web Up 12 seconds
notes-notes-worker  Up 12 seconds
worker started, api=http://127.0.0.1:8080, interval=5s
summary: 1 notes, 4 words
summary: 1 notes, 4 words

"5" muss in Anführungszeichen stehen: Kubernetes-Umgebungsvariablen sind Strings. Zum Abschluss des Tages den Pod abbauen – das Volume bleibt für Tag 3:

podman kube down notes-pod-worker.yaml 2>/dev/null | tail -1
podman pod ps -q | wc -l

Erwartet:

Volumes removed:
0

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Subuid-Bereiche zentral vergeben (LDAP/SSSD oder Konfigurationsmanagement), damit sich Bereiche verschiedener User nie überschneiden.
  • Bind-Mounts mit :U ändern Besitzer auf dem Host – auf geteilten Ordnern gefährlich. Für Dienstdaten sind named Volumes oder eigene Ordner pro Dienst die bessere Wahl.
  • Für Ports 80/443 rootless lieber einen Reverse Proxy rootful oder einen Socket-aktivierten Dienst als den Sysctl für alle User zu öffnen.
  • Generiertes Kube-YAML ist ein Startpunkt, kein fertiges Manifest: Secrets statt Klartext, Ressourcen-Limits, Probes und ein Deployment statt eines nackten Pods ergänzt „Kubernetes zum Anfassen”.
  • podman kube play versteht nur einen Teil der Kubernetes-API (Pod, Deployment, PVC, ConfigMap, Secret). Was es nicht kennt, ignoriert es teils ohne Warnung.