Zum Inhalt springen
Trainingslager IT-Trainingslager

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 Docker

Danach 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 80

Tipp: Bei Colima musst du das Compose-Plugin einmalig bekannt machen. Füge in ~/.docker/config.json den 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 docker zu 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 argocd

Vault ist wegen der Lizenz (BSL) nicht mehr im Homebrew-Hauptkatalog. HashiCorp pflegt einen eigenen „Tap”:

brew tap hashicorp/tap
brew install hashicorp/tap/vault

Wer lieber die freie Abspaltung OpenBao nutzt, installiert zusätzlich:

brew install openbao

Merke: yq meint in diesem Buch immer das Go-Werkzeug von Mike Farah (Homebrew-Paket yq). Es gibt ein gleichnamiges Python-Werkzeug mit anderer Syntax. Prüfe mit yq --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/kubectl

Beispiel Trivy über das Installationsskript:

curl -sfL \
  https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh \
  | sudo sh -s -- -b /usr/local/bin

Sicherheit: curl … | sh fü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öffentlichte checksums.txt vergleichen, 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.sh

Erwartete 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 --version

Worauf 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 version muss sowohl „Client” als auch „Server” zeigen. Fehlt der Server-Teil, läuft der Docker-Daemon nicht. Starte Docker Desktop oder colima 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 ~/seclab

Erwartete 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:2

Wir 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/_catalog

Erwartete 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.toml

Erwartete 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.yaml

Die 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: true

Was die Teile bedeuten:

  • name: seclab legt den Clusternamen fest. Der Kontext heißt dann kind-seclab.
  • containerdConfigPatches ergänzt die containerd-Konfiguration im Knoten um config_path.
  • extraMounts macht 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 die hosts.toml-Dateien nachträglich per docker exec in den Knoten kopiert. Unser Weg über extraMounts ist gleichwertig, aber reproduzierbarer.

Schritt 4: Cluster erstellen

kind create cluster --name seclab --config ~/seclab/kind.yaml

Erwartete 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 nodes

Erwartete 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.toml

Erwartete 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 bridge und den veröffentlichten Port erreichst du sie vom Host. Über kind erreicht 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/_catalog

Erwartete 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)
EOF

Schritt 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
EOF

Achtung: requests==2.25.0 ist 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()
EOF

Lokal 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 -q

Erwartete 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"]
EOF

Was 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-slim per 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/
EOF

Schritt 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
EOF

Ein 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, nicht localhost:5001. Aus Sicht des Knotens wäre localhost der 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 --oneline

Erwartete 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-app

Erwartete 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 einen amd64-Server bringst. Dann hilft docker 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-test

Erwartete 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.0

Erwartete 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: crane spricht localhost automatisch ü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.0

Erwartete 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.0

Der 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,svc

Erwartete 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 nodes

Die 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 kind verbunden. Die beiden docker 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.digest

Typische 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-app dein 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 seclab und der Beispielanwendung demo-app.
  • Dieselbe Registry hat zwei Adressen: localhost:5001 vom Host und reg-build:5000 aus dem Cluster. Das Docker-Netz kind mit seinem eingebauten DNS macht die zweite Adresse möglich.
  • containerd findet Registries über hosts.toml-Dateien in /etc/containerd/certs.d. kind setzt dafür config_path per containerdConfigPatches, die Dateien kommen per extraMounts in 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: ALL und runAsNonRoot gehören von Anfang an ins Deployment.
  • Ein Tag ist ein beweglicher Zeiger, ein Digest ein fester Fingerabdruck. crane digest zeigt ihn dir, und crane copy erhält ihn beim Kopieren.
  • Mit ~/seclab/check-tools.sh und 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.