Einige oder alle Informationen auf dieser Seite gelten möglicherweise nicht für Cloud de Confiance von S3NS. Weitere Informationen finden Sie unter Unterschiede zu Google Cloud.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

LLMs in GKE mit einer kostenoptimierten und hochverfügbaren GPU-Bereitstellungsstrategie bereitstellen

Autopilot Standard

In diesem Leitfaden erfahren Sie, wie Sie die Kosten für LLM-Serving-Arbeitslasten in GKE optimieren. In dieser Anleitung wird eine Kombination aus Flex-Start-VMs, Spot-VMs und Compute-Klassen für kostengünstige Inferenz verwendet.

In dieser Anleitung wird Mixtral 8x7b als Beispiel-LLM verwendet, das Sie bereitstellen können.

Dieser Leitfaden richtet sich an Machine Learning-Entwickler, Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die daran interessiert sind, Funktionen zur Kubernetes-Containerorchestrierung für die Bereitstellung von LLMs zu nutzen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in Cloud de Confiance by S3NS Inhalten verweisen, finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.

Flex-Start-Preise

Flex-Start wird empfohlen, wenn für Ihre Arbeitslast Ressourcen benötigt werden, die nach Bedarf für bis zu sieben Tage mit kurzfristigen Reservierungen dynamisch bereitgestellt werden, keine komplexe Kontingentverwaltung erforderlich ist und ein kostengünstiger Zugriff möglich sein soll. Flex-Start basiert auf dem Dynamic Workload Scheduler und wird gemäß der Preisgestaltung des Dynamic Workload Schedulers abgerechnet:

Sie können einen Rabatt (bis zu 53%) für vCPUs, GPUs, TPUs und alle angehängten lokalen SSD-Laufwerke erhalten.
Sie zahlen nach dem Pay-as-you-go-Modell (PAYG).

Hintergrund

In diesem Abschnitt werden die verfügbaren Funktionen beschrieben, mit denen Sie basierend auf den Anforderungen Ihrer KI-/ML-Arbeitslasten Rechenressourcen wie GPUs oder TPUs erhalten können. Mit diesen Funktionen können Sie Strategien implementieren, um die Flexibilität, Effizienz und Verfügbarkeit Ihrer Rechenkapazität zu maximieren.

GPUs

Mit Grafikprozessoren (GPUs) können Sie bestimmte Arbeitslasten wie maschinelles Lernen und Datenverarbeitung beschleunigen. GKE bietet Knoten, die mit diesen leistungsstarken GPUs ausgestattet sind, um die Leistung von Aufgaben für maschinelles Lernen und Datenverarbeitung zu optimieren. GKE bietet eine Reihe von Maschinentypoptionen für die Knotenkonfiguration, einschließlich Maschinentypen mit NVIDIA H100-, A100- und L4-GPUs.

Weitere Informationen finden Sie unter GPUs in GKE.

Flex-Start

Flex-Start, basierend auf dem Dynamic Workload Scheduler, ist eine Option für die GPU-Nutzung, bei der GKE Ihre GPU-Anfrage beibehält und automatisch Flex-Start-VMs bereitstellt, wenn Kapazität verfügbar wird. Erwägen Sie die Verwendung von Flex-Start für Arbeitslasten, die für einen begrenzten Zeitraum von bis zu sieben Tagen GPU-Kapazität benötigen und kein festes Startdatum haben. Weitere Informationen finden Sie unter flex-start.

Spot-VMs

Sie können GPUs mit Spot-VMs verwenden, wenn Ihre Arbeitslasten häufige Knotenunterbrechungen tolerieren können. Bei Verwendung von Spot-VMs oder Flex-Start-VMs reduziert sich der Preis für die Ausführung von GPUs. Die Verwendung von Spot-VMs in Kombination mit Flex-Start bietet eine Fallback-Option, wenn die Spot-VM-Kapazität nicht verfügbar ist.

Weitere Informationen finden Sie unter Spot-VMs mit GPU-Knotenpools verwenden.

ComputeClasses

Sie können GPUs mit ComputeClasses anfordern. Mit Compute-Klassen können Sie eine Hierarchie von Knotenkonfigurationen definieren, die GKE bei Entscheidungen zur Knotenskalierung priorisieren soll, damit Arbeitslasten auf der von Ihnen ausgewählten Hardware ausgeführt werden. Weitere Informationen finden Sie unter Benutzerdefinierte Compute-Klassen.

Hinweis

In the Cloud de Confiance console, on the project selector page, select or create a Cloud de Confiance project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Cloud de Confiance project.

Sie benötigen einen GKE Autopilot- oder Standardcluster mit Version 1.32.2-gke.1652000 oder höher. In Ihrem Cluster muss die automatische Knotenbereitstellung aktiviert und GPU-Limits konfiguriert sein.
Erstellen Sie ein Hugging Face-Konto, falls Sie noch keines haben.
Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für NVIDIA L4-GPUs auf Abruf hat. Weitere Informationen finden Sie unter Kontingente für Ressourcen auf Abruf.

Zugriff auf das Modell erhalten

Generieren Sie ein neues Hugging Face-Token, falls Sie noch keines haben:

Klicken Sie auf Profil > Einstellungen > Zugriffstokens.
Wählen Sie Neues Token aus.
Geben Sie einen Namen Ihrer Wahl und eine Rolle von mindestens Read an.
Wählen Sie Token generieren aus.

ComputeClass erstellen

In diesem Abschnitt erstellen Sie eine benutzerdefinierte ComputeClass. ComputeClasses definieren die Typen und Beziehungen zwischen mehreren Rechenressourcen, die von Ihrer Arbeitslast verwendet werden.

Starten Sie in der Cloud de Confiance Console eine Cloud Shell-Sitzung. Klicken Sie dazu in der Cloud de Confiance Console auf Cloud Shell aktivieren. Im unteren Bereich der Cloud de Confiance Console wird eine Sitzung geöffnet.

dws-flex-start.yaml-Manifestdatei erstellen:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: dws-model-inference-class
spec:
  priorities:
    - machineType: g2-standard-24
      spot: true
    - machineType: g2-standard-24
      flexStart:
        enabled: true
        nodeRecycling:
          leadTimeSeconds: 3600
  nodePoolAutoCreation:
    enabled: true

Wenden Sie das dws-flex-start.yaml-Manifest an:
```
kubectl apply -f dws-flex-start.yaml
```

GKE stellt g2-standard-24-Maschinen mit L4-Beschleunigern bereit. GKE verwendet ComputeClasses, um Spot-VMs zu priorisieren und Flex-Start-VMs an zweiter Stelle zu platzieren.

LLM-Arbeitslast bereitstellen

Erstellen Sie mit dem folgenden Befehl ein Kubernetes-Secret, das das Hugging Face-Token enthält:

kubectl create secret generic model-inference-secret \
    --from-literal=HUGGING_FACE_TOKEN=HUGGING_FACE_TOKEN \
    --dry-run=client -o yaml | kubectl apply -f -

Ersetzen Sie HUGGING_FACE_TOKEN durch Ihr Hugging Face-Zugriffstoken.

Erstellen Sie eine Datei mit dem Namen mixtral-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: inference-mixtral-ccc
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llm
  template:
    metadata:
      labels:
        app: llm
    spec:
      nodeSelector:
        cloud.google.com/compute-class: dws-model-inference-class
      containers:
      - name: llm
        image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311
        resources:
          requests:
            cpu: "5"
            memory: "40Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "5"
            memory: "40Gi"
            nvidia.com/gpu: "2"
        env:
        - name: MODEL_ID
          value: mistralai/Mixtral-8x7B-Instruct-v0.1
        - name: NUM_SHARD
          value: "2"
        - name: PORT
          value: "8080"
        - name: QUANTIZE
          value: bitsandbytes-nf4
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: model-inference-secret
              key: HUGGING_FACE_TOKEN
        volumeMounts:
          - mountPath: /dev/shm
            name: dshm
          - mountPath: /tmp
            name: ephemeral-volume
      volumes:
        - name: dshm
          emptyDir:
              medium: Memory
        - name: ephemeral-volume
          ephemeral:
            volumeClaimTemplate:
              metadata:
                labels:
                  type: ephemeral
              spec:
                accessModes: ["ReadWriteOnce"]
                storageClassName: "premium-rwo"
                resources:
                  requests:
                    storage: 100Gi

In diesem Manifest ist das Feld mountPath auf /tmp festgelegt, da dies der Pfad ist, auf den die Umgebungsvariable HF_HOME im Deep Learning Container (DLC) für Text Generation Inference (TGI) festgelegt ist. Dies ist nicht der Standardpfad /data, der im TGI-Standard-Image festgelegt ist. Das heruntergeladene Modell wird in diesem Verzeichnis gespeichert.

Modell bereitstellen:
```
kubectl apply -f  mixtral-deployment.yaml
```
GKE plant einen neuen Pod für die Bereitstellung, wodurch der Autoscaler für Knotenpools einen zweiten Knoten hinzufügt, bevor er das zweite Replikat des Modells bereitstellt.

Prüfen Sie den Status des Modells:

watch kubectl get deploy inference-mixtral-ccc

Wenn das Modell erfolgreich bereitgestellt wurde, sieht die Ausgabe in etwa so aus:

NAME                   READY   UP-TO-DATE   AVAILABLE   AGE
inference-mixtral-ccc  1/1     1            1           10m

Drücken Sie CTRL + C, um die Smartwatch zu beenden.

Warten Sie, bis der Container heruntergeladen wurde und das Modell bereitstellt:
```
watch "kubectl logs $(kubectl get pods -l app=llm -o custom-columns=:metadata.name --no-headers) | tail"
```
Drücken Sie CTRL + C, um die Smartwatch zu beenden.

Hinweis :Wenn Sie anstelle von Downloadprotokollen HTTP-Statuscodes 403 Forbidden sehen, müssen Sie möglicherweise das Mixtral 8x7b-Repository auf Hugging Face aufrufen und die Einwilligungserklärung unterzeichnen.

Knotenpools ansehen, die von GKE bereitgestellt wurden:

kubectl get nodes -L cloud.google.com/gke-nodepool

Die Ausgabe sieht etwa so aus:

  NAME                                                  STATUS   ROLES    AGE   VERSION               GKE-NODEPOOL
  gke-flex-na-nap-g2-standard--0723b782-fg7v   Ready    <none>   10m   v1.32.3-gke.1152000   nap-g2-standard-24-spot-gpu2-1gbdlbxz
  gke-flex-nap-zo-default-pool-09f6fe53-fzm8   Ready    <none>   32m   v1.32.3-gke.1152000   default-pool
  gke-flex-nap-zo-default-pool-09f6fe53-lv2v   Ready    <none>   32m   v1.32.3-gke.1152000   default-pool
  gke-flex-nap-zo-default-pool-09f6fe53-pq6m   Ready    <none>   32m   v1.32.3-gke.1152000   default-pool

Der Name des erstellten Knotenpools gibt den Maschinentyp an. In diesem Fall hat GKE Spot-VMs bereitgestellt.

Modell verfügbar machen:
```
kubectl expose deployment/inference-mixtral-ccc --port 8080 --name=llm-service
```
Erfolg: Sie haben eine LLM mithilfe einer Kombination aus Flex-Start-VMs, Spot-VMs und Compute-Klassen bereitgestellt, um die GPU-Bereitstellung und die Kosten zu optimieren. Sie können jetzt mit dem Modell interagieren.

Mit dem Modell über `curl` interagieren

In diesem Abschnitt wird gezeigt, wie Sie einen einfachen Inferenztest durchführen können, um Ihr bereitgestelltes Modell zu prüfen.

Richten Sie die Portweiterleitung zum Modell ein:

kubectl port-forward service/llm-service 8080:8080

Die Ausgabe sieht etwa so aus:

Forwarding from 127.0.0.1:8080 -> 8080

Chatten Sie in einer neuen Terminalsitzung mit Ihrem Modell, indem Sie curl verwenden:

curl http://localhost:8080/v1/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
    "model": "mixtral-8x7b-instruct-gptq",
    "prompt": "<s>[INST]Who was the first president of the United States?[/INST]",
    "max_tokens": 40}'

Die Ausgabe sieht dann ungefähr so aus:

George Washington was a Founding Father and the first president of the United States, serving from 1789 to 1797.

Bereinigen

Damit Ihrem Cloud de Confiance by S3NS -Konto die auf dieser Seite verwendeten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder das Projekt löschen, das die Ressourcen enthält, oder das Projekt beibehalten und die einzelnen Ressourcen löschen.

Projekt löschen

Wechseln Sie in der Cloud de Confiance -Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Einzelne Ressource löschen

Löschen Sie die Kubernetes-Ressourcen, die Sie anhand dieser Anleitung erstellt haben:

kubectl delete deployment inference-mixtral-ccc
kubectl delete service llm-service
kubectl delete computeclass dws-model-inference-class
kubectl delete secret model-inference-secret

Löschen Sie den Cluster:

gcloud container clusters delete CLUSTER_NAME