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-IP10.10.20.100, auf die*.lab.internalzeigt. - cert-manager mit eigener Root-CA:
ClusterIssuer lab-castellt alle Lab-Zertifikate aus. - Storage:
longhorn(Default, 2 Replicas) für Datenbanken und Prometheus,local-pathnur aufrke2-gpu-1für den Modell-Cache (Tag 11). - kube-prometheus-stack minimal im Namespace
monitoring, Grafana untergrafana.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 ciliumloadbalancerippoolsErwartet (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 lbtestErwartet (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
.100vonlbtestbelegt, bevor Traefik kommt, gib sie mitkubectl delete svc lbtestwieder 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 istErwartet (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.internalErwartet:
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 clusterissuerErwartet (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.crtErwartet (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 storageclassErwartet (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:80Fortschritt 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-pathErwartet (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-testErwartet (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-tlsErwartet (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 .databaseErwartet:
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.internalErwartet (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-nginxmüssen bis v1.37 auf Traefik (oder Gateway API) migrieren – Annotationen sind nicht kompatibel.