Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: Plattform-Basis

Ziel: Der RKE2-Cluster vergibt LoadBalancer-IPs, terminiert TLS mit der Lab-CA am Traefik-Ingress, stellt Longhorn- und local-path-Volumes bereit und wird von Prometheus/Grafana überwacht. · Dauer: ca. 120 min · Voraussetzung: Tag 8

Briefing

  • Cilium LB-IPAM vergibt aus 10.10.20.100–120, L2-Announcements beantworten ARP für diese IPs. Kein MetalLB.
  • Ingress: Traefik (RKE2-Default seit v1.36, IngressClass traefik). Er bekommt per HelmChartConfig eine feste LB-IP 10.10.20.100, auf die *.lab.internal zeigt.
  • cert-manager mit eigener Root-CA: ClusterIssuer lab-ca stellt alle Lab-Zertifikate aus.
  • Storage: longhorn (Default, 2 Replicas) für Datenbanken und Prometheus, local-path nur auf rke2-gpu-1 für den Modell-Cache (Tag 11).
  • kube-prometheus-stack minimal im Namespace monitoring, Grafana unter grafana.lab.internal.
Laptop ── https://grafana.lab.internal ──> 10.10.20.100 (L2/ARP, Cilium)
   └─ Service rke2-traefik (LoadBalancer)
        └─ Traefik-Pods auf wk-1 / wk-2 / gpu-1
             └─ Service grafana.monitoring   (TLS-Zertifikat von lab-ca)

Drill 1: LoadBalancer-Pool und L2-Announcements

export KUBECONFIG=~/ki-lab/rke2.yaml
mkdir -p ~/ki-lab/code/infra-rke2/platform && cd ~/ki-lab/code/infra-rke2/platform
cat > cilium-lb.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumLoadBalancerIPPool
metadata:
  name: lab-pool
spec:
  blocks:
    - start: "10.10.20.100"
      stop: "10.10.20.120"
---
apiVersion: cilium.io/v2alpha1
kind: CiliumL2AnnouncementPolicy
metadata:
  name: lab-l2
spec:
  nodeSelector:
    matchExpressions:
      - key: node-role.kubernetes.io/control-plane
        operator: DoesNotExist
  interfaces:
    - ^eth[0-9]+
  externalIPs: true
  loadBalancerIPs: true
EOF
kubectl apply -f cilium-lb.yaml
kubectl get ciliumloadbalancerippools

Erwartet (gekürzt, nicht live getestet):

ciliumloadbalancerippool.cilium.io/lab-pool created
ciliuml2announcementpolicy.cilium.io/lab-l2 created
NAME       DISABLED   CONFLICTING   IPS AVAILABLE   AGE
lab-pool   false      False         21              3s

Warum nur Agents im nodeSelector? Die Server tragen CriticalAddonsOnly und haben keine Traefik-Pods. Ein Agent als ARP-Sprecher hält den Weg kurz. Fällt er aus, übernimmt ein anderer den Lease.

Kurzer Test mit einem Wegwerf-Service:

kubectl create deployment lbtest --image=traefik/whoami:v1.12
kubectl expose deployment lbtest --port=80 --type=LoadBalancer
kubectl get svc lbtest -o jsonpath='{.status.loadBalancer.ingress[0].ip}{"\n"}'
kubectl -n kube-system get lease | grep cilium-l2announce
curl -s http://10.10.20.101 | grep -E '^Hostname'
kubectl delete deployment,svc lbtest

Erwartet (gekürzt, nicht live getestet):

10.10.20.101
cilium-l2announce-default-lbtest   rke2-wk-1   12s
Hostname: lbtest-6b8f9c7d5-x2kqp

.100 ist reserviert, weil Traefik sie gleich per Annotation anfordert. Bleibt die IP <pending>, prüfe kubectl -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg config | grep -i l2 – EnableL2Announcements muss true sein (Tag 8, HelmChartConfig).

Tipp: Für Tests ohne Annotation vergibt LB-IPAM die erste freie IP. Wird .100 von lbtest belegt, bevor Traefik kommt, gib sie mit kubectl delete svc lbtest wieder frei.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Traefik als LoadBalancer

Der RKE2-Traefik läuft als DaemonSet mit hostPort 80/443 und Service-Typ ClusterIP. Du überschreibst nur Service-Typ, LB-IP und Default-Class:

cat > rke2-traefik-config.yaml <<'EOF'
apiVersion: helm.cattle.io/v1
kind: HelmChartConfig
metadata:
  name: rke2-traefik
  namespace: kube-system
spec:
  valuesContent: |-
    ingressClass:
      isDefaultClass: true
    service:
      spec:
        type: LoadBalancer
      annotations:
        lbipam.cilium.io/ips: "10.10.20.100"
EOF
kubectl apply -f rke2-traefik-config.yaml
kubectl -n kube-system get svc rke2-traefik -w   # Strg+C, sobald EXTERNAL-IP da ist

Erwartet (gekürzt, nicht live getestet):

NAME           TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)
rke2-traefik   LoadBalancer   10.43.112.47   10.10.20.100   80:31080/TCP,443:31443/TCP

Den helm-controller interessiert nur die HelmChartConfig: er rendert das Chart rke2-traefik mit deinen Werten neu. Dieselbe Datei kannst du alternativ nach /var/lib/rancher/rke2/server/manifests/ auf die Server legen.

DNS: Lege im Router/DNS-Server einen Wildcard-Eintrag *.lab.internal → 10.10.20.100 an. Für den Anfang reicht /etc/hosts auf dem Laptop:

for h in grafana llm chat code; do
  grep -q "$h.lab.internal" /etc/hosts || \
    echo "10.10.20.100 $h.lab.internal" | sudo tee -a /etc/hosts
done
curl -s -o /dev/null -w '%{http_code}\n' http://grafana.lab.internal

Erwartet:

404

404 von Traefik ist hier gut: Die IP antwortet, es gibt nur noch keine Route.

Fortschritt speichern? Kostenlos registrieren

Drill 3: cert-manager und Lab-CA

helm repo add jetstack https://charts.jetstack.io && helm repo update jetstack
cat > cert-manager-values.yaml <<'EOF'
crds:
  enabled: true
replicaCount: 1
prometheus:
  servicemonitor:
    enabled: false   # nach kube-prometheus-stack auf true setzen
EOF
helm upgrade --install cert-manager jetstack/cert-manager --version v1.21.2 \
  -n cert-manager --create-namespace -f cert-manager-values.yaml --wait
cat > lab-ca.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: selfsigned
spec:
  selfSigned: {}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: lab-ca
  namespace: cert-manager
spec:
  isCA: true
  commonName: KI-Lab Root CA
  secretName: lab-ca-keypair
  duration: 87600h      # 10 Jahre, nur Lab
  privateKey:
    algorithm: ECDSA
    size: 256
  issuerRef:
    kind: ClusterIssuer
    name: selfsigned
---
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: lab-ca
spec:
  ca:
    secretName: lab-ca-keypair
EOF
kubectl apply -f lab-ca.yaml
kubectl get clusterissuer

Erwartet (gekürzt, nicht live getestet):

clusterissuer.cert-manager.io/selfsigned created
certificate.cert-manager.io/lab-ca created
clusterissuer.cert-manager.io/lab-ca created
NAME         READY   AGE
lab-ca       True    8s
selfsigned   True    8s

Drei Schritte: selfsigned signiert genau ein Zertifikat – die Root-CA lab-ca (Secret lab-ca-keypair). Der ClusterIssuer lab-ca signiert damit alle weiteren. Ingresses brauchen nur noch die Annotation cert-manager.io/cluster-issuer: lab-ca.

Die CA dem Laptop bekannt machen (macOS):

kubectl -n cert-manager get secret lab-ca-keypair \
  -o jsonpath='{.data.ca\.crt}' | base64 -d > ~/ki-lab/lab-ca.crt
openssl x509 -in ~/ki-lab/lab-ca.crt -noout -subject -enddate
sudo security add-trusted-cert -d -r trustRoot \
  -k /Library/Keychains/System.keychain ~/ki-lab/lab-ca.crt

Erwartet (Datum abweichend):

subject=CN=KI-Lab Root CA
notAfter=Oct  7 18:30:12 2036 GMT

Sicherheit: Der private Schlüssel der Lab-CA liegt als Secret im Cluster. Wer cert-manager-Secrets lesen darf, kann für jede Domain Zertifikate ausstellen, denen dein Laptop vertraut. Nur im Lab, und die CA bei Bedarf wieder aus dem Schlüsselbund entfernen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Longhorn

Longhorn braucht open-iscsi auf jedem Node – das hat cloud-init an Tag 7 installiert.

helm repo add longhorn https://charts.longhorn.io && helm repo update longhorn
cat > longhorn-values.yaml <<'EOF'
persistence:
  defaultClass: true
  defaultClassReplicaCount: 2   # nur 3 Agents im Lab
preUpgradeChecker:
  jobEnabled: true
defaultSettings:
  # GPU-Node bekommt in Tag 10 den Taint nvidia.com/gpu – Longhorn soll dort bleiben
  taintToleration: "nvidia.com/gpu:NoSchedule"
EOF
helm upgrade --install longhorn longhorn/longhorn --version 1.13.0 \
  -n longhorn-system --create-namespace -f longhorn-values.yaml
kubectl -n longhorn-system rollout status ds/longhorn-manager --timeout=10m
kubectl get storageclass

Erwartet (gekürzt, nicht live getestet):

daemon set "longhorn-manager" successfully rolled out
NAME                 PROVISIONER          RECLAIMPOLICY   VOLUMEBINDINGMODE
longhorn (default)   driver.longhorn.io   Delete          Immediate

Warum 2 Replicas? Longhorn-Pods laufen nur auf den drei Agents (Server-Taint). Mit 3 Replicas wäre jeder Node-Ausfall sofort „degraded“, 2 lässt Platz zum Umverteilen.

Die UI erreichst du ohne Ingress (sie hat keine Anmeldung):

kubectl -n longhorn-system port-forward svc/longhorn-frontend 8080:80

Fortschritt speichern? Kostenlos registrieren

Drill 5: local-path für den Modell-Cache auf rke2-gpu-1

Modelle (10–50 GB) über Longhorn zu replizieren kostet Netz und Platz, und ein vLLM-Pod läuft ohnehin nur auf dem GPU-Node. Also lokale Disk, und zwar nur dort. RKE2 bringt anders als k3s keinen local-path-Provisioner mit.

kubectl apply -f https://raw.githubusercontent.com/rancher/local-path-provisioner/\
v0.0.37/deploy/local-path-storage.yaml
cat > local-path-config.yaml <<'EOF'
# Überschreibt die ConfigMap aus local-path-storage.yaml (v0.0.37):
# Volumes nur auf rke2-gpu-1, alle anderen Nodes lehnen ab.
apiVersion: v1
kind: ConfigMap
metadata:
  name: local-path-config
  namespace: local-path-storage
data:
  config.json: |-
    {
      "nodePathMap": [
        {"node": "DEFAULT_PATH_FOR_NON_LISTED_NODES", "paths": []},
        {"node": "rke2-gpu-1", "paths": ["/var/lib/ki-models"]}
      ]
    }
  setup: |-
    #!/bin/sh
    set -eu
    mkdir -m 0777 -p "$VOL_DIR"
  teardown: |-
    #!/bin/sh
    set -eu
    rm -rf "$VOL_DIR"
  helperPod.yaml: |-
    apiVersion: v1
    kind: Pod
    metadata:
      name: helper-pod
    spec:
      priorityClassName: system-node-critical
      tolerations:
        - key: node.kubernetes.io/disk-pressure
          operator: Exists
          effect: NoSchedule
      containers:
        - name: helper-pod
          image: busybox
          imagePullPolicy: IfNotPresent
EOF
kubectl apply -f local-path-config.yaml
kubectl -n local-path-storage rollout restart deploy/local-path-provisioner
kubectl get storageclass local-path

Erwartet (gekürzt, nicht live getestet):

configmap/local-path-config configured
deployment.apps/local-path-provisioner restarted
NAME         PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE
local-path   rancher.io/local-path   Delete          WaitForFirstConsumer

"paths": [] für alle anderen Nodes heißt laut Doku: Provisionierung wird dort verweigert. Ein Pod mit local-path-PVC auf rke2-wk-1 bleibt also Pending statt still Daten auf dem falschen Node abzulegen. WaitForFirstConsumer legt das Volume erst an, wenn der Pod geplant ist.

Test (der Pod wird per nodeSelector auf den GPU-Node gezwungen):

cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata: {name: lp-test, namespace: default}
spec:
  storageClassName: local-path
  accessModes: ["ReadWriteOnce"]
  resources: {requests: {storage: 1Gi}}
---
apiVersion: v1
kind: Pod
metadata: {name: lp-test, namespace: default}
spec:
  nodeSelector: {kubernetes.io/hostname: rke2-gpu-1}
  containers:
    - name: c
      image: busybox:1.37
      command: ["sh", "-c", "echo ok > /data/f && sleep 3600"]
      volumeMounts: [{name: d, mountPath: /data}]
  volumes: [{name: d, persistentVolumeClaim: {claimName: lp-test}}]
EOF
kubectl wait pod/lp-test --for=condition=Ready --timeout=120s
ssh [email protected] 'sudo find /var/lib/ki-models -name f'
kubectl delete pod/lp-test pvc/lp-test

Erwartet (gekürzt, nicht live getestet):

pod/lp-test condition met
/var/lib/ki-models/pvc-3c1e..._default_lp-test/f

Fortschritt speichern? Kostenlos registrieren

Drill 6: kube-prometheus-stack minimal

helm repo add prometheus-community \
  https://prometheus-community.github.io/helm-charts
helm repo update prometheus-community
cat > kps-values.yaml <<'EOF'
# kube-prometheus-stack, minimal für das Lab
grafana:
  adminPassword: lab-grafana-1234     # Lab-Wert!
  ingress:
    enabled: true
    ingressClassName: traefik
    hosts: ["grafana.lab.internal"]
    annotations:
      cert-manager.io/cluster-issuer: lab-ca
    tls:
      - secretName: grafana-tls
        hosts: ["grafana.lab.internal"]
prometheus:
  prometheusSpec:
    retention: 7d
    # ServiceMonitors aller Namespaces einsammeln (vLLM, LiteLLM, DCGM ...)
    serviceMonitorSelectorNilUsesHelmValues: false
    podMonitorSelectorNilUsesHelmValues: false
    ruleSelectorNilUsesHelmValues: false
    storageSpec:
      volumeClaimTemplate:
        spec:
          storageClassName: longhorn
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 20Gi
alertmanager:
  alertmanagerSpec:
    replicas: 1
# RKE2 bindet diese Komponenten an 127.0.0.1 bzw. kube-proxy fehlt (Cilium)
kubeProxy:
  enabled: false
kubeEtcd:
  enabled: false
kubeControllerManager:
  enabled: false
kubeScheduler:
  enabled: false
EOF
helm upgrade --install kube-prometheus-stack \
  prometheus-community/kube-prometheus-stack --version 92.2.0 \
  -n monitoring --create-namespace -f kps-values.yaml
kubectl -n monitoring get pods
kubectl -n monitoring get certificate grafana-tls

Erwartet (gekürzt, nicht live getestet):

NAME                                                     READY   STATUS
alertmanager-kube-prometheus-stack-alertmanager-0        2/2     Running
kube-prometheus-stack-grafana-7d9c8b6f5-k2x7p            3/3     Running
kube-prometheus-stack-kube-state-metrics-5b8c7d9f-q4m2   1/1     Running
kube-prometheus-stack-operator-6f7b9c8d4-z8n1v           1/1     Running
kube-prometheus-stack-prometheus-node-exporter-xxxxx     1/1     Running
prometheus-kube-prometheus-stack-prometheus-0            2/2     Running
NAME          READY   SECRET        AGE
grafana-tls   True    grafana-tls   40s

Warum ...NilUsesHelmValues: false? Sonst sammelt Prometheus nur ServiceMonitors mit dem Release-Label ein. vLLM (Tag 11), LiteLLM (Tag 12) und DCGM (Tag 10) bringen eigene mit. etcd, Scheduler und Controller-Manager lauschen bei RKE2 nur auf 127.0.0.1 – ohne Freigabe wären das dauerhaft rote Targets, deshalb im Lab aus.

curl -s https://grafana.lab.internal/api/health | jq -r .database

Erwartet:

ok

Login admin / lab-grafana-1234 (Lab-Wert). Kein -k nötig – die Lab-CA ist seit Drill 3 vertrauenswürdig.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

export KUBECONFIG=~/ki-lab/rke2.yaml
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "LB-Pool lab-pool" 'kubectl get ciliumloadbalancerippool lab-pool'
check "Traefik auf 10.10.20.100" '[ "$(kubectl -n kube-system get svc \
  rke2-traefik -o jsonpath="{.status.loadBalancer.ingress[0].ip}")" \
  = 10.10.20.100 ]'
check "ClusterIssuer lab-ca Ready" 'kubectl wait clusterissuer/lab-ca \
  --for=condition=Ready --timeout=5s'
check "StorageClass longhorn (default)" 'kubectl get sc longhorn -o \
  jsonpath="{.metadata.annotations}" | grep -q "is-default-class\":\"true"'
check "StorageClass local-path" 'kubectl get sc local-path'
check "Grafana per HTTPS" 'curl -sf https://grafana.lab.internal/api/health'
check "Prometheus-Targets up" '[ "$(kubectl -n monitoring exec \
  prometheus-kube-prometheus-stack-prometheus-0 -c prometheus -- \
  wget -qO- "http://localhost:9090/api/v1/query?query=count(up==0)" \
  | jq -r ".data.result | length")" -eq 0 ]'

Erwartet:

✔ LB-Pool lab-pool
✔ Traefik auf 10.10.20.100
✔ ClusterIssuer lab-ca Ready
✔ StorageClass longhorn (default)
✔ StorageClass local-path
✔ Grafana per HTTPS
✔ Prometheus-Targets up

Challenge

Veröffentliche den Longhorn-Frontend-Service unter https://longhorn.lab.internal mit einem Zertifikat der Lab-CA, aber nur mit Basic-Auth davor (Benutzer admin, Lab-Passwort lab-longhorn-1234).

Hinweis: Traefik liest Basic-Auth aus einer Middleware (CRD traefik.io/v1alpha1) und bindet sie per Ingress-Annotation traefik.ingress.kubernetes.io/router.middlewares: <ns>-<name>@kubernetescrd ein.

Lösung

NS=longhorn-system
kubectl -n $NS create secret generic longhorn-auth \
  --from-literal=users="$(htpasswd -nbB admin lab-longhorn-1234)"
cat <<'EOF' | kubectl apply -f -
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata: {name: longhorn-auth, namespace: longhorn-system}
spec:
  basicAuth: {secret: longhorn-auth}
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: longhorn
  namespace: longhorn-system
  annotations:
    cert-manager.io/cluster-issuer: lab-ca
    traefik.ingress.kubernetes.io/router.middlewares: >-
      longhorn-system-longhorn-auth@kubernetescrd
spec:
  ingressClassName: traefik
  tls: [{hosts: [longhorn.lab.internal], secretName: longhorn-tls}]
  rules:
    - host: longhorn.lab.internal
      http:
        paths:
          - path: /
            pathType: Prefix
            backend: {service: {name: longhorn-frontend, port: {number: 80}}}
EOF
echo "10.10.20.100 longhorn.lab.internal" | sudo tee -a /etc/hosts
curl -s -o /dev/null -w '%{http_code}\n' https://longhorn.lab.internal
curl -s -o /dev/null -w '%{http_code}\n' -u admin:lab-longhorn-1234 \
  https://longhorn.lab.internal

Erwartet (nicht live getestet):

401
200

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • L2-Announcements funktionieren nur in einem L2-Segment und haben einen Failover von Sekunden (Lease). Im Rechenzentrum: Cilium BGP Control Plane gegen die Top-of-Rack-Router oder ein externer Load Balancer.
  • Statt selbstsignierter Root-CA: Intermediate-CA aus der Firmen-PKI oder aus Vault/OpenBao (cert-manager Vault-Issuer), kurze Laufzeiten, CA-Schlüssel nie im Cluster. Für öffentliche Namen ACME.
  • Longhorn produktiv: eigene Datenplatten statt OS-Disk, Backup-Target (S3/NFS) und Recurring Jobs, mindestens 3 Storage-Nodes. Für sehr große Modelle ist ein schnelles Shared-Filesystem (NFS/CephFS, RWX) als Modell-Cache oft besser als local-path.
  • Monitoring: Prometheus mit Thanos/Mimir für Langzeit und HA, Alertmanager mit echten Receivern, Grafana per OIDC (Keycloak, Tag 13) statt Admin-Passwort.
  • Ingress-Wechsel dokumentieren: Bestehende Kunden mit rke2-ingress-nginx müssen bis v1.37 auf Traefik (oder Gateway API) migrieren – Annotationen sind nicht kompatibel.