Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 10: GPUs in Kubernetes

Ziel: rke2-gpu-1 meldet nvidia.com/gpu, Pods sehen die Karte per nvidia-smi, die GPU ist per Time-Slicing teilbar und DCGM-Metriken landen in Prometheus. · Dauer: ca. 150 min · Voraussetzung: Tag 9

Briefing

  • Treiber im Gast (Ubuntu-Paket per Ansible) oder als Container vom GPU Operator – du nimmst im Lab den Gast-Treiber, der Operator liefert den Rest.
  • GPU Operator = Container Toolkit, Device Plugin, GPU Feature Discovery (GFD), DCGM Exporter, Validator.
  • RKE2 hat ein eigenes containerd unter /run/k3s/containerd/ – das muss das Toolkit wissen.
  • Taint nvidia.com/gpu hält normale Pods vom teuren Node fern.
  • Time-Slicing teilt eine GPU ohne Speicherisolation. DRA ist der Nachfolger des Device Plugins.
rke2-gpu-1 (VM, Passthrough L4)
  Kernel: nvidia.ko (Rolle nvidia_host)
  RKE2 containerd /run/k3s/containerd  <-- Toolkit: Runtime "nvidia" + CDI
  Device Plugin  --> Node: nvidia.com/gpu: 1 (Time-Slicing: 4)
  GFD            --> Labels nvidia.com/gpu.product=NVIDIA-L4 ...
  DCGM Exporter  --> :9400/metrics --> ServiceMonitor --> Prometheus

Achtung: Ohne GPU auf dieser Maschine sind alle GPU-Ausgaben gegen die NVIDIA- und RKE2-Doku (GPU Operator v26.7.1, RKE2 v1.36) geprüft, aber nicht live getestet. Manifeste und Helm-Werte wurden per helm template + kubeconform und kubectl apply --dry-run=server validiert, die Ansible-Rolle mit ansible-lint.

Drill 1: Treiber im Gast oder vom Operator?

Kriterium Treiber im Gast (Paket) Treiber-Container (Operator)
Installation Ansible, Reboot DaemonSet, kompiliert/lädt Modul
Kernel-Update DKMS/Paket muss passen Image muss zum Kernel passen
Debugging nvidia-smi direkt auf dem Host nur im Treiber-Pod
Gut für wenige, langlebige VMs (Lab) große, homogene Flotten

Du installierst den Treiber im Gast. Die Rolle nvidia_host nutzt ubuntu-drivers mit dem Server-Branch 580 (DRA verlangt ≥ 580). Die Operator-Variante liegt als code/gpu/gpu-operator-driver-values.yaml bei (driver.enabled: true, Treiber 595.91.07).

cd ~/ki-lab/code/infra-rke2
mkdir -p roles/nvidia_host/{defaults,tasks,handlers}
cat > roles/nvidia_host/defaults/main.yml <<'EOF'
---
# Treiber-Branch im Gast (Tag 10). DRA braucht >= 580.
nvidia_host_driver_branch: "580-server"
EOF
cat > roles/nvidia_host/tasks/main.yml <<'EOF'
---
- name: Werkzeug für Ubuntu-Treiberauswahl installieren
  ansible.builtin.apt:
    name: ubuntu-drivers-common
    update_cache: true

- name: Ist der Treiber schon geladen?
  ansible.builtin.command: nvidia-smi -L
  register: nvidia_host_smi
  changed_when: false
  failed_when: false

- name: Headless-Treiber (GPGPU) installieren
  ansible.builtin.command: >-
    ubuntu-drivers install --gpgpu nvidia:{{ nvidia_host_driver_branch }}
  when: nvidia_host_smi.rc != 0
  changed_when: true
  notify: Reboot GPU node

- name: Userspace-Tools (nvidia-smi, libnvidia-ml)
  ansible.builtin.apt:
    name: "nvidia-utils-{{ nvidia_host_driver_branch }}"
  notify: Reboot GPU node
EOF
cat > roles/nvidia_host/handlers/main.yml <<'EOF'
---
- name: Reboot GPU node
  ansible.builtin.reboot:
    reboot_timeout: 600
EOF
cat > gpu.yml <<'EOF'
---
# Tag 10: NVIDIA-Treiber im Gast der GPU-VMs
- name: NVIDIA-Treiber auf GPU-Nodes
  hosts: gpu_nodes
  become: true
  serial: 1
  roles:
    - nvidia_host
EOF
ansible-lint gpu.yml roles/nvidia_host
ansible-playbook -i inventory.yaml gpu.yml
ssh [email protected] nvidia-smi --query-gpu=name,driver_version,memory.total \
  --format=csv

Erwartet (Lint live getestet, Rest gekürzt, nicht live getestet):

Passed: 0 failure(s), 0 warning(s) in 5 files processed of 5 encountered.
...
RUNNING HANDLER [nvidia_host : Reboot GPU node] ********************************
changed: [rke2-gpu-1]
rke2-gpu-1   : ok=6    changed=3    unreachable=0    failed=0
name, driver_version, memory.total [MiB]
NVIDIA L4, 580.95.05, 23034 MiB

Warum --gpgpu? Das installiert den Headless-Treiber ohne X11-Pakete und mit vorkompilierten, signierten Kernel-Modulen. Die VM aus Tag 7 bootet OVMF ohne vorgeladene Secure-Boot-Schlüssel – mit Secure Boot bräuchtest du sonst MOK-Enrollment.

Fortschritt speichern? Kostenlos registrieren

Drill 2: GPU-Node reservieren (Taint)

export KUBECONFIG=~/ki-lab/rke2.yaml
kubectl taint node rke2-gpu-1 nvidia.com/gpu=present:NoSchedule
kubectl get node rke2-gpu-1 -o jsonpath='{.spec.taints}{"\n"}' | jq -c .

Erwartet:

node/rke2-gpu-1 tainted
[{"effect":"NoSchedule","key":"nvidia.com/gpu","value":"present"}]

Warum NoSchedule statt NoExecute? Laufende DaemonSets (Cilium, Traefik, node-exporter, Longhorn) bleiben, neue normale Pods landen nicht mehr auf der GPU-VM. Die Operator-DaemonSets tolerieren genau diesen Key bereits (Chart-Default daemonsets.tolerations). RKE2 setzt Taints aus der config.yaml (node-taint) nur bei der ersten Registrierung – für bestehende Nodes nimmst du kubectl.

Fortschritt speichern? Kostenlos registrieren

Drill 3: GPU Operator auf RKE2 installieren

mkdir -p ~/ki-lab/code/gpu && cd ~/ki-lab/code/gpu
cat > gpu-operator-values.yaml <<'EOF'
# NVIDIA GPU Operator v26.7.1 auf RKE2 (Tag 10)
# Treiber liegt im Gast (Rolle nvidia_host), der Operator macht den Rest.
driver:
  enabled: false
toolkit:
  env:
    # RKE2 betreibt sein eigenes containerd unter /run/k3s
    - name: CONTAINERD_SOCKET
      value: /run/k3s/containerd/containerd.sock
dcgmExporter:
  serviceMonitor:
    enabled: true           # kube-prometheus-stack aus Tag 9 sammelt ihn ein
    interval: 15s
EOF
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update nvidia
helm upgrade --install gpu-operator nvidia/gpu-operator --version v26.7.1 \
  -n gpu-operator --create-namespace -f gpu-operator-values.yaml --wait

Erwartet (gekürzt, nicht live getestet):

Release "gpu-operator" does not exist. Installing it now.
NAME: gpu-operator
NAMESPACE: gpu-operator
STATUS: deployed
REVISION: 1

Warum nur CONTAINERD_SOCKET? Das ist laut RKE2-Doku für Operator v25.10/v26.x die einzige nötige Anpassung. Das Toolkit trägt die Runtime nvidia über diesen Socket in RKE2s containerd ein. Ältere Anleitungen setzen zusätzlich CONTAINERD_CONFIG auf config.toml.tmpl – bei aktuellen Versionen nicht mehr nötig, mit v25.3 brauchst du noch runtimeClassName: nvidia in jedem Pod.

Tipp: Alternativ legst du dieselben Werte als HelmChart-Ressource (helm.cattle.io/v1) nach /var/lib/rancher/rke2/server/manifests/ – so macht es die RKE2-Doku. Im Lab bleibst du bei Helm wie in Tag 9.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Operator validieren

kubectl -n gpu-operator get pods
kubectl -n gpu-operator logs -l app=nvidia-operator-validator \
  -c nvidia-operator-validator --tail=3
kubectl get runtimeclass
ssh [email protected] \
  'sudo grep -rl nvidia /var/lib/rancher/rke2/agent/etc/containerd/'

Erwartet (gekürzt, nicht live getestet, Pod-Namen weichen ab):

NAME                                                READY   STATUS
gpu-feature-discovery-x7k2p                         1/1     Running
gpu-operator-7c9d8f6b5-l2m4n                        1/1     Running
gpu-operator-node-feature-discovery-gc-5f8b-q9w     1/1     Running
gpu-operator-node-feature-discovery-master-6d-tz    1/1     Running
gpu-operator-node-feature-discovery-worker-abcde    1/1     Running
nvidia-container-toolkit-daemonset-h5j8k            1/1     Running
nvidia-cuda-validator-p4r7s                         0/1     Completed
nvidia-dcgm-exporter-m3n6b                          1/1     Running
nvidia-device-plugin-daemonset-w8e2c                1/1     Running
nvidia-operator-validator-f6g9h                     1/1     Running
all validations are successful
NAME             HANDLER          AGE
nvidia           nvidia           4m
nvidia-cdi       nvidia-cdi       4m
nvidia-legacy    nvidia-legacy    4m
/var/lib/rancher/rke2/agent/etc/containerd/config.toml

Kein nvidia-driver-daemonset – richtig so, der Treiber kommt aus dem Gast. Hängt nvidia-operator-validator in Init, zeigt kubectl -n gpu-operator logs <pod> -c driver-validation meist den Grund (Treiber nicht geladen, falscher Socket).

Fortschritt speichern? Kostenlos registrieren

Drill 5: Labels, Kapazität und nvidia-smi im Pod

GFD schreibt Eigenschaften der Karte als Labels an den Node – damit planst du Workloads gezielt.

kubectl get node rke2-gpu-1 -o json | jq -r '.metadata.labels
  | with_entries(select(.key | test("nvidia.com/(gpu|cuda|mig)")))
  | to_entries[] | "\(.key)=\(.value)"' | sort
kubectl get node rke2-gpu-1 -o jsonpath='{.status.allocatable.nvidia\.com/gpu}{"\n"}'

Erwartet (Auszug, nicht live getestet, Beispiel L4):

nvidia.com/cuda.driver-version.major=580
nvidia.com/gpu.count=1
nvidia.com/gpu.family=ada-lovelace
nvidia.com/gpu.memory=23034
nvidia.com/gpu.present=true
nvidia.com/gpu.product=NVIDIA-L4
nvidia.com/mig.capable=false
1

Jetzt der Rauchtest: ein Pod mit nvidia-smi (CUDA-Basisimage, das Toolkit injiziert Treiber und Binary).

cat > gpu-smoke.yaml <<'EOF'
# GPU-Rauchtest (Tag 10): nvidia-smi auf rke2-gpu-1
apiVersion: v1
kind: Namespace
metadata:
  name: gpu-test
---
apiVersion: v1
kind: Pod
metadata:
  name: nvidia-smi
  namespace: gpu-test
spec:
  restartPolicy: Never
  nodeSelector:
    nvidia.com/gpu.present: "true"
  tolerations:
    - key: nvidia.com/gpu
      operator: Exists
      effect: NoSchedule
  containers:
    - name: smi
      image: nvcr.io/nvidia/cuda:13.0.2-base-ubuntu24.04
      command: ["nvidia-smi"]
      resources:
        limits:
          nvidia.com/gpu: 1
EOF
kubectl apply -f gpu-smoke.yaml
kubectl -n gpu-test wait pod/nvidia-smi --for=jsonpath='{.status.phase}'=Succeeded \
  --timeout=180s
kubectl -n gpu-test logs nvidia-smi | head -12

Erwartet (Server-Dry-Run live getestet, Ausgaben gekürzt, nicht live getestet):

pod/nvidia-smi condition met
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 580.95.05     Driver Version: 580.95.05     CUDA Version: 13.0   |
|-------------------------------+----------------------+----------------------+
| GPU  Name                     | Bus-Id        Disp.A | Volatile Uncorr. ECC |
|   0  NVIDIA L4             On | 00000000:01:00.0 Off |                    0 |
| N/A   34C    P8    12W /  72W |      0MiB / 23034MiB |      0%      Default |
...

Gegenprobe: ein GPU-Pod ohne Toleration.

kubectl -n gpu-test get pod nvidia-smi -o json | jq '.metadata = {name: "no-tol",
  namespace: "gpu-test"} | del(.spec.tolerations, .spec.nodeSelector,
  .spec.nodeName, .status)' | kubectl create -f -
sleep 5
kubectl -n gpu-test get events --field-selector involvedObject.name=no-tol \
  -o jsonpath='{.items[-1].message}{"\n"}'
kubectl -n gpu-test delete pod no-tol

Erwartet (nicht live getestet, gekürzt):

0/6 nodes are available: 1 node(s) had untolerated taint {nvidia.com/gpu:
present}, 2 Insufficient nvidia.com/gpu, 3 node(s) had untolerated taint
{CriticalAddonsOnly: true}. preemption: 0/6 nodes are available: ...
pod "no-tol" deleted

Warum braucht jeder GPU-Pod die Toleration selbst? Der Admission-Controller ExtendedResourceToleration, der sie automatisch ergänzt, ist in RKE2 nicht aktiv.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Time-Slicing – eine GPU, vier Slots

vLLM-Chat (Tag 11) und das Embedding-Modell (Tag 13) sollen sich die L4 teilen. Time-Slicing meldet die Karte mehrfach. Speicher und Fehler sind dabei nicht isoliert – das regelt später --gpu-memory-utilization pro vLLM.

cat > time-slicing.yaml <<'EOF'
# Time-Slicing: 1 physische GPU erscheint als 4 x nvidia.com/gpu
apiVersion: v1
kind: ConfigMap
metadata:
  name: time-slicing-config
  namespace: gpu-operator
data:
  any: |-
    version: v1
    flags:
      migStrategy: none
    sharing:
      timeSlicing:
        renameByDefault: false
        failRequestsGreaterThanOne: true
        resources:
          - name: nvidia.com/gpu
            replicas: 4
EOF
cat > gpu-operator-timeslicing-values.yaml <<'EOF'
# Overlay zu gpu-operator-values.yaml: Device Plugin liest time-slicing-config
devicePlugin:
  config:
    name: time-slicing-config
    default: any
EOF
kubectl apply -f time-slicing.yaml
helm upgrade gpu-operator nvidia/gpu-operator --version v26.7.1 -n gpu-operator \
  -f gpu-operator-values.yaml -f gpu-operator-timeslicing-values.yaml --wait
kubectl -n gpu-operator rollout status ds/nvidia-device-plugin-daemonset
kubectl get node rke2-gpu-1 -o json | jq -c '{
  gpu: .status.allocatable["nvidia.com/gpu"],
  replicas: .metadata.labels["nvidia.com/gpu.replicas"],
  product: .metadata.labels["nvidia.com/gpu.product"]}'

Erwartet (Dry-Run live getestet, Node-Ausgabe nicht live getestet):

configmap/time-slicing-config created
daemon set "nvidia-device-plugin-daemonset" successfully rolled out
{"gpu":"4","replicas":"4","product":"NVIDIA-L4-SHARED"}

Warum per Helm statt kubectl patch clusterpolicies? Die NVIDIA-Doku patcht die ClusterPolicy direkt. Das nächste helm upgrade würde den Patch aber wieder überschreiben. failRequestsGreaterThanOne: true lässt Pods mit nvidia.com/gpu: 2 scheitern – zwei Slots wären ohnehin nicht doppelt so schnell. Das Suffix -SHARED am Produkt-Label verrät per nodeSelector, dass die Karte geteilt ist.

Fortschritt speichern? Kostenlos registrieren

Drill 7: DCGM Exporter in Prometheus

Der Operator bringt Service und ServiceMonitor mit. Prometheus aus Tag 9 sammelt alle ServiceMonitors ein – ohne Release-Label.

kubectl -n gpu-operator get svc,servicemonitor -l app=nvidia-dcgm-exporter
# PromQL-Helfer für die nächsten Kapitel: Abfrage im Prometheus-Pod
promq() {
  kubectl -n monitoring exec prometheus-kube-prometheus-stack-prometheus-0 \
    -c prometheus -- wget -qO- "http://localhost:9090/api/v1/query?query=$(
    jq -rn --arg q "$1" '$q|@uri')" | jq -r '.data.result[]
    | "\(.metric.Hostname // .metric.pod // "-") \(.value[1])"'
}
promq 'DCGM_FI_DEV_GPU_UTIL'
promq 'DCGM_FI_DEV_FB_USED / (DCGM_FI_DEV_FB_USED + DCGM_FI_DEV_FB_FREE)'
promq 'DCGM_FI_DEV_GPU_TEMP'
promq 'DCGM_FI_DEV_POWER_USAGE'

Erwartet (gekürzt, nicht live getestet):

NAME                           TYPE        CLUSTER-IP     PORT(S)
service/nvidia-dcgm-exporter   ClusterIP   10.43.88.12    9400/TCP
NAME                                                        AGE
servicemonitor.monitoring.coreos.com/nvidia-dcgm-exporter   12m
rke2-gpu-1 0
rke2-gpu-1 0.0004
rke2-gpu-1 34
rke2-gpu-1 12.1
Metrik Bedeutung Alarm ab (Faustregel)
DCGM_FI_DEV_GPU_UTIL Rechenauslastung in % dauerhaft 100 % + Warteschlange
DCGM_FI_DEV_FB_USED belegter VRAM in MiB vLLM belegt absichtlich ~90 %
DCGM_FI_DEV_GPU_TEMP Temperatur in °C > 85 °C
DCGM_FI_DEV_XID_ERRORS letzter Xid-Fehler jeder Wert > 0

Warum Hostname? DCGM setzt das Label auf den Node-Namen. Mit Time-Slicing siehst du trotzdem nur eine physische GPU – die Zuordnung zu Pods kommt über die Labels pod/namespace, sobald ein Pod die GPU hält.

Fortschritt speichern? Kostenlos registrieren

Drill 8: MIG-Check und DRA-Ausblick

MIG (Multi-Instance GPU) teilt A100/H100/H200/B200 in isolierte Instanzen mit eigenem Speicher. Eine L4 oder RTX kann das nicht:

ssh [email protected] nvidia-smi --query-gpu=name,mig.mode.current --format=csv

Erwartet (nicht live getestet): NVIDIA L4, [N/A] nach der CSV-Kopfzeile.

Mit MIG-Karte setzt du im Chart mig.strategy: single und labelst den Node mit nvidia.com/mig.config=all-1g.10gb. Der MIG Manager partitioniert dann und das Device Plugin meldet die Instanzen.

DRA (Dynamic Resource Allocation, resource.k8s.io/v1, GA seit Kubernetes 1.34) ersetzt nvidia.com/gpu: 1 durch Claims mit Filtern auf Attribute (Modell, Speicher). Im GPU Operator v26.7 ist das der experimentelle GPUCluster-Modus. Er schließt die ClusterPolicy aus, einen In-place-Wechsel gibt es nicht. Du baust also um und am Ende wieder zurück.

cat > gpu-operator-dra-values.yaml <<'EOF'
# DRA-Modus (experimentell in v26.7): GPUCluster statt ClusterPolicy
# Kein In-place-Wechsel: Operator vorher deinstallieren!
# Ohne Device Plugin und Toolkit: der DRA-Treiber liefert CDI-Specs selbst.
clusterPolicy:
  deployCR: false
gpuCluster:
  deployCR: true
driver:
  enabled: false            # Treiber aus der Rolle nvidia_host (>= 580)
draDriver:
  computeDomains:
    enabled: false          # nur für Multi-Node-NVLink (GB200 & Co.)
EOF
kubectl delete ns gpu-test --wait
helm uninstall gpu-operator -n gpu-operator --wait
helm install gpu-operator nvidia/gpu-operator --version v26.7.1 \
  -n gpu-operator -f gpu-operator-dra-values.yaml --wait
kubectl get gpucluster gpu-cluster
kubectl get deviceclass
kubectl get resourceslice -o json | jq -r '.items[].spec.devices[]
  | "\(.name) \(.attributes.productName.string) \(.capacity.memory.value)"'

Erwartet (Rendering und GPUCluster-Dry-Run live getestet, Rest nicht live getestet):

NAME          STATUS   AGE
gpu-cluster   ready    3m
NAME                  AGE
gpu.nvidia.com        3m
mig.nvidia.com        3m
vfio.gpu.nvidia.com   3m
gpu-0 NVIDIA L4 23034Mi

Der Claim fordert „eine GPU mit mehr als 16 GiB“ – per CEL statt Node-Label:

kubectl create ns gpu-test
cat > dra-test.yaml <<'EOF'
# DRA (Tag 10, Drill 8): GPU per ResourceClaim statt nvidia.com/gpu
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: single-gpu
  namespace: gpu-test
spec:
  spec:
    devices:
      requests:
        - name: gpu
          exactly:
            deviceClassName: gpu.nvidia.com
            selectors:
              - cel:
                  expression: >-
                    device.capacity['gpu.nvidia.com'].memory
                    .isGreaterThan(quantity('16Gi'))
---
apiVersion: v1
kind: Pod
metadata:
  name: dra-smi
  namespace: gpu-test
spec:
  restartPolicy: Never
  tolerations:
    - key: nvidia.com/gpu
      operator: Exists
      effect: NoSchedule
  containers:
    - name: smi
      image: nvcr.io/nvidia/cuda:13.0.2-base-ubuntu24.04
      command: ["nvidia-smi", "-L"]
      resources:
        claims:
          - name: gpu
  resourceClaims:
    - name: gpu
      resourceClaimTemplateName: single-gpu
EOF
kubectl apply -f dra-test.yaml
kubectl -n gpu-test wait pod/dra-smi --for=jsonpath='{.status.phase}'=Succeeded \
  --timeout=180s
kubectl -n gpu-test logs dra-smi
kubectl -n gpu-test get resourceclaims

Erwartet (Dry-Run live getestet, Ausgabe nicht live getestet):

resourceclaimtemplate.resource.k8s.io/single-gpu created
pod/dra-smi created
pod/dra-smi condition met
GPU 0: NVIDIA L4 (UUID: GPU-5c1f...)
NAME                STATE                AGE
dra-smi-gpu-x8k2q   allocated,reserved   40s

Zurück zum Device-Plugin-Modus mit Time-Slicing – die Kapitel 11–14 bauen darauf auf:

kubectl delete ns gpu-test
helm uninstall gpu-operator -n gpu-operator --wait
helm install gpu-operator nvidia/gpu-operator --version v26.7.1 -n gpu-operator \
  -f gpu-operator-values.yaml -f gpu-operator-timeslicing-values.yaml --wait
kubectl get node rke2-gpu-1 \
  -o jsonpath='{.status.allocatable.nvidia\.com/gpu}{"\n"}'

Erwartet (nicht live getestet):

4

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
export KUBECONFIG=~/ki-lab/rke2.yaml
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "Taint nvidia.com/gpu auf rke2-gpu-1" 'kubectl get node rke2-gpu-1 \
  -o jsonpath="{.spec.taints[*].key}" | grep -q nvidia.com/gpu'
check "Operator-Validator Running" '[ "$(kubectl -n gpu-operator get pods \
  -l app=nvidia-operator-validator -o jsonpath="{.items[0].status.phase}")" \
  = Running ]'
check "GFD-Label gpu.present" '[ "$(kubectl get node rke2-gpu-1 -o \
  jsonpath="{.metadata.labels.nvidia\.com/gpu\.present}")" = true ]'
check "Time-Slicing: 4 GPUs" '[ "$(kubectl get node rke2-gpu-1 -o \
  jsonpath="{.status.allocatable.nvidia\.com/gpu}")" = 4 ]'
check "ServiceMonitor DCGM" 'kubectl -n gpu-operator get servicemonitor \
  nvidia-dcgm-exporter'
check "DCGM-Metrik in Prometheus" '[ -n "$(promq DCGM_FI_DEV_GPU_TEMP)" ]'

Erwartet:

✔ Taint nvidia.com/gpu auf rke2-gpu-1
✔ Operator-Validator Running
✔ GFD-Label gpu.present
✔ Time-Slicing: 4 GPUs
✔ ServiceMonitor DCGM
✔ DCGM-Metrik in Prometheus

Die letzte Prüfung braucht die Funktion promq aus Drill 7 (im selben Shell sourcen).

Challenge

Ein zweiter GPU-Node soll später nur 2 Slots bekommen. Lege dafür in derselben ConfigMap ein zweites Profil l4-2 an und weise es per Node-Label nur rke2-gpu-1 zu – zum Testen.

Hinweis: Der Device Plugin liest das Profil aus dem Node-Label nvidia.com/device-plugin.config; default: any gilt nur für Nodes ohne Label.

Lösung

kubectl -n gpu-operator patch configmap time-slicing-config --type merge -p '
data:
  l4-2: |-
    version: v1
    flags:
      migStrategy: none
    sharing:
      timeSlicing:
        failRequestsGreaterThanOne: true
        resources:
          - name: nvidia.com/gpu
            replicas: 2
'
kubectl label node rke2-gpu-1 nvidia.com/device-plugin.config=l4-2 --overwrite
sleep 60
kubectl get node rke2-gpu-1 -o jsonpath='{.status.allocatable.nvidia\.com/gpu}{"\n"}'
kubectl label node rke2-gpu-1 nvidia.com/device-plugin.config-

Erwartet (nicht live getestet):

2

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Treiber, Toolkit und Kernel zusammen versionieren und auf einem Canary-GPU-Node testen. Beim Operator-Treiber vorkompilierte Images (driver.usePrecompiled) für reproduzierbare Rollouts.
  • Time-Slicing nur für Dev/Test oder klar budgetierte Inferenz. Für Mandantentrennung MIG (A100/H100) oder dedizierte GPUs, dazu ResourceQuotas auf requests.nvidia.com/gpu pro Namespace.
  • DRA ist die Zukunft (Filter auf Speicher/Modell, geteilte Claims, MIG dynamisch). Im GPU Operator ist der GPUCluster-Modus noch experimentell – produktiv erst nach Freigabe durch NVIDIA einplanen.
  • DCGM-Alarme: Xid-Fehler, ECC-Fehler, Temperatur, Throttling (DCGM_FI_DEV_CLOCK_THROTTLE_REASONS). GPU-Nodes per Node-Pool und Cluster-Autoscaler (Cloud) bzw. Kapazitätsplanung (on-prem) managen.
  • Härtung: CIS-Profil und PSA restricted brauchen Ausnahmen für den Namespace gpu-operator (privilegierte DaemonSets) – dokumentieren und auditieren.