GPU-Zeitscheiben für gleichzeitige LLM-Agenten auf Kubernetes

GPU-Zeitscheibenverfahren für gleichzeitige LLM-Agenten auf Kubernetes

Large Language Model (LLM)-Agenten revolutionieren die Art und Weise, wie Unternehmen Reasoning, Retrieval und Entscheidungsfindung automatisieren. Die gleichzeitige Ausführung mehrerer LLM-Agenten auf Kubernetes stellt jedoch eine grundlegende Herausforderung dar: GPUs sind teuer, knapp und werden traditionell mit einem Pod pro GPU zugewiesen. Das GPU-Zeitscheibenverfahren löst diesen Engpass, indem es mehreren Workloads ermöglicht, eine einzelne GPU gemeinsam zu nutzen, wodurch die Auslastung drastisch verbessert und die Kosten gesenkt werden. Dieser Artikel bietet eine praktische Schritt-für-Schritt-Anleitung zur Konfiguration des GPU-Zeitscheibenverfahrens auf Kubernetes für gleichzeitige LLM-Agenten-Bereitstellungen.

Was ist das GPU-Zeitscheibenverfahren?

Das GPU-Zeitscheibenverfahren ist ein Kubernetes-nativer Mechanismus, der eine einzelne physische GPU in mehrere virtuelle Geräte aufteilt. Jedes virtuelle Gerät wird einem Pod so präsentiert, als wäre es eine dedizierte GPU, aber die zugrundeliegende Hardware verarbeitet Workloads in schnellen Round-Robin-Zeitscheiben. Dieser Ansatz unterscheidet sich von der GPU-Partitionierung (MIG), die Speicher und Rechenleistung physisch isoliert. Das Zeitscheibenverfahren teilt Speicher- und Rechenressourcen, verursacht jedoch nur minimalen Overhead für Inferenz-Workloads, was es ideal für LLM-Agenten macht, die die meiste Zeit auf Netzwerkaufrufe oder Token-Generierung warten.

Der entscheidende Kompromiss ist die vorhersagbare Leistung: Wenn zwei Agent-Pods versuchen, die GPU gleichzeitig auszulasten, wird jeder einen reduzierten Durchsatz erfahren. Für interaktive LLM-Agenten mit burstartigen Inferenzmustern liefert das Zeitscheibenverfahren jedoch oft eine nahezu native Latenz, während die Anzahl der gleichzeitigen Agenten pro GPU vervierfacht oder mehr wird.

Voraussetzungen

Stellen Sie vor der Implementierung des GPU-Zeitscheibenverfahrens sicher, dass Ihre Umgebung diese Voraussetzungen erfüllt:

• **Kubernetes-Cluster** Version 1.24 oder höher (getestet mit 1.27+)
• **NVIDIA GPU Operator** installiert (Version 23.6.0 oder neuer empfohlen)
• **NVIDIA-Treiber** Version 525 oder höher (unterstützt Zeitscheibenverfahren)
• **GPU-Hardware**: Jede NVIDIA-GPU mit Compute Capability 7.0+ (Volta, Turing, Ampere, Hopper)
• **LLM-Agent-Framework**: Jeder containerisierte Agent (z. B. LangChain, LlamaIndex, benutzerdefinierter Python-Dienst), der ein LLM über API oder lokales Modell aufruft
• **Helm** (zur Installation des GPU-Operators)
• **kubectl** mit Cluster-Admin-Rechten konfiguriert

> **Hinweis**: Das Zeitscheibenverfahren eignet sich am besten für Inferenz-Workloads. Verwenden Sie für Training MIG oder dedizierte GPUs.

Schritt-für-Schritt-Installation

1. Installieren Sie den NVIDIA GPU Operator

Der GPU-Operator verwaltet GPU-Treiber, Geräte-Plugins und Überwachung. Installieren Sie ihn über Helm:

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update
helm install gpu-operator nvidia/gpu-operator --namespace nvidia-gpu-operator --create-namespace

Dieser Befehl fügt das NVIDIA-Helm-Repository hinzu, aktualisiert den lokalen Cache und installiert den Operator in einem dedizierten Namespace. Warten Sie, bis alle Pods bereit sind:

kubectl wait --for=condition=ready pod --all -n nvidia-gpu-operator --timeout=300s

2. Überprüfen Sie die GPU-Erkennung

Bestätigen Sie, dass der Cluster Ihre GPU-Knoten sieht:

kubectl get nodes -o json | jq '.items[].status.allocatable | with_entries(select(.key | startswith("nvidia.com/gpu")))'

Sie sollten eine Ausgabe wie `"nvidia.com/gpu": "1"` für jeden GPU-Knoten sehen.

3. Erstellen Sie ein ConfigMap für das Zeitscheibenverfahren

Das NVIDIA-Geräte-Plugin verwendet ein `ConfigMap`, um Profile für das Zeitscheibenverfahren zu definieren. Erstellen Sie eine Datei namens `time-slicing-config.yaml`:

apiVersion: v1
kind: ConfigMap
metadata:
  name: time-slicing-config
  namespace: nvidia-gpu-operator
data:
  default: |-
    version: v1
    sharing:
      timeSlicing:
        resources:
        - name: nvidia.com/gpu
          replicas: 4

Diese Konfiguration deklariert, dass jede physische GPU als 4 virtuelle GPUs erscheinen soll. Passen Sie `replicas` basierend auf Ihrem Workload an (4–8 sind üblich für LLM-Agenten).

Wenden Sie das ConfigMap an:

kubectl apply -f time-slicing-config.yaml

4. Konfigurieren Sie die ClusterPolicy für das Zeitscheibenverfahren

Die `ClusterPolicy`-Ressource des GPU-Operators steuert die Einstellungen des Geräte-Plugins. Patchen Sie sie, um das Zeitscheibenverfahren zu aktivieren:

kubectl patch clusterpolicy gpu-cluster-policy -n nvidia-gpu-operator --type='json' -p='[{"op": "replace", "path": "/spec/devicePlugin/config", "value": {"name": "time-slicing-config", "default": "default"}}]'

Dies teilt dem Geräte-Plugin mit, das von uns erstellte ConfigMap zu verwenden. Wenn Ihre ClusterPolicy einen anderen Namen hat (überprüfen Sie mit `kubectl get clusterpolicy -n nvidia-gpu-operator`), passen Sie dies entsprechend an.

5. Starten Sie das DaemonSet des Geräte-Plugins neu

Zwingen Sie das Geräte-Plugin, seine Konfiguration neu zu laden:

kubectl rollout restart daemonset nvidia-device-plugin-daemonset -n nvidia-gpu-operator

Warten Sie, bis der Neustart abgeschlossen ist:

kubectl rollout status daemonset nvidia-device-plugin-daemonset -n nvidia-gpu-operator

6. Überprüfen Sie die virtuellen GPUs

Jetzt sollte jeder GPU-Knoten mehrere `nvidia.com/gpu`-Ressourcen melden:

kubectl get nodes -o json | jq '.items[].status.allocatable | with_entries(select(.key | startswith("nvidia.com/gpu")))'

Erwartete Ausgabe: `"nvidia.com/gpu": "4"` (oder die von Ihnen eingestellten Replikate).

Anwendungsbeispiele

Beispiel 1: Bereitstellung von zwei gleichzeitigen LLM-Agent-Pods

Erstellen Sie ein Deployment, das 1 virtuelle GPU pro Pod anfordert:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm-agent
spec:
  replicas: 2
  selector:
    matchLabels:
      app: llm-agent
  template:
    metadata:
      labels:
        app: llm-agent
    spec:
      containers:
      - name: agent
        image: your-llm-agent:latest
        resources:
          limits:
            nvidia.com/gpu: 1
        env:
        - name: NVIDIA_VISIBLE_DEVICES
          value: "all"

Wenden Sie das Deployment an:

kubectl apply -f llm-agent-deployment.yaml

Beide Pods werden auf demselben GPU-Knoten ausgeführt, wobei jeder eine virtuelle GPU erhält. Überprüfen Sie, ob sie die GPU gemeinsam nutzen:

kubectl get pods -o wide | grep llm-agent
kubectl exec <pod-name> -- nvidia-smi

Jeder Pod sieht in `nvidia-smi` eine vollständige GPU, aber der Treiber sorgt für eine faire Zeitscheibenzuteilung.

Beispiel 2: Überwachung der GPU-Auslastung mit Prometheus

Installieren Sie den NVIDIA DCGM-Exporter für Echtzeitmetriken:

helm install dcgm-exporter nvidia/dcgm-exporter --namespace nvidia-gpu-operator

Leiten Sie den Metrik-Port weiter:

kubectl port-forward -n nvidia-gpu-operator service/dcgm-exporter 9400:9400 &

Fragen Sie die GPU-Auslastung ab:

curl http://localhost:9400/metrics | grep -E "DCGM_FI_DEV_GPU_UTIL|DCGM_FI_DEV_MEM_COPY_UTIL"

Sie sehen Auslastungswerte für die physische GPU, die über alle Zeitscheiben-Pods hinweg gemeinsam genutzt wird.

Beispiel 3: Python-LLM-Agent, der GPU verwendet

Ein minimaler LangChain-Agent, der ein lokales LLM aufruft (z. B. Llama 2 über Ollama), könnte so aussehen:

import os
from langchain.llms import Ollama
from langchain.agents import initialize_agent, Tool
from langchain.tools import tool

@tool
def get_current_time() -> str:
    """Returns the current time."""
    from datetime import datetime
    return datetime.now().isoformat()

llm = Ollama(model="llama2", temperature=0.1)
tools = [get_current_time]
agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)

result = agent.run("What time is it?")
print(result)

Containerisieren Sie dieses Skript und stellen Sie es auf Kubernetes mit `nvidia.com/gpu: 1` in den Ressourcenlimits bereit. Die Zeitscheibenkonfiguration stellt sicher, dass mehrere solcher Agenten auf einer GPU koexistieren können.

Optimierung und bewährte Verfahren

Passen Sie die Replikatanzahl basierend auf dem Workload an

Für LLM-Agenten mit niedrigen Anforderungsraten (z. B. 1–5 Abfragen pro Minute pro Agent) sind 8 Replikate pro GPU sicher. Für hochfrequente Agenten beginnen Sie mit 4 und überwachen Sie die GPU-Auslastung:

kubectl exec -n nvidia-gpu-operator daemonset/nvidia-device-plugin-daemonset -- nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv

Wenn die Auslastung 90 % übersteigt, reduzieren Sie die Replikate.

Kombinieren Sie mit dem Horizontal Pod Autoscaler

Das GPU-Zeitscheibenverfahren lässt sich gut mit HPA basierend auf benutzerdefinierten Metriken kombinieren. Skalieren Sie Agenten beispielsweise basierend auf der durchschnittlichen GPU-Auslastung:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: llm-agent-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: llm-agent
  minReplicas: 1
  maxReplicas: 8
  metrics:
  - type: Pods
    pods:
      metric:
        name: gpu_utilization
      target:
        type: AverageValue
        averageValue: 50

Umgang mit Speicherkonflikten

Das Zeitscheibenverfahren teilt den GPU-Speicher. Wenn Ihr LLM-Modell 8 GB benötigt, stellen Sie sicher, dass der gesamte Speicher aller gleichzeitigen Agenten den verfügbaren Speicher nicht überschreitet. Verwenden Sie `nvidia-smi`, um die Speichernutzung zu überprüfen, und begrenzen Sie die `replicas` entsprechend.

Fazit

Das GPU-Zeitscheibenverfahren ermöglicht es Kubernetes-Clustern, mehrere LLM-Agenten gleichzeitig auf einer einzelnen GPU auszuführen, wodurch die Hardwareauslastung maximiert und die Infrastrukturkosten gesenkt werden. Indem Sie den Schritten in dieser Anleitung folgen – Installation des NVIDIA GPU-Operators, Erstellen eines ConfigMap für das Zeitscheibenverfahren und Konfigurieren des Geräte-Plugins – können Sie eine einzelne GPU in eine gemeinsam genutzte Ressource für 4–8 gleichzeitige Inferenz-Workloads verwandeln. Dieser Ansatz ist besonders wertvoll für Produktionssysteme, die viele interaktive LLM-Agenten bedienen, bei denen burstartige Verkehrsmuster das Zeitscheibenverfahren zu einer effizienten und praktischen Lösung machen. Wie in aktuellen Branchendiskussionen von Quellen wie OpenAI und Microsoft festgestellt, ist die effiziente GPU-Freigabe ein wichtiger Wegbereiter für skalierbare KI-Bereitstellungen. Beginnen Sie mit 4 Replikaten pro GPU, überwachen Sie die Auslastung und passen Sie sie an die Parallelitätsanforderungen Ihres Agenten an. Ihre LLM-Agenten – und Ihr Budget – werden es Ihnen danken.