Autoscaling für LLM-Arbeitslasten auf GPUs mit Google Kubernetes Engine (GKE) konfigurieren

Autopilot Standard

Auf dieser Seite wird gezeigt, wie Sie die Autoscaling-Infrastruktur mit dem Horizontalen Pod-Autoscaler (HPA) von GKE einrichten, um das Large Language Model (LLM) Gemma mit dem Serving-Framework der Benutzeroberfläche zur Textgenerierung (TGI) von Hugging Face bereitzustellen.

Weitere Informationen zum Auswählen von Messwerten für das Autoscaling finden Sie unter Best Practices zum Autoscaling von LLM-Arbeitslasten mit GPUs in GKE.

Hinweise

Führen Sie die folgenden Schritte durch, bevor Sie beginnen:

Aktivieren Sie die Google Kubernetes Engine API.

Google Kubernetes Engine API aktivieren

Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI die compute/region- und compute/zone-Attribute fest. Durch das Festlegen von Standardspeicherorten können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden.

Machen Sie sich mit dem Workflow unter Offene Gemma-Modelle mit GPUs in GKE mit Hugging Face TGI bereitstellen vertraut.

Autoscaling mit Servermesswerten

Sie können die arbeitslastspezifischen Leistungsmesswerte verwenden, die vom TGI-Inferenzserver ausgegeben werden, um das Autoscaling für Ihre Pods weiterzuleiten. Weitere Informationen zu diesen Messwerten finden Sie unter Servermesswerte.

So richten Sie das Autoscaling anhand von benutzerdefinierten Messwerten mit Servermesswerten ein:

Exportieren Sie die Messwerte vom TGI-Server in Cloud Monitoring. Sie verwenden Google Cloud Managed Service for Prometheus, was die Bereitstellung und Konfiguration Ihres Prometheus-Collectors vereinfacht. Google Cloud Managed Service for Prometheus ist in Ihrem GKE-Cluster standardmäßig aktiviert. Sie können es auch manuell aktivieren.

Das folgende Beispielmanifest zeigt, wie Sie Ihre PodMonitoring-Ressourcendefinition so einrichten, dass Google Cloud Managed Service for Prometheus Messwerte in wiederkehrenden Intervallen von 15 Sekunden aus Ihren Pods extrahiert:
```
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: gemma-pod-monitoring
spec:
  selector:
    matchLabels:
      app: gemma-server
  endpoints:
  - port: 8000
    interval: 15s
```
Installieren Sie den Stackdriver-Adapter für benutzerdefinierte Messwerte. Mit diesem Adapter wird der benutzerdefinierte Messwert, den Sie in Monitoring exportiert haben, für den HPA-Controller sichtbar. Weitere Informationen finden Sie unter Horizontales Pod-Autoscaling in der Dokumentation zu Google Cloud Managed Service for Prometheus.

Der folgende Beispielbefehl zeigt, wie Sie den Adapter installieren:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```
Richten Sie die benutzerdefinierte messwertbasierte HPA-Ressource ein. Stellen Sie eine HPA-Ressource bereit, die auf Ihrem bevorzugten benutzerdefinierten Messwert basiert. Weitere Informationen finden Sie unter Horizontales Pod-Autoscaling in der Dokumentation zu Google Cloud Managed Service for Prometheus.

Wählen Sie einen dieser Tabs aus, um Beispiele zum Konfigurieren der Ressource HorizontalPodAutoscaler in Ihrem Manifest zu sehen:
Warteschlangengröße
In diesem Beispiel werden die TGI-Servermesswerte tgi_queue_size verwendet, die die Anzahl der Anfragen in der Warteschlange darstellen.

Informationen zum Ermitteln des richtigen Schwellenwerts für die Warteschlangengröße für HPA finden Sie unter Best Practices für das Autoscaling von LLM-Inferenzarbeitslasten mit GPUs.
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-server
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|tgi_queue_size|gauge
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET
```
Batchgröße
In diesem Beispiel wird der TGI-Servermesswert tgi_batch_size verwendet, der die Anzahl der Anfragen im aktuellen Batch darstellt.

Informationen zum Ermitteln des richtigen Schwellenwerts für die Batchgröße für HPA finden Sie unter Best Practices für das Autoscaling von LLM-Inferenzarbeitslasten mit GPUs.
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-server
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|tgi_batch_current_size|gauge
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET
```

Autoscaling mit GPU-Messwerten

Sie können die von der GPU ausgegebenen Nutzungs- und Leistungsmesswerte verwenden, um das Autoscaling für Ihre Pods auszurichten. Weitere Informationen zu diesen Messwerten finden Sie unter GPU-Messwerte.

So richten Sie das Autoscaling anhand von benutzerdefinierten Messwerten mit GPU-Messwerten ein:

Exportieren Sie die GPU-Messwerte in Cloud Monitoring. Wenn für Ihren GKE-Cluster Systemmesswerte aktiviert sind, wird der GPU-Auslastungsmesswert über den Systemmesswert container/accelerator/duty_cycle automatisch alle 60 Sekunden an Cloud Monitoring gesendet.
- Informationen zum Aktivieren von GKE-Systemmesswerten finden Sie unter Messwerterfassung konfigurieren.
- Informationen zum Einrichten der verwalteten Erfassung finden Sie unter Erste Schritte mit verwalteter Sammlung in der Dokumentation zu Google Cloud Managed Service for Prometheus.
- Weitere Techniken zum Monitoring der GPU-Arbeitslastleistung in GKE finden Sie unter GPUs in GKE-Standardknotenpools ausführen.
Das folgende Beispielmanifest zeigt, wie Sie Ihre PodMonitoring-Ressourcendefinition zum Aufnehmen von Messwerten aus der NVIDIA DCGM-Arbeitslast einrichten:
```
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: nvidia-dcgm-exporter-for-hpa
  namespace: gmp-public
  labels:
    app.kubernetes.io/name: nvidia-dcgm-exporter
    app.kubernetes.io/part-of: google-cloud-managed-prometheus
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: nvidia-dcgm-exporter
  endpoints:
    - port: metrics
      interval: 15s
      metricRelabeling:
        - action: keep
          sourceLabels: [__name__]
        - action: replace
          sourceLabels: [__name__]
          targetLabel: __name__
          regex: DCGM_FI_DEV_GPU_UTIL
          replacement: dcgm_fi_dev_gpu_util
```
Stellen Sie sicher, dass Sie im Code den DCGM-Messwertnamen zur Verwendung in HPA in Kleinbuchstaben ändern. Diese Notwendigkeit liegt daran, dass es ein bekanntes Problem gibt, bei dem HPA nicht mit externen Messwertnamen in Großbuchstaben funktioniert.
Installieren Sie den Stackdriver-Adapter für benutzerdefinierte Messwerte. Mit diesem Adapter wird der benutzerdefinierte Messwert, den Sie in Monitoring exportiert haben, für den HPA-Controller sichtbar. Weitere Informationen finden Sie unter Horizontales Pod-Autoscaling in der Dokumentation zu Google Cloud Managed Service for Prometheus.

Der folgende Beispielbefehl zeigt, wie diese Installation ausgeführt wird:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```

Richten Sie die benutzerdefinierte messwertbasierte HPA-Ressource ein. Stellen Sie eine HPA-Ressource basierend auf Ihrem bevorzugten benutzerdefinierten Messwert bereit. Weitere Informationen finden Sie unter Horizontales Pod-Autoscaling in der Dokumentation zu Google Cloud Managed Service for Prometheus.

Bestimmen Sie ein durchschnittliches Wertziel für HPA, um das Autoscaling auszulösen. Sie können dies experimentell tun. Generieren Sie beispielsweise eine zunehmende Last auf Ihrem Server und beobachten Sie, wo die GPU-Auslastung Spitzen aufweist. Achten Sie auf die HPA-Toleranz, die standardmäßig bei einem Nicht-Aktionsbereich von 0,1 um den Zielwert liegt, um Schwankungen zu dämpfene.
Wir empfehlen die Verwendung des Lokust-Last-Inferenz-Tools zum Testen. Sie können auch ein benutzerdefiniertes Dashboard für Cloud Monitoring erstellen, um das Messwertverhalten zu visualisieren.

Wählen Sie einen dieser Tabs aus, um ein Beispiel für die Konfiguration der Ressource HorizontalPodAutoscaler in Ihrem Manifest zu sehen:

Arbeitszyklus (GKE-System)

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: External
    external:
      metric:
        name: kubernetes.io|container|accelerator|duty_cycle
        selector:
          matchLabels:
            resource.labels.container_name: inference-server
            resource.labels.namespace_name: default
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET

Arbeitszyklus (DCGM)

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: External
    external:
      metric:
        name: prometheus.googleapis.com|dcgm_fi_dev_gpu_util|unknown
        selector:
          matchLabels:
            metric.labels.exported_container: inference-server
            metric.labels.exported_namespace: default
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET

Nächste Schritte

Pod-Autoscaling anhand von Messwerten aus Cloud Monitoring optimieren
Weitere Informationen über horizontales Pod-Autoscaling finden Sie in der Open-Source-Dokumentation zu Kubernetes.