Kapitel 0: Dein Labor aufbauen
In diesem Kapitel lernst du:
- welche Bausteine dein Übungslabor hat und wie sie zusammenspielen
- wie du alle Werkzeuge für dieses Buch installierst und ihre Versionen prüfst
- wie du zwei lokale Registries als „Build-Zone” und „Ziel-Zone” betreibst
- wie du einen kind-Cluster so konfigurierst, dass er Images aus diesen Registries zieht
- wie du die Beispielanwendung baust, in die Registry schiebst und im Cluster startest
Bevor wir über sichere Lieferketten reden, brauchst du eine Werkbank. Ein Schreiner lernt sein Handwerk nicht aus dem Katalog, sondern an der Hobelbank: Werkzeug in Reichweite, Material auf dem Tisch, ein Probestück zum Üben. Genau das baust du in diesem Kapitel auf.
Das Labor ist absichtlich klein. Alles läuft auf deinem Rechner in Docker. Es gibt keine Cloud-Konten, keine Lizenzen und keine Kosten. Trotzdem bildet es die wichtigsten Teile einer echten Lieferkette nach: Quellcode, Build, Registry, Zonengrenze und ein Kubernetes-Cluster als Ziel.
Am Ende dieses Kapitels läuft die Beispielanwendung
demo-app in deinem Cluster und antwortet auf
curl. Alle späteren Kapitel bauen darauf auf. Nimm dir also
Zeit. Ein sauberes Labor spart dir später viele Stunden Fehlersuche.
Überblick über das Lab
Stell dir das Labor als kleine Firma mit zwei Gebäuden vor. Im ersten Gebäude (Build-Zone) wird gebaut. Im zweiten Gebäude (Ziel-Zone) wird produziert. Zwischen beiden liegt eine Pforte. Nur was dort geprüft wurde, darf hinüber. In Kapitel 4 bauen wir diese Pforte richtig aus. Heute legen wir nur die beiden Lager an: je eine Registry pro Zone.
Dein Rechner (macOS oder Linux, Docker)
+------------------------------------------------------------------+
| CLI-Werkzeuge: docker kind kubectl helm git jq yq cosign syft |
| grype trivy checkov semgrep gitleaks skopeo oras crane vault |
| kyverno conftest opa argocd |
| |
| ~/seclab/demo-app --docker build/push--> localhost:5001 |
| |
| Docker-Netz "kind" |
| +------------------------------------------------------------+ |
| | ZONE BUILD/INTERN | ZONE ZIEL/PRODUKTION | |
| | +-----------------------+ | +----------------------+ | |
| | | reg-build (registry:2)| | | reg-ziel (registry:2)| | |
| | | Host: localhost:5001 |---+-->| Host: localhost:5002 | | |
| | | Netz: reg-build:5000 | Übergabe | Netz: reg-ziel:5000 | | |
| | +-----------------------+ (Kap. 4) +--------------------+ | |
| | \ / | |
| | \------- pull (http) -----/ | |
| | +------------------------------------------------------+ | |
| | | kind-Cluster "seclab" (Node: seclab-control-plane) | | |
| | | containerd: certs.d/reg-build:5000 + reg-ziel:5000 | | |
| | | Namespace demo: Deployment + Service demo-app | | |
| | +------------------------------------------------------+ | |
| +------------------------------------------------------------+ |
+------------------------------------------------------------------+
Die wichtigsten Namen solltest du dir gleich merken. Sie tauchen in jedem Kapitel wieder auf:
| Baustein | Vom Host aus | Aus dem Cluster | Zweck |
|---|---|---|---|
| reg-build | localhost:5001 |
reg-build:5000 |
gebaute Images |
| reg-ziel | localhost:5002 |
reg-ziel:5000 |
freigegebene Images |
| kind-Cluster | Kontext kind-seclab |
– | Zielplattform |
| demo-app | ~/seclab/demo-app |
Namespace demo |
Beispielanwendung |
Merke: Dieselbe Registry hat zwei Adressen. Dein Rechner spricht sie über den veröffentlichten Port an (
localhost:5001). Der Cluster spricht sie über den Container-Namen im Docker-Netz an (reg-build:5000). Das Image ist dasselbe, nur der Weg dorthin unterscheidet sich.
Was du an Hardware brauchst
- Docker Desktop, Colima oder Docker Engine (Linux)
- mindestens 8 GB RAM für Docker, 16 GB empfohlen (GitLab in Kapitel 1 ist hungrig)
- etwa 40 GB freier Plattenplatz
- Internetzugang für die Installation (später simulieren wir auch Offline-Szenarien)
Werkzeuge installieren
Wir installieren alles auf einmal. So musst du später nicht mitten in einer Übung unterbrechen. Keine Sorge: Du musst noch nicht wissen, was jedes Werkzeug tut. Die Tabelle gibt dir einen ersten Eindruck.
Tipp: Was installiere ich hier eigentlich? Anhang D: Werkzeugkunde beschreibt jedes Werkzeug in ein, zwei Zeilen, zeigt typische Befehle und erklärt, wo sich Werkzeuge wie grype und trivy überschneiden. Lies ihn jetzt quer, und schlag später nach, wenn ein Werkzeug zum ersten Mal auftaucht.
| Werkzeug | Wofür | Kapitel |
|---|---|---|
| docker, kind, kubectl, helm | Container, Cluster, Pakete | alle |
| git, jq, yq, curl, openssl | Grundhandwerk | alle |
| gitlab-runner (Container), argocd | CI/CD und GitOps | 1 |
| skopeo, crane, oras | Images kopieren, prüfen | 3, 4 |
| cosign | Signieren und Verifizieren | 5 |
| vault | Secrets-Management | 6 |
| syft, grype | SBOM und Schwachstellen | 7 |
| trivy, checkov, semgrep, gitleaks | Scanner | 2, 8 |
| kyverno, conftest, opa | Policy as Code | 9 |
Container-Laufzeit auf macOS
Du hast zwei Möglichkeiten. Docker Desktop ist bequem, braucht aber in größeren Firmen eine Lizenz. Colima ist eine schlanke, freie Alternative.
Variante A, Docker Desktop:
brew install --cask docker
open -a DockerDanach in den Einstellungen unter „Resources” mindestens 8 GB RAM und 4 CPUs zuweisen.
Variante B, Colima:
brew install colima docker docker-compose docker-buildx
colima start --cpu 4 --memory 12 --disk 80Tipp: Bei Colima musst du das Compose-Plugin einmalig bekannt machen. Füge in
~/.docker/config.jsonden Eintrag"cliPluginsExtraDirs": ["/opt/homebrew/lib/docker/cli-plugins"]hinzu. Auf Intel-Macs lautet der Pfad/usr/local/lib/docker/cli-plugins.
Container-Laufzeit auf Linux
Installiere Docker Engine nach der offiziellen Anleitung für deine
Distribution (docs.docker.com, Abschnitt „Install Docker Engine”). Dort
ist das Compose-Plugin bereits enthalten. Füge danach deinen Benutzer
der Gruppe docker hinzu und melde dich neu an:
sudo usermod -aG docker "$USER"Sicherheit: Mitglied der Gruppe
dockerzu sein heißt praktisch: root auf diesem Rechner. Wer den Docker-Socket nutzen darf, kann jeden Ordner des Hosts in einen Container einhängen. Für ein Labor ist das in Ordnung. Auf Build-Servern merken wir uns diesen Punkt für Kapitel 1.
CLI-Werkzeuge mit Homebrew (macOS und Linux)
Homebrew läuft auch unter Linux. Wenn du es dort nutzt, kannst du exakt dieselben Befehle verwenden. Das ist der einfachste Weg, um auf beiden Systemen gleiche Versionen zu bekommen. Die drei Zeilen entsprechen den drei Gruppen in Anhang D: Grundhandwerk, Prüfen und Signieren, Registries und Policies.
brew install kind kubectl helm git jq yq curl openssl
brew install cosign syft grype trivy checkov semgrep gitleaks
brew install skopeo oras crane kyverno conftest opa argocdVault ist wegen der Lizenz (BSL) nicht mehr im Homebrew-Hauptkatalog. HashiCorp pflegt einen eigenen „Tap”:
brew tap hashicorp/tap
brew install hashicorp/tap/vaultWer lieber die freie Abspaltung OpenBao nutzt, installiert zusätzlich:
brew install openbaoMerke:
yqmeint in diesem Buch immer das Go-Werkzeug von Mike Farah (Homebrew-Paketyq). Es gibt ein gleichnamiges Python-Werkzeug mit anderer Syntax. Prüfe mityq --version, dass „mikefarah” in der Ausgabe steht.
CLI-Werkzeuge auf Linux ohne Homebrew
Wenn du kein Homebrew nutzen willst, nimm die offiziellen Installationswege. Paketquellen der Distributionen sind oft veraltet. Gerade bei Sicherheitswerkzeugen willst du aktuelle Versionen.
| Werkzeug | Offizieller Weg |
|---|---|
| kind | Binary von kind.sigs.k8s.io („Quick Start”) |
| kubectl | Binary von dl.k8s.io (Anleitung auf kubernetes.io) |
| helm | Skript get-helm-3 oder Paketquelle (helm.sh) |
| trivy, syft, grype | install.sh aus dem jeweiligen GitHub-Repo |
| cosign, crane, oras | Release-Binary von GitHub |
| kyverno, conftest, opa | Release-Binary von GitHub |
| argocd | Release-Binary von GitHub (argoproj/argo-cd) |
| vault | HashiCorp-Paketquelle (apt/dnf) |
| checkov, semgrep | pipx install checkov /
pipx install semgrep |
| skopeo, jq, git, openssl | Paketmanager der Distribution |
Beispiel kubectl auf Linux (amd64), so wie es die Kubernetes-Doku beschreibt:
STABLE=$(curl -L -s https://dl.k8s.io/release/stable.txt)
curl -LO "https://dl.k8s.io/release/${STABLE}/bin/linux/amd64/kubectl"
curl -LO "https://dl.k8s.io/release/${STABLE}/bin/linux/amd64/kubectl.sha256"
echo "$(cat kubectl.sha256) kubectl" | sha256sum --check
sudo install -m 0755 kubectl /usr/local/bin/kubectlBeispiel Trivy über das Installationsskript:
curl -sfL \
https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh \
| sudo sh -s -- -b /usr/local/binSicherheit:
curl … | shführt fremden Code ungeprüft aus. Das ist bequem, aber genau die Art Vertrauen, die wir in diesem Buch hinterfragen. Besser: Skript erst herunterladen, lesen, dann ausführen. Noch besser: Release-Binary laden und die Prüfsumme gegen die veröffentlichtechecksums.txtvergleichen, wie oben bei kubectl.
gitlab-runner
Den GitLab Runner installieren wir nicht auf dem Host. Er läuft in
Kapitel 1 als Container (gitlab/gitlab-runner). Du musst
jetzt nichts tun.
Versionen prüfen
Jetzt kontrollierst du, ob alles da ist. Lege dafür ein kleines Prüfskript an. Du wirst es noch öfter brauchen, etwa nach einem Betriebssystem-Update.
mkdir -p ~/seclab
cat > ~/seclab/check-tools.sh <<'EOF'
#!/usr/bin/env bash
# Prüft, ob alle Lab-Werkzeuge im PATH liegen.
set -u
tools="docker kind kubectl helm git jq yq curl openssl cosign syft grype
trivy checkov semgrep gitleaks skopeo oras crane vault kyverno conftest
opa argocd"
missing=0
for t in $tools; do
if command -v "$t" >/dev/null 2>&1; then
printf "OK %s\n" "$t"
else
printf "FEHLT %s\n" "$t"
missing=$((missing + 1))
fi
done
docker compose version >/dev/null 2>&1 \
&& echo "OK docker compose" \
|| { echo "FEHLT docker compose"; missing=$((missing + 1)); }
echo "Fehlend: $missing"
exit "$missing"
EOF
chmod +x ~/seclab/check-tools.sh
~/seclab/check-tools.shErwartete Ausgabe (gekürzt):
OK docker
OK kind
OK kubectl
...
OK argocd
OK docker compose
Fehlend: 0
Danach schaust du dir die Versionen an. Notiere sie dir. Wenn später ein Befehl anders reagiert als im Buch, ist die Version der erste Verdächtige.
docker version --format 'Docker Server: {{.Server.Version}}'
docker compose version
kind version
kubectl version --client
helm version --short
cosign version
syft version
grype version
trivy --version
checkov --version
semgrep --version
gitleaks version
skopeo --version
oras version
crane version
vault version
kyverno version
conftest --version
opa version
argocd version --client
yq --versionWorauf du achten solltest:
| Werkzeug | Erwartung |
|---|---|
| cosign | v2.x (bei v3 Hinweise in Kapitel 5 beachten) |
| kubectl | höchstens eine Minor-Version Abstand zum Cluster |
| yq | Ausgabe enthält „mikefarah” |
| docker compose | v2.x (Plugin, nicht das alte docker-compose) |
Tipp:
docker versionmuss sowohl „Client” als auch „Server” zeigen. Fehlt der Server-Teil, läuft der Docker-Daemon nicht. Starte Docker Desktop odercolima start.
Das Arbeitsverzeichnis
Alle Dateien des Buchs liegen unter ~/seclab. Jedes
Kapitel bekommt einen eigenen Unterordner. Die Beispielanwendung liegt
in ~/seclab/demo-app.
mkdir -p ~/seclab/{demo-app,containerd-certs.d,kap01,kap02,kap03,kap04,kap05}
mkdir -p ~/seclab/{kap06,kap07,kap08,kap09,kap10,kap11}
ls ~/seclabErwartete Ausgabe:
check-tools.sh containerd-certs.d demo-app kap01 kap02 kap03 kap04
kap05 kap06 kap07 kap08 kap09 kap10 kap11
Die zwei Registries
Eine Registry ist ein Lager für Container-Images. Wir nutzen das
schlanke Referenz-Image registry:2. Es hat keine
Oberfläche, keine Benutzer und kein TLS. Für Produktion ist das nichts.
Für ein Labor ist es ideal: schnell, durchschaubar und mit
Standard-Werkzeugen ansprechbar.
Schritt 1: Registries starten
docker run -d --restart=always --name reg-build \
-p 127.0.0.1:5001:5000 registry:2
docker run -d --restart=always --name reg-ziel \
-p 127.0.0.1:5002:5000 registry:2Wir binden die Ports bewusst nur an 127.0.0.1. So sind
die Registries nicht aus deinem WLAN erreichbar.
Prüfen:
docker ps --filter name=reg- --format '{{.Names}}\t{{.Ports}}'
curl -s http://localhost:5001/v2/_catalog
curl -s http://localhost:5002/v2/_catalogErwartete Ausgabe:
reg-ziel 127.0.0.1:5002->5000/tcp
reg-build 127.0.0.1:5001->5000/tcp
{"repositories":[]}
{"repositories":[]}
Warum ohne TLS?
Docker erlaubt unverschlüsselte Registries nur für
localhost ohne weitere Konfiguration. Deshalb klappt
docker push localhost:5001/... sofort. Der Cluster dagegen
spricht die Registries über ihren Container-Namen an. Dort müssen wir
containerd ausdrücklich sagen: „Für reg-build:5000 ist
http in Ordnung.” Das erledigen wir gleich in der
kind-Konfiguration.
Achtung: Unverschlüsselte Registries sind ein reines Lab-Zugeständnis. In Kapitel 3 lernst du Nexus mit sauberer Konfiguration kennen. In echten Umgebungen gehört vor jede Registry TLS mit einem Zertifikat aus deiner eigenen PKI (siehe Kapitel 5).
Der kind-Cluster
kind steht für „Kubernetes in Docker”. Jeder Kubernetes-Knoten ist
ein Docker-Container. Darin läuft containerd als Container-Laufzeit.
containerd lädt die Images für deine Pods. Also muss containerd wissen,
wie es reg-build:5000 und reg-ziel:5000
erreicht.
Wie containerd Registries findet
Seit containerd 1.5 gibt es dafür ein einfaches Verzeichnis-Schema.
In einem Ordner, meist /etc/containerd/certs.d, liegt pro
Registry ein Unterordner mit einer Datei hosts.toml. Der
Ordnername ist genau der Registry-Name aus der Image-Referenz.
/etc/containerd/certs.d/
reg-build:5000/hosts.toml -> "nutze http://reg-build:5000"
reg-ziel:5000/hosts.toml -> "nutze http://reg-ziel:5000"
Damit containerd diesen Ordner liest, muss in seiner Konfiguration
config_path gesetzt sein. Das erledigt kind über
containerdConfigPatches. Die
hosts.toml-Dateien legen wir auf dem Host an und hängen sie
per extraMounts in den Knoten ein. So ist alles deklarativ
und überlebt ein Neuanlegen des Clusters.
Schritt 2: hosts.toml-Dateien anlegen
for reg in reg-build reg-ziel; do
mkdir -p ~/seclab/containerd-certs.d/"${reg}:5000"
cat > ~/seclab/containerd-certs.d/"${reg}:5000"/hosts.toml <<EOF
server = "http://${reg}:5000"
[host."http://${reg}:5000"]
capabilities = ["pull", "resolve"]
EOF
done
cat ~/seclab/containerd-certs.d/reg-build:5000/hosts.tomlErwartete Ausgabe:
server = "http://reg-build:5000"
[host."http://reg-build:5000"]
capabilities = ["pull", "resolve"]
Die capabilities erlauben nur Lesen (pull)
und das Auflösen von Tags zu Digests (resolve). Der Cluster
soll nichts in die Registry schreiben.
Schritt 3: kind.yaml schreiben
kind versteht in hostPath keine Tilde. Wir lassen die
Shell deshalb $HOME beim Schreiben einsetzen. Achte darauf,
dass der Heredoc-Marker EOF hier nicht in
Anführungszeichen steht.
cat > ~/seclab/kind.yaml <<EOF
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: seclab
containerdConfigPatches:
- |-
[plugins."io.containerd.grpc.v1.cri".registry]
config_path = "/etc/containerd/certs.d"
nodes:
- role: control-plane
extraMounts:
- hostPath: ${HOME}/seclab/containerd-certs.d
containerPath: /etc/containerd/certs.d
readOnly: true
EOF
cat ~/seclab/kind.yamlDie fertige Datei sieht bei dir etwa so aus (dein Home-Pfad steht darin):
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: seclab
containerdConfigPatches:
- |-
[plugins."io.containerd.grpc.v1.cri".registry]
config_path = "/etc/containerd/certs.d"
nodes:
- role: control-plane
extraMounts:
- hostPath: /Users/thomas/seclab/containerd-certs.d
containerPath: /etc/containerd/certs.d
readOnly: trueWas die Teile bedeuten:
name: seclablegt den Clusternamen fest. Der Kontext heißt dannkind-seclab.containerdConfigPatchesergänzt die containerd-Konfiguration im Knoten umconfig_path.extraMountsmacht deinen Host-Ordner im Knoten sichtbar.- Ein einzelner Knoten reicht. Er spart RAM, den GitLab in Kapitel 1 braucht.
Merke: Die offizielle kind-Doku („Local Registry”) zeigt dasselbe Prinzip mit
config_path. Dort werden diehosts.toml-Dateien nachträglich perdocker execin den Knoten kopiert. Unser Weg überextraMountsist gleichwertig, aber reproduzierbarer.
Schritt 4: Cluster erstellen
kind create cluster --name seclab --config ~/seclab/kind.yamlErwartete Ausgabe (gekürzt):
Creating cluster "seclab" ...
✓ Ensuring node image (kindest/node:v1.xx.x)
✓ Preparing nodes
✓ Writing configuration
✓ Starting control-plane
✓ Installing CNI
✓ Installing StorageClass
Set kubectl context to "kind-seclab"
Die Häkchen stammen von kind selbst. Prüfe den Cluster:
kubectl cluster-info --context kind-seclab
kubectl get nodesErwartete Ausgabe:
Kubernetes control plane is running at https://127.0.0.1:xxxxx
...
NAME STATUS ROLES AGE VERSION
seclab-control-plane Ready control-plane 1m v1.xx.x
Prüfe außerdem, dass die Registry-Konfiguration im Knoten angekommen ist:
docker exec seclab-control-plane ls /etc/containerd/certs.d
docker exec seclab-control-plane grep config_path /etc/containerd/config.tomlErwartete Ausgabe:
reg-build:5000
reg-ziel:5000
config_path = "/etc/containerd/certs.d"
Das Docker-Netz kind
Beim Erstellen des Clusters hat kind ein Docker-Netz namens
kind angelegt. Der Knoten seclab-control-plane
hängt darin. Docker betreibt in solchen benutzerdefinierten Netzen einen
eingebauten DNS-Dienst. Container im selben Netz finden sich gegenseitig
über ihren Namen.
Unsere Registries hängen aber noch im Standardnetz
bridge. Der Knoten kann sie also nicht finden. Das ändern
wir.
Schritt 5: Registries ins Netz kind hängen
docker network connect kind reg-build
docker network connect kind reg-ziel
docker network inspect kind \
--format '{{range .Containers}}{{.Name}} {{end}}'Erwartete Ausgabe (Reihenfolge kann abweichen):
seclab-control-plane reg-build reg-ziel
Meldet Docker
endpoint with name reg-build already exists in network kind,
hängt der Container schon im Netz. Das ist kein Fehler.
Merke: Die Registries hängen jetzt in zwei Netzen. Über
bridgeund den veröffentlichten Port erreichst du sie vom Host. Überkinderreicht sie der Cluster-Knoten. In Kapitel 1 hängen wir auch GitLab und die CI-Jobs in dieses Netz.
Kurzer Verbindungstest aus dem Knoten heraus:
docker exec seclab-control-plane \
curl -s http://reg-build:5000/v2/_catalogErwartete Ausgabe:
{"repositories":[]}
Die Beispielanwendung
Jetzt brauchst du etwas, das durch die Lieferkette wandert. Die
demo-app ist eine winzige Python-Webanwendung mit Flask.
Sie ist absichtlich einfach. Der Inhalt ist nicht das Thema, sondern der
Weg vom Quellcode bis in den Cluster.
Die Struktur am Ende:
~/seclab/demo-app/
app.py
requirements.txt
requirements-dev.txt
tests/test_app.py
Dockerfile
.dockerignore
.gitignore
k8s/deployment.yaml
k8s/service.yaml
Schritt 6: app.py
cd ~/seclab/demo-app
cat > app.py <<'EOF'
"""Minimale Demo-Anwendung für das Lieferketten-Labor."""
import os
from flask import Flask, jsonify
app = Flask(__name__)
APP_VERSION = os.environ.get("APP_VERSION", "1.0.0")
@app.get("/")
def index():
"""Einfacher Lebenszeichen-Endpunkt."""
return jsonify(status="ok")
@app.get("/version")
def version():
"""Gibt die ausgelieferte Version zurück."""
return jsonify(version=APP_VERSION)
if __name__ == "__main__":
# Nur für lokale Tests. Im Container startet gunicorn die App.
app.run(host="127.0.0.1", port=8000)
EOFSchritt 7: Abhängigkeiten
cat > requirements.txt <<'EOF'
flask==3.0.3
gunicorn==22.0.0
# Absichtlich veraltet: bekannte Schwachstellen für die Scan-Übungen
# in Kapitel 7 und 8. Die App benutzt requests nicht.
requests==2.25.0
EOF
cat > requirements-dev.txt <<'EOF'
pytest==8.3.3
EOFAchtung:
requests==2.25.0ist bewusst eine Version mit bekannten Schwachstellen (CVEs). Sie ist unser Übungsobjekt für SBOM, Scanner und Schwellenwerte. Übernimm diese Zeile nie in ein echtes Projekt.
Alle Versionen sind fest gepinnt (==). Das ist der erste
kleine Baustein einer sicheren Lieferkette: Der Build von heute und der
Build von morgen sollen dieselben Pakete verwenden.
Schritt 8: Ein Test
Kapitel 1 lässt diesen Test in der Pipeline laufen.
mkdir -p tests
cat > tests/test_app.py <<'EOF'
from app import app
def test_index_returns_ok():
client = app.test_client()
resp = client.get("/")
assert resp.status_code == 200
assert resp.get_json() == {"status": "ok"}
def test_version_has_value():
client = app.test_client()
resp = client.get("/version")
assert resp.status_code == 200
assert "version" in resp.get_json()
EOFLokal ausführen ist optional, aber ein guter Schnelltest:
python3 -m venv .venv
.venv/bin/pip install -q -r requirements.txt -r requirements-dev.txt
.venv/bin/python -m pytest -qErwartete Ausgabe:
.. [100%]
2 passed in 0.05s
Schritt 9: Dockerfile
Das Dockerfile hat zwei Stufen (multi-stage). Die erste Stufe installiert die Pakete in eine virtuelle Umgebung. Die zweite Stufe übernimmt nur das Ergebnis. Werkzeuge, die nur zum Bauen nötig sind, landen so nicht im fertigen Image. Außerdem läuft die App nicht als root, sondern als Benutzer mit der UID 10001.
cat > Dockerfile <<'EOF'
# ---- Stufe 1: Abhängigkeiten installieren ----
FROM python:3.12-slim AS build
WORKDIR /app
COPY requirements.txt .
RUN python -m venv /opt/venv \
&& /opt/venv/bin/pip install --no-cache-dir -r requirements.txt
# ---- Stufe 2: schlankes Laufzeit-Image ----
FROM python:3.12-slim
ENV PATH="/opt/venv/bin:$PATH" \
PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid 10001 --no-create-home app
WORKDIR /app
COPY --from=build /opt/venv /opt/venv
COPY app.py .
USER 10001:10001
EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "2", "app:app"]
EOFWas die wichtigsten Zeilen tun:
| Zeile | Wirkung |
|---|---|
FROM ... AS build |
benannte Bau-Stufe |
COPY --from=build |
nur die fertige venv übernehmen |
USER 10001:10001 |
Prozess läuft ohne root |
PYTHONDONTWRITEBYTECODE=1 |
keine .pyc-Dateien, passt zu read-only |
Tipp: Wir verwenden hier noch
python:3.12-slimper Tag. Ein Tag ist ein beweglicher Zeiger. In Kapitel 2 lernst du, Basis-Images per Digest festzunageln, und in Kapitel 3 kommen sie nur noch aus deinem Spiegel.
Dazu eine .dockerignore, damit keine lokalen Reste ins
Image wandern, und eine .gitignore:
cat > .dockerignore <<'EOF'
.git
.venv
__pycache__
*.pyc
tests
k8s
EOF
cat > .gitignore <<'EOF'
.venv/
__pycache__/
*.pyc
.pytest_cache/
EOFSchritt 10: Kubernetes-Manifeste
mkdir -p k8s
cat > k8s/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: demo-app
namespace: demo
labels:
app: demo-app
spec:
replicas: 1
selector:
matchLabels:
app: demo-app
template:
metadata:
labels:
app: demo-app
spec:
automountServiceAccountToken: false
securityContext:
runAsNonRoot: true
runAsUser: 10001
runAsGroup: 10001
seccompProfile:
type: RuntimeDefault
containers:
- name: demo-app
image: reg-build:5000/demo-app:1.0.0
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8000
name: http
env:
- name: APP_VERSION
value: "1.0.0"
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
capabilities:
drop: ["ALL"]
resources:
requests:
cpu: 50m
memory: 64Mi
limits:
memory: 256Mi
readinessProbe:
httpGet:
path: /
port: http
initialDelaySeconds: 3
periodSeconds: 10
livenessProbe:
httpGet:
path: /
port: http
initialDelaySeconds: 10
periodSeconds: 20
volumeMounts:
- name: tmp
mountPath: /tmp
volumes:
- name: tmp
emptyDir: {}
EOF
cat > k8s/service.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata:
name: demo-app
namespace: demo
labels:
app: demo-app
spec:
type: ClusterIP
selector:
app: demo-app
ports:
- name: http
port: 80
targetPort: http
EOFEin paar Details verdienen eine Erklärung:
- readOnlyRootFilesystem: Der Container darf sein Dateisystem nicht verändern. Ein Angreifer kann so kein Werkzeug nachladen und ablegen.
- emptyDir unter /tmp: gunicorn braucht ein beschreibbares Temp-Verzeichnis für seine Worker. Ohne diesen Mount startet der Pod mit einem Fehler.
- capabilities drop ALL: Der Prozess bekommt keine Linux-Sonderrechte.
- automountServiceAccountToken: false: Die App braucht keinen Zugriff auf die Kubernetes-API, also bekommt sie auch kein Token.
- image: Hier steht die Cluster-Adresse
reg-build:5000, nichtlocalhost:5001. Aus Sicht des Knotens wärelocalhostder Knoten selbst.
Merke: Diese Sicherheitseinstellungen sind keine Kür. In Kapitel 9 schreibst du Kyverno-Regeln, die genau diese Felder erzwingen. Die demo-app besteht diese Regeln dann von Anfang an.
Schritt 11: Git-Repository anlegen
Kapitel 1 schiebt die App in GitLab. Lege das Repository schon jetzt an:
cd ~/seclab/demo-app
git init -b main
git add .
git commit -m "demo-app: erste Version 1.0.0"
git log --onelineErwartete Ausgabe:
a1b2c3d demo-app: erste Version 1.0.0
Die .venv taucht dank .gitignore nicht im
Commit auf. Prüfe das mit git status --ignored.
Image bauen und pushen
Schritt 12: Bauen
cd ~/seclab/demo-app
docker build -t localhost:5001/demo-app:1.0.0 .
docker image ls localhost:5001/demo-appErwartete Ausgabe (Größe schwankt):
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost:5001/demo-app 1.0.0 3f2c... 10 seconds ago ~150MB
Tipp: Auf einem Mac mit Apple-Chip baut Docker ein
arm64-Image. Der kind-Knoten läuft auf derselben Architektur, also passt das. Probleme gibt es erst, wenn du das Image auf einenamd64-Server bringst. Dann hilftdocker buildx build --platform linux/amd64.
Schritt 13: Lokal ausprobieren
Bevor das Image in den Cluster geht, ein kurzer Test direkt mit Docker:
docker run --rm -d --name demo-test -p 127.0.0.1:8000:8000 \
localhost:5001/demo-app:1.0.0
sleep 2
curl -s http://localhost:8000/
curl -s http://localhost:8000/version
docker exec demo-test id
docker stop demo-testErwartete Ausgabe:
{"status":"ok"}
{"version":"1.0.0"}
uid=10001(app) gid=10001(app) groups=10001(app)
demo-test
Die Zeile mit uid=10001 beweist: Der Prozess läuft nicht
als root.
Schritt 14: Pushen und Digest ermitteln
docker push localhost:5001/demo-app:1.0.0
curl -s http://localhost:5001/v2/_catalog
crane ls localhost:5001/demo-app
crane digest localhost:5001/demo-app:1.0.0Erwartete Ausgabe:
The push refers to repository [localhost:5001/demo-app]
...
1.0.0: digest: sha256:9c1e... size: 1789
{"repositories":["demo-app"]}
1.0.0
sha256:9c1e...
Der Digest ist der Fingerabdruck des Images. Ein Tag wie
1.0.0 kann morgen auf ein anderes Image zeigen. Der Digest
nicht. Ab Kapitel 4 arbeiten wir deshalb fast nur noch mit
image@sha256:….
Merke:
cranesprichtlocalhostautomatisch über http an. Bei anderen Registry-Namen bräuchtest du--insecure. Das ist eine Eigenheit der Bibliothek go-containerregistry, auf der crane aufbaut.
Schritt 15: Pull aus dem Cluster testen
Jetzt der entscheidende Test: Findet containerd im Knoten das Image unter seinem Cluster-Namen?
docker exec seclab-control-plane \
crictl pull reg-build:5000/demo-app:1.0.0Erwartete Ausgabe:
Image is up to date for sha256:4e7a...
Die Zahl hinter sha256: ist hier die Image-ID, nicht der
Manifest-Digest. Beides sind Hashes, aber über verschiedene Dinge. Das
ist normal.
Teste gleich auch die Ziel-Registry. Wir kopieren das Image mit
crane copy hinüber. Das ist ein Vorgeschmack auf die
Übergabe in Kapitel 4.
crane copy localhost:5001/demo-app:1.0.0 localhost:5002/demo-app:1.0.0
crane digest localhost:5002/demo-app:1.0.0
docker exec seclab-control-plane \
crictl pull reg-ziel:5000/demo-app:1.0.0Der Digest in reg-ziel ist identisch mit dem in reg-build.
crane copy kopiert Byte für Byte. Das ist wichtig: Eine
Signatur, die auf den Digest zeigt, bleibt so über die Zonengrenze
hinweg gültig.
Im Cluster deployen und testen
Schritt 16: Namespace und Manifeste anwenden
kubectl create namespace demo
kubectl apply -f ~/seclab/demo-app/k8s/
kubectl -n demo rollout status deployment/demo-app --timeout=120s
kubectl -n demo get pods,svcErwartete Ausgabe:
namespace/demo created
deployment.apps/demo-app created
service/demo-app created
deployment "demo-app" successfully rolled out
NAME READY STATUS RESTARTS AGE
pod/demo-app-6d9f8b7c5d-x2k4q 1/1 Running 0 20s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/demo-app ClusterIP 10.96.123.45 <none> 80/TCP 20s
Schritt 17: Mit port-forward und curl testen
Der Service hat keine externe Adresse. Für Tests leitest du einen lokalen Port an ihn weiter. Der Befehl blockiert das Terminal, deshalb läuft er im Hintergrund.
kubectl -n demo port-forward svc/demo-app 8000:80 >/dev/null 2>&1 &
PF_PID=$!
sleep 2
curl -s http://localhost:8000/
curl -s http://localhost:8000/version
kill "$PF_PID"Erwartete Ausgabe:
{"status":"ok"}
{"version":"1.0.0"}
Herzlichen Glückwunsch: Die Lieferkette funktioniert einmal von Anfang bis Ende. Quellcode, Build, Registry, Cluster. Noch ist sie völlig ungeschützt. Das ändern wir Kapitel für Kapitel.
Woher kam das Image wirklich? Das zeigt dir der Pod:
kubectl -n demo get pod -l app=demo-app \
-o jsonpath='{.items[0].status.containerStatuses[0].imageID}{"\n"}'Erwartete Ausgabe:
reg-build:5000/demo-app@sha256:9c1e...
Das ist derselbe Digest, den crane digest gemeldet
hat.
Das Labor pausieren und wieder starten
Das Labor muss nicht ständig laufen. So sparst du RAM und Akku:
# Pausieren
docker stop seclab-control-plane
# Wieder starten
docker start seclab-control-plane
kubectl get nodesDie Registries starten wegen --restart=always mit Docker
automatisch. Wenn der Cluster nach einem Neustart nicht sauber
hochkommt, löschst du ihn und legst ihn neu an. Dank
kind.yaml dauert das nur eine Minute:
kind delete cluster --name seclab
kind create cluster --name seclab --config ~/seclab/kind.yaml
docker network connect kind reg-build
docker network connect kind reg-ziel
kubectl create namespace demo
kubectl apply -f ~/seclab/demo-app/k8s/Tipp: Meist bleiben die Registries mit dem Netz
kindverbunden. Die beidendocker network connect-Befehle stehen trotzdem in der Liste, denn sie schaden nicht: Ist die Verbindung schon da, meldet Docker nur „already exists”. Die Images in den Registries bleiben in jedem Fall erhalten.
Prüfe dein Lab
Hake jeden Punkt ab, bevor du zu Kapitel 1 gehst. Jede Zeile hat einen Prüfbefehl.
| Prüfung | Befehl | Erwartung |
|---|---|---|
| Werkzeuge vollständig | ~/seclab/check-tools.sh |
Fehlend: 0 |
| Registries laufen | docker ps --filter name=reg- |
zwei Container |
| Image in reg-build | crane ls localhost:5001/demo-app |
1.0.0 |
| Kontext stimmt | kubectl config current-context |
kind-seclab |
| Knoten bereit | kubectl get nodes |
Ready |
| Netz verbunden | docker network inspect kind |
reg-build, reg-ziel |
| Cluster-Pull klappt | crictl pull im Knoten |
Image is up to date |
| App läuft | kubectl -n demo get pods |
1/1 Running |
| App antwortet | port-forward + curl |
{"status":"ok"} |
| Git-Repo existiert | git -C ~/seclab/demo-app log |
ein Commit |
Wenn alles grün ist, kannst du diesen Zustand als Referenz festhalten:
crane digest localhost:5001/demo-app:1.0.0 > ~/seclab/demo-app-1.0.0.digest
cat ~/seclab/demo-app-1.0.0.digestTypische Stolperfallen
| Symptom | Ursache | Lösung |
|---|---|---|
Cannot connect to the Docker daemon |
Docker läuft nicht | Docker Desktop bzw. colima start |
port is already allocated beim Start |
anderer Dienst nutzt 5001/5002 | Belegung mit lsof -i :5001 prüfen |
Pod ErrImagePull, „http: server gave HTTP response to
HTTPS client” |
hosts.toml fehlt oder config_path nicht
gesetzt |
Schritte 2–4 prüfen, Cluster neu anlegen |
Pod ErrImagePull, „no such host” |
Registry nicht im Netz kind |
docker network connect kind reg-build |
Pod ErrImagePull, „not found” |
Image nicht gepusht oder Tippfehler | crane ls localhost:5001/demo-app |
kind create meldet Mount-Fehler |
hostPath enthält ~ oder Ordner fehlt |
kind.yaml mit $HOME neu erzeugen |
Pod CrashLoopBackOff, gunicorn-Fehler zu tmp |
/tmp nicht beschreibbar |
emptyDir unter /tmp mounten |
Pod CreateContainerConfigError |
runAsNonRoot und Image ohne numerischen User |
USER 10001:10001 numerisch setzen |
curl auf Port 8000 hängt |
port-forward nicht aktiv | Prozess mit jobs prüfen, neu starten |
yq-Befehle schlagen fehl |
Python-yq installiert |
Go-Variante (mikefarah) installieren |
Pull auf amd64-Server: „exec format error” |
Image für arm64 gebaut |
mit --platform linux/amd64 bauen |
Tipp: Bei Pull-Fehlern ist
kubectl -n demo describe pod -l app=demo-appdein bester Freund. Ganz unten unter „Events” steht die genaue Fehlermeldung von containerd.
Zusammenfassung
Das hast du gelernt:
- Dein Labor besteht aus zwei Registries (reg-build auf Port 5001,
reg-ziel auf Port 5002), einem kind-Cluster
seclabund der Beispielanwendungdemo-app. - Dieselbe Registry hat zwei Adressen:
localhost:5001vom Host undreg-build:5000aus dem Cluster. Das Docker-Netzkindmit seinem eingebauten DNS macht die zweite Adresse möglich. - containerd findet Registries über
hosts.toml-Dateien in/etc/containerd/certs.d. kind setzt dafürconfig_pathpercontainerdConfigPatches, die Dateien kommen perextraMountsin den Knoten. - Ein multi-stage Dockerfile mit festem, nicht privilegiertem Benutzer (UID 10001) ist die Grundlage für ein schlankes, sicheres Image.
- Sicherheitseinstellungen wie
readOnlyRootFilesystem,drop: ALLundrunAsNonRootgehören von Anfang an ins Deployment. - Ein Tag ist ein beweglicher Zeiger, ein Digest ein fester
Fingerabdruck.
crane digestzeigt ihn dir, undcrane copyerhält ihn beim Kopieren. - Mit
~/seclab/check-tools.shund der Checkliste kannst du jederzeit prüfen, ob dein Labor intakt ist.
Im nächsten Kapitel ersetzt du den Handbetrieb durch eine echte CI/CD-Kette: GitLab baut das Image, Argo CD bringt es in den Cluster.