K8s AI GPU-Scheduling in der Praxis: MIG-Partitionierung, GPU-Sharing und Multi-Tenant-Workload-Orchestrierung

云原生

Zusammenfassung

  • GPUs sind die Kernressource für KI-Workloads: Die durchschnittliche GPU-Auslastung in K8s-Clustern liegt nur bei 30–40 %; eine Scheduling-Optimierung kann sie auf über 80 % steigern
  • NVIDIA MIG-Partitionierung: Eine einzelne A100 lässt sich in 7 Instanzen aufteilen, ermöglicht die parallele Ausführung verschiedener KI-Aufgaben und steigert die Ressourcennutzung um das 3-Fache
  • Drei GPU-Sharing-Modi: Time Slicing (TS), MPS und MIG, jeweils geeignet für Inferenz, Training und gemischte Szenarien
  • Multi-Tenant-Scheduling-Strategien: GPU-Quotenverwaltung, prioritätsbasierte Präemption und elastisches Skalieren zur Sicherstellung der SLA-Einhaltung
  • Dieser Artikel bietet eine Full-Stack-K8s-GPU-Scheduling-Lösung, einschließlich Device-Plugin-Konfiguration und Praxisbeispielen zur Scheduler-Erweiterung

Inhaltsverzeichnis

GPU-Scheduling: Die zentrale Herausforderung von KI-Clustern

Aktueller Stand der GPU-Ressourcenverschwendung

Problem Ursache Verschwendungsanteil
Geringe Inferenz-Auslastung Ein einzelner Inferenz-Request nutzt nur 10–20 % der GPU 40–60 %
Trainings-Fragmentierung Training kleiner Modelle belegt eine ganze Karte 20–30 %
Leerlauf-Warten Tasks warten in der Queue auf GPU-Freigabe 15–25 %
Fehlkonfiguration Resource-Requests stimmen nicht mit tatsächlicher Nutzung überein 10–15 %

GPU-Scheduling-Entwicklung

Phase Zeitraum Ansatz Merkmale
Exklusivmodus Vor 2020 1Pod=1GPU Einfach, aber verschwenderisch
Time Slicing 2021 GPU-Zeitscheiben-Sharing Geeignet für Inferenz
MIG-Partitionierung 2022 Hardware-Level-Partitionierung der A100 Starke Isolation
MPS-Sharing 2023 Multi-Prozess-GPU-Sharing Geeignet für Training
Elastisches Scheduling 2024–2026 Dynamisches MIG + Priorität Intelligent

Verbreitete GPU-Spezifikationen 2026

GPU Speicher MIG-Instanzen Geeignete Szenarien Preis ($/h)
A100 80GB 80GB 7×10GB oder 2×40GB Allgemeines Training & Inferenz 3,5
H100 80GB 80GB 7×10GB oder 2×40GB Training großer Modelle 4,5
H200 141GB 141GB 7×20GB oder 2×70GB Ultragroße Modelle 6,0
L40S 48GB 48GB MIG nicht unterstützt Inferenz/Feintuning 1,5
RTX 4090 24GB MIG nicht unterstützt Entwicklung & Test 0,8

NVIDIA MIG-Partitionierung in der Praxis

MIG-Architekturüberblick

┌──────────────────────────────────────────────────────────────┐
│              A100 80GB MIG Partitioning Schemes                │
│                                                                │
│  Scheme 1: 7x MIG 1g.10gb (maximum parallelism)              │
│  ┌──────┐┌──────┐┌──────┐┌──────┐┌──────┐┌──────┐┌──────┐   │
│  │ GI 0 ││ GI 1 ││ GI 2 ││ GI 3 ││ GI 4 ││ GI 5 ││ GI 6 │   │
│  │10GB  ││10GB  ││10GB  ││10GB  ││10GB  ││10GB  ││10GB  │   │
│  │14SM  ││14SM  ││14SM  ││14SM  ││14SM  ││14SM  ││14SM  │   │
│  └──────┘└──────┘└──────┘└──────┘└──────┘└──────┘└──────┘   │
│  Suited for: 7 lightweight inference services in parallel     │
│                                                                │
│  Scheme 2: 2x MIG 3g.40gb (large model inference)            │
│  ┌─────────────────────────────┐┌─────────────────────────────┐│
│  │          GI 0               ││          GI 1               ││
│  │          40GB               ││          40GB               ││
│  │          42SM               ││          42SM               ││
│  └─────────────────────────────┘└─────────────────────────────┘│
│  Suited for: 2x 70B model inference (quantized)               │
│                                                                │
│  Scheme 3: 1x MIG 4g.40gb + 2x MIG 1g.10gb (mixed)          │
│  ┌─────────────────────────────┐┌──────┐┌──────┐              │
│  │          GI 0               ││ GI 1 ││ GI 2 │              │
│  │          40GB               ││10GB  ││10GB  │              │
│  │          56SM               ││14SM  ││14SM  │              │
│  └─────────────────────────────┘└──────┘└──────┘              │
│  Suited for: 1 large model inference + 2 lightweight inference │
└──────────────────────────────────────────────────────────────┘

MIG Configuration in Practice

# nvidia-mig-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: nvidia-mig-config
  namespace: gpu-operator
data:
  config.yaml: |
    version: v1
    mig-configs:
      all-1g.10gb:
        - devices: all
          mig-enabled: true
          mig-devices:
            "1g.10gb": 7
      all-2g.20gb:
        - devices: all
          mig-enabled: true
          mig-devices:
            "2g.20gb": 3
      all-3g.40gb:
        - devices: all
          mig-enabled: true
          mig-devices:
            "3g.40gb": 2
      mixed:
        - devices: [0]
          mig-enabled: true
          mig-devices:
            "3g.40gb": 2
        - devices: [1]
          mig-enabled: true
          mig-devices:
            "1g.10gb": 7
        - devices: [2, 3]
          mig-enabled: false
---
apiVersion: nvidia.com/v1alpha1
kind: MigManager
metadata:
  name: mig-manager
spec:
  config: nvidia-mig-config
  gpuClientsConfig:
    version: v1
    gpuClients:
      - namespace: "ai-inference"
        podSelector:
          matchLabels:
            workload: "llm-inference"
        migDevice: "3g.40gb"
      - namespace: "ai-inference"
        podSelector:
          matchLabels:
            workload: "light-inference"
        migDevice: "1g.10gb"

MIG Pod Scheduling

# Large model inference - using MIG 3g.40gb
apiVersion: v1
kind: Pod
metadata:
  name: llm-inference-70b
  namespace: ai-inference
  labels:
    workload: llm-inference
spec:
  containers:
    - name: inference
      image: vllm/vllm-openai:latest
      resources:
        limits:
          nvidia.com/mig-3g.40gb: 1
      env:
        - name: MODEL_NAME
          value: "Qwen/Qwen2.5-72B-Instruct-AWQ"
        - name: GPU_MEMORY_UTILIZATION
          value: "0.95"
        - name: MAX_MODEL_LEN
          value: "8192"
---
# Lightweight inference - using MIG 1g.10gb
apiVersion: v1
kind: Pod
metadata:
  name: embedding-service
  namespace: ai-inference
  labels:
    workload: light-inference
spec:
  containers:
    - name: embedding
      image: huggingface/tei:latest
      resources:
        limits:
          nvidia.com/mig-1g.10gb: 1
      env:
        - name: MODEL_NAME
          value: "BAAI/bge-large-zh-v1.5"
        - name: MAX_BATCH_SIZE
          value: "256"

Drei GPU-Sharing-Modi

Modus-Vergleich

Dimension Time Slicing (TS) MPS MIG
Isolationsebene Software Hardware (teilweise) Hardware (vollständig)
Speicherisolation Nein (gemeinsam) Nein (gemeinsam) Ja (unabhängig)
Performance-Isolation Schwach Mittel Gut
Parallelität Hoch Mittel Mittel
Fehlerisolation Schwach Schwach Gut
Geeignete Szenarien Inferenz Training Gemischt
GPU-Anforderung Allgemein Volta+ A100+

Time-Slicing-Konfiguration

# gpu-time-slicing.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: gpu-time-slicing-config
  namespace: gpu-operator
data:
  config.yaml: |
    version: v1
    flags:
      migStrategy: none
    sharing:
      timeSlicing:
        renameByDefault: false
        resources:
          - name: nvidia.com/gpu
            replicas: 4
            devices: all
---
# Pod using time slicing
apiVersion: apps/v1
kind: Deployment
metadata:
  name: inference-pool
  namespace: ai-inference
spec:
  replicas: 8
  selector:
    matchLabels:
      app: inference
  template:
    metadata:
      labels:
        app: inference
    spec:
      containers:
        - name: inference
          image: vllm/vllm-openai:latest
          resources:
            limits:
              nvidia.com/gpu: 1
          env:
            - name: MODEL_NAME
              value: "Qwen/Qwen2.5-7B-Instruct"

MPS-Konfiguration

# gpu-mps-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: gpu-mps-config
  namespace: gpu-operator
data:
  config.yaml: |
    version: v1
    sharing:
      mps:
        resources:
          - name: nvidia.com/gpu
            replicas: 2
            devices: all
---
apiVersion: v1
kind: Pod
metadata:
  name: training-job-mps
  namespace: ai-training
spec:
  containers:
    - name: training
      image: pytorch/pytorch:2.4-cuda12.4
      resources:
        limits:
          nvidia.com/gpu: 1
      command:
        - python
        - -m
        - torch.distributed.launch
        - --nproc_per_node=2
        - train.py

Entscheidungsbaum zur Modusauswahl

Haben Sie A100/H100?
├── Nein → Time Slicing (Inferenz) / MPS (Training)
└── Ja → Vollständige Isolation nötig?
    ├── Ja → MIG-Partitionierung
    └── Nein → Training nötig?
        ├── Ja → MPS
        └── Nein → Time Slicing

K8s GPU Device-Plugin-Konfiguration

NVIDIA Device-Plugin-Bereitstellung

# nvidia-device-plugin.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nvidia-device-plugin-daemonset
  namespace: kube-system
spec:
  selector:
    matchLabels:
      name: nvidia-device-plugin-ds
  template:
    metadata:
      labels:
        name: nvidia-device-plugin-ds
    spec:
      tolerations:
        - key: nvidia.com/gpu
          operator: Exists
          effect: NoSchedule
      priorityClassName: system-node-critical
      containers:
        - name: nvidia-device-plugin
          image: nvcr.io/nvidia/k8s-device-plugin:v0.16.0
          args:
            - --config=default
            - --mig-strategy=mixed
            - --pass-device-specs=true
            - --device-list-strategy=configmap
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop: ["ALL"]
          volumeMounts:
            - name: device-plugin
              mountPath: /var/lib/kubelet/device-plugins
      volumes:
        - name: device-plugin
          hostPath:
            path: /var/lib/kubelet/device-plugins

GPU-Ressourcenüberwachung

# gpu-monitor.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: gpu-monitor-config
  namespace: monitoring
data:
  gpu-metrics.json: |
    {
      "metrics": [
        "gpu_utilization",
        "gpu_memory_utilization",
        "gpu_memory_used_bytes",
        "gpu_memory_total_bytes",
        "gpu_power_usage_watts",
        "gpu_temperature_celsius",
        "gpu_sm_clock_mhz",
        "gpu_mem_clock_mhz"
      ],
      "scrape_interval": "15s",
      "labels": {
        "cluster": "production",
        "region": "cn-east"
      }
    }
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: dcgm-exporter
  namespace: monitoring
spec:
  selector:
    matchLabels:
      app: dcgm-exporter
  template:
    metadata:
      labels:
        app: dcgm-exporter
    spec:
      containers:
        - name: dcgm-exporter
          image: nvcr.io/nvidia/k8s/dcgm-exporter:3.3.7
          ports:
            - containerPort: 9400
              name: metrics
          env:
            - name: DCGM_EXPORTER_COLLECTORS
              value: "/etc/dcgm-exporter/dcp-metrics-inventory.csv"
          resources:
            limits:
              nvidia.com/gpu: 1

Multi-Tenant GPU-Scheduling-Strategien

GPU-Quotenverwaltung

# gpu-resource-quota.yaml
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-quota-team-a
  namespace: team-a
spec:
  hard:
    requests.nvidia.com/gpu: "8"
    limits.nvidia.com/gpu: "8"
    requests.nvidia.com/mig-3g.40gb: "4"
    limits.nvidia.com/mig-3g.40gb: "4"
    requests.nvidia.com/mig-1g.10gb: "14"
    limits.nvidia.com/mig-1g.10gb: "14"
---
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-quota-team-b
  namespace: team-b
spec:
  hard:
    requests.nvidia.com/gpu: "4"
    limits.nvidia.com/gpu: "4"
    requests.nvidia.com/mig-3g.40gb: "2"
    limits.nvidia.com/mig-3g.40gb: "2"

Prioritätsbasierte Präemptions-Scheduling

# gpu-priority-class.yaml
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: gpu-critical
value: 1000000
globalDefault: false
description: "Critical GPU workloads - can preempt others"
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: gpu-high
value: 900000
globalDefault: false
description: "High priority GPU workloads"
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: gpu-low
value: 100000
globalDefault: false
description: "Low priority GPU workloads - preemptible"
---
# Online inference - high priority
apiVersion: apps/v1
kind: Deployment
metadata:
  name: online-inference
spec:
  template:
    spec:
      priorityClassName: gpu-critical
      containers:
        - name: inference
          resources:
            limits:
              nvidia.com/mig-3g.40gb: 1
---
# Offline training - low priority
apiVersion: batch/v1
kind: Job
metadata:
  name: offline-training
spec:
  template:
    spec:
      priorityClassName: gpu-low
      containers:
        - name: training
          resources:
            limits:
              nvidia.com/gpu: 4

GPU-elastisches Skalieren

# gpu-hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: inference-hpa
  namespace: ai-inference
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: inference-pool
  minReplicas: 2
  maxReplicas: 20
  metrics:
    - type: Pods
      pods:
        metric:
          name: gpu_utilization
        target:
          type: AverageValue
          averageValue: "70"
    - type: Pods
      pods:
        metric:
          name: request_latency_ms
        target:
          type: AverageValue
          averageValue: "200"
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
        - type: Percent
          value: 50
          periodSeconds: 120
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Percent
          value: 25
          periodSeconds: 300

GPU-Cluster-Management in Produktion

GPU-Knoten-Labels und Scheduling

# gpu-node-labels.yaml
# Label GPU types
kubectl label nodes gpu-node-1 nvidia.com/gpu.product=A100-SXM4-80GB
kubectl label nodes gpu-node-2 nvidia.com/gpu.product=H100-SXM5-80GB
kubectl label nodes gpu-node-3 nvidia.com/gpu.product=L40S-48GB

# Label MIG configurations
kubectl label nodes gpu-node-1 nvidia.com/mig.config=mixed
kubectl label nodes gpu-node-2 nvidia.com/mig.config=all-3g.40gb

# Schedule to specific GPU
apiVersion: v1
kind: Pod
metadata:
  name: h100-training
spec:
  nodeSelector:
    nvidia.com/gpu.product: H100-SXM5-80GB
  containers:
    - name: training
      resources:
        limits:
          nvidia.com/gpu: 8

GPU-Fehler-Selbstheilung

# gpu-health-check.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: gpu-health-monitor
  namespace: kube-system
spec:
  selector:
    matchLabels:
      app: gpu-health-monitor
  template:
    metadata:
      labels:
        app: gpu-health-monitor
    spec:
      serviceAccountName: gpu-health-sa
      containers:
        - name: monitor
          image: custom/gpu-health-monitor:latest
          env:
            - name: CHECK_INTERVAL
              value: "60"
            - name: MEMORY_ERROR_THRESHOLD
              value: "10"
            - name: TEMPERATURE_THRESHOLD
              value: "90"
            - name: AUTO_CORDON
              value: "true"
          volumeMounts:
            - name: nvidia
              mountPath: /usr/local/nvidia
      volumes:
        - name: nvidia
          hostPath:
            path: /usr/local/nvidia

Ergebnisse der GPU-Auslastungsoptimierung

Optimierungsmaßnahme Auslastungssteigerung Kosteneinsparung
MIG-Partitionierung +35 % 30 %
Time Slicing +25 % 20 %
Prioritäts-Scheduling +15 % 15 %
Elastisches Skalieren +10 % 10 %
Kombinierte Optimierung +50 % 50 %

Zusammenfassung und Ressourcen

Wichtigste Erkenntnisse

  1. MIG-Partitionierung: Das Killer-Feature von A100/H100 — verwandelt 1 Karte in 7, die erste Wahl für Inferenz-Szenarien
  2. GPU-Sharing: Time Slicing für Inferenz, MPS für Training, MIG für gemischte Workloads
  3. Multi-Tenant-Scheduling: Das Trio aus Quotas + Prioritäten + elastischem Skalieren sichert die SLA-Einhaltung
  4. Kombinierte Optimierung: MIG + Scheduling + Skalieren gemeinsam erreichen 50 % Kosteneinsparung

Empfehlungen zur GPU-Scheduling-Lösung

Clustergröße Empfohlene Lösung Erwartete Auslastung
<8 Karten Time Slicing 60 %
8–32 Karten MIG + Time Slicing 75 %
32–128 Karten MIG + Prioritäts-Scheduling 80 %
>128 Karten Vollständiges Lösungsset 85 %+

Müssen Sie schnell cURL-Befehle generieren, um GPU-Inferenz-APIs zu testen? Nutzen Sie unser cURL-in-Code-Tool und den JSON-Formatter.

Weiterführende Literatur

Probiere diese browser-lokalen Tools aus — keine Registrierung erforderlich →

#K8s GPU scheduling#AI inference scheduling#GPU sharing#MIG partitioning#K8s AI workloads#2026