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

vLLM in GKE verwenden, um Inferenzen mit gpt-oss-120b auszuführen

Geclusterte GPUs

In dieser Anleitung wird gezeigt, wie Sie ein gpt-oss-120b-Language Model mit dem vLLM-Framework bereitstellen und verfügbar machen. Sie stellen dieses Modell in einem Google Kubernetes Engine-Autopilot-Cluster (GKE) bereit und verwenden eine einzelne virtuelle A4-Maschine (VM) mit 8 B200-GPUs.

Diese Anleitung richtet sich an ML-Entwickler, Plattformadministratoren und -operatoren sowie Daten- und KI-Spezialisten, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen für die Verarbeitung von Inferenzarbeitslasten zu verwenden.

Ziele

Greifen Sie über Hugging Face auf gpt-oss-120b zu.
Bereiten Sie Ihre Umgebung vor.
Erstellen Sie einen GKE-Cluster im Autopilot-Modus.
Erstellen Sie ein Kubernetes-Secret für Hugging Face-Anmeldedaten.
Cloud Storage-Bucket erstellen
Laden Sie das Modell in Ihren Cloud Storage-Bucket herunter.
Stellen Sie einen vLLM-Container in Ihrem GKE-Cluster bereit.
Mithilfe von curl mit dem Language Model gpt-oss interagieren.
bereinigen.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloudverwendet, darunter:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Hinweis

Installieren Sie die Google Cloud CLI.
Konfigurieren Sie die gcloud CLI für die Verwendung Ihrer föderierten Identität.

Weitere Informationen finden Sie unter Mit Ihrer föderierten Identität in der gcloud CLI anmelden.
Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:
```
gcloud init
```
Google Cloud -Projekt erstellen oder auswählen.
Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts
- Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
- Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Project Creator“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Informationen zum Zuweisen von Rollen
Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.
- Erstellen Sie ein Projekt in Google Cloud :
```
gcloud projects create PROJECT_ID
```
  Ersetzen Sie PROJECT_ID durch einen Namen für das Projekt in Google Cloud , das Sie erstellen.
- Wählen Sie das von Ihnen erstellte Projekt in Google Cloud aus:
```
gcloud config set project PROJECT_ID
```
  Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .
Prüfen Sie, ob die Abrechnung für Ihr Google Cloud -Projekt aktiviert ist.
Aktivieren Sie die erforderliche API, falls sie noch nicht aktiviert ist:
Erforderliche Rollen zum Aktivieren von APIs
Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Inhaberrolle (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen
```
gcloud services enable container.googleapis.com
```

Weisen Sie Ihrem Nutzerkonto Rollen zu. Führen Sie den folgenden Befehl für jede der folgenden IAM-Rollen einmal aus: roles/container.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Ersetzen Sie Folgendes:
- PROJECT_ID: Ihre Projekt-ID.
- USER_IDENTIFIER: Die Kennung für Ihr Nutzerkonto. -Konto. Beispiele finden Sie unter Workforce-Pool-Nutzer in IAM-Richtlinien darstellen.
- ROLE: Die IAM-Rolle, die Sie Ihrem Nutzerkonto zuweisen.
Melden Sie sich in einem Hugging Face-Konto an oder erstellen Sie eines.

Über Hugging Face auf gpt-oss zugreifen

So greifen Sie mit Hugging Face auf gpt-oss zu:

Melden Sie sich bei Hugging Face an und sehen Sie sich das gpt-oss-Modell an.
Erstellen Sie ein Hugging Face-read-Zugriffstoken.
Kopieren und speichern Sie den read access-Tokenwert. Sie benötigen sie später in dieser Anleitung.

Umgebung vorbereiten

Legen Sie die Standardumgebungsvariablen fest, um Ihre Umgebung vorzubereiten:

export PROJECT_ID="YOUR_PROJECT_ID"
export RESERVATION_URL="YOUR_RESERVATION_NAME"
export REGION="YOUR_REGION"
export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export GCS_BUCKET="YOUR_GCS_BUCKET"
export HUGGING_FACE_TOKEN="YOUR_HF_TOKEN"
export NETWORK="YOUR_NETWORK_NAME"
export SUBNETWORK="YOUR_SUBNETWORK_NAME"
export PROJECT_NUMBER=$(gcloud projects describe "${PROJECT_ID}" --format="value(projectNumber)")

gcloud config set project "${PROJECT_ID}"
gcloud config set billing/quota_project "${PROJECT_ID}"

Ersetzen Sie Folgendes:

YOUR_PROJECT_ID: die ID des Google Cloud -Projekts, in dem Sie den GKE-Cluster erstellen möchten.
YOUR_RESERVATION_NAME: die URL der Reservierung, die Sie zum Erstellen Ihres GKE-Cluster verwenden möchten. Geben Sie je nach Projekt, in dem sich die Reservierung befindet, einen der folgenden Werte an:
- Die Reservierung ist in Ihrem Projekt vorhanden: RESERVATION_NAME
- Die Reservierung befindet sich in einem anderen Projekt und Ihr Projekt kann die Reservierung verwenden: projects/RESERVATION_PROJECT_ID/reservations/RESERVATION_NAME
YOUR_REGION: die Region, in der Sie Ihren GKE-Cluster erstellen möchten. Sie können den Cluster nur in der Region erstellen, in der sich Ihre Reservierung befindet.
YOUR_CLUSTER_NAME: der Name des zu erstellenden GKE-Cluster.
YOUR_GCS_BUCKET: der Name des Cloud Storage-Bucket, in den Sie das Modell herunterladen.
YOUR_HF_TOKEN: Das Hugging Face-Zugriffstoken, das Sie im vorherigen Abschnitt erstellt haben.
YOUR_NETWORK_NAME: das Netzwerk, das der GKE-Cluster verwendet. Geben Sie einen der folgenden Werte an:
- Wenn Sie ein benutzerdefiniertes Netzwerk erstellt haben, geben Sie den Namen Ihres Netzwerks an.
- Geben Sie andernfalls default an.
YOUR_SUBNETWORK_NAME: das Subnetzwerk, das der GKE-Cluster verwendet. Geben Sie einen der folgenden Werte an:
- Wenn Sie ein benutzerdefiniertes Subnetzwerk erstellt haben, geben Sie den Namen Ihres Subnetzwerks an. Sie können nur ein Subnetzwerk angeben, das sich in derselben Region wie die Reservierung befindet.
- Geben Sie andernfalls default an.

GKE-Cluster im Autopilot-Modus erstellen

Führen Sie den folgenden Befehl aus, um einen GKE-Cluster im Autopilot-Modus zu erstellen:

gcloud container clusters create-auto $CLUSTER_NAME \
    --project=$PROJECT_ID \
    --region=$REGION \
    --release-channel=rapid \
    --network=$NETWORK \
    --subnetwork=$SUBNETWORK

Das Erstellen des GKE-Cluster kann einige Zeit dauern. Wenn Sie prüfen möchten, ob Google Cloud die Erstellung des Clusters abgeschlossen hat, rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster auf.

Kubernetes-Secret für Hugging Face-Anmeldedaten erstellen

So erstellen Sie ein Kubernetes-Secret für Hugging Face-Anmeldedaten:

Konfigurieren Sie kubectl für die Kommunikation mit Ihrem GKE-Cluster:

gcloud container clusters get-credentials $CLUSTER_NAME \
    --location=$REGION

Erstellen Sie ein Kubernetes-Secret, um Ihr Hugging Face-Token zu speichern:

kubectl create secret generic hf-secret \
    --from-literal=hf_token=${HUGGING_FACE_TOKEN} \
    --dry-run=client -o yaml | kubectl apply -f -

Cloud Storage-Bucket erstellen

Wenn Sie einen vorhandenen Cloud Storage-Bucket verwenden, muss Folgendes zutreffen:

Ihr Cloud Storage-Bucket befindet sich in derselben Region wie Ihr GKE-Cluster.
Ihr Dienstkonto hat die erforderlichen write-Berechtigungen für den Bucket.

So speichern Sie Ihr Modell in einem neuen Cloud Storage-Bucket:

Führen Sie den folgenden Befehl aus, um einen Bucket zu erstellen:

gcloud storage buckets create gs://$GCS_BUCKET --location=$REGION --uniform-bucket-level-access

Gewähren Sie dem Standarddienstkonto die Berechtigungen write für den Cloud Storage-Bucket.

gcloud storage buckets add-iam-policy-binding gs://$GCS_BUCKET \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/default" \
    --role="roles/storage.objectAdmin"

Modell in Ihren Cloud Storage-Bucket herunterladen

Führen Sie die folgenden Schritte aus, um das Modell in Ihren Cloud Storage-Bucket herunterzuladen:

gpt-download-job.yaml-Datei erstellen:

apiVersion: batch/v1
kind: Job
metadata:
  name: gpt-download-job
  namespace: default
spec:
  template:
    metadata:
      labels:
        app: gpt-oss-downloader
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      restartPolicy: OnFailure
      containers:
      - name: downloader
        image: python:3.11-slim
        resources:
          requests:
            cpu: "4"
            memory: "16Gi"
          limits:
            cpu: "4"
            memory: "16Gi"
        env:
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        - name: HF_HUB_ENABLE_HF_TRANSFER
          value: "0"
        - name: HF_HOME
          value: "/tmp/hf_cache"
        command: ["/bin/sh", "-c"]
        args:
        - |
          echo "Installing Hugging Face Hub library..."
          pip install -U "huggingface_hub"

          echo "Beginning model snapshot download to GCS Fuse..."
          hf download openai/gpt-oss-120b \
            --token "$HUGGING_FACE_HUB_TOKEN" \
            --local-dir /mnt/gcs/gpt-oss-120b \
            --max-workers 1

          DOWNLOAD_STATUS=$?

          if [ $DOWNLOAD_STATUS -eq 0 ]; then
            echo "Download Complete!"
          else 
            echo "ERROR: Model download failed with exit code $DOWNLOAD_STATUS"
            exit $DOWNLOAD_STATUS
          fi

        volumeMounts:
        - mountPath: /mnt/gcs
          name: gcs-bucket-volume
      volumes:
      - name: gcs-bucket-volume
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: $GCS_BUCKET
            mountOptions: "implicit-dirs"

Wenden Sie das Manifest gpt-download-job.yaml an, um den Downloadjob zu initialisieren.
```
envsubst '$GCS_BUCKET' < gpt-download-job.yaml | kubectl apply -f -
```
Die Jobressource lädt die gpt-oss-120b-Modellgewichtungen von Hugging Face in Ihren Cloud Storage-Bucket herunter. Der Download dauert etwa 30 Minuten. Fahren Sie nach Abschluss des Downloads mit dem nächsten Abschnitt fort, um die Modellbereitstellung zu starten.
Führen Sie den folgenden Befehl aus, um den Abschlussstatus aufzurufen:
```
kubectl wait \
    --for=condition=Complete \
    --timeout=7200s job/gpt-download-job
```
Das Flag --timeout gibt an, wie lange der Befehl den Job überwacht, bevor ein Zeitüberschreitungsfehler auftritt.
Führen Sie den folgenden Befehl aus, um den Job zu löschen:
```
kubectl delete job gpt-download-job
```

vLLM-Container in Ihrem GKE-Cluster bereitstellen

Nachdem Sie das Modell in Ihren Cloud Storage-Bucket heruntergeladen haben, stellen Sie einen vLLM-Container in Ihrem GKE-Cluster bereit:

Erstellen Sie eine vllm-gpt-oss-120b.yaml-Datei mit der ausgewählten vLLM-Bereitstellung:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gpt-oss-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gpt-oss
  template:
    metadata:
      labels:
        app: gpt-oss
        ai.gke.io/model: gpt-oss-120b
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
      annotations:
        gke-gcsfuse/volumes: "true"
    spec:
      containers:
      - name: vllm-inference
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250822_0916_RC01
        resources:
          requests:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "240Gi"
            nvidia.com/gpu: "8"
          limits:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "240Gi"
            nvidia.com/gpu: "8"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/mnt/gcs/gpt-oss-120b
        - --tensor-parallel-size=8
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=8192
        - --max-num-seqs=4
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
        - mountPath: /mnt/gcs
          name: gcs-bucket-volume
          readOnly: true
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 900
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 900
          periodSeconds: 5
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      - name: gcs-bucket-volume
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: $GCS_BUCKET
            mountOptions: "implicit-dirs,file-cache:max-size-mb:-1,file-cache:enable-parallel-downloads:true,file-cache:max-parallel-downloads:32,file-cache:parallel-downloads-per-file:8,file-cache:download-chunk-size-mb:16"
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-b200
        cloud.google.com/reservation-name: $RESERVATION_URL
        cloud.google.com/reservation-affinity: "specific"
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: oss-service
spec:
  selector:
    app: gpt-oss
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000
---
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: vllm-gpt-oss-monitoring
spec:
  selector:
    matchLabels:
      app: gpt-oss
  endpoints:
  - port: 8000
    path: /metrics
    interval: 30s

Wenden Sie die Datei vllm-gpt-oss-120b.yaml auf Ihren GKE-Cluster an:
```
envsubst < vllm-gpt-oss-120b.yaml | kubectl apply -f -
```
Führen Sie den folgenden Befehl aus, um den Abschlussstatus aufzurufen:
```
kubectl wait \
    --for=condition=Available \
    --timeout=7200s deployment/vllm-gpt-oss-deployment
```
Mit dem Flag --timeout kann der Befehl die Bereitstellung für den angegebenen Zeitraum überwachen.

Mithilfe von curl mit dem `gpt-oss`-Modell interagieren

So prüfen Sie das bereitgestellte gpt-oss-Modell:

Richten Sie die Portweiterleitung zum Modell gpt-oss ein:
```
kubectl port-forward service/oss-service 8000:8000
```

Öffnen Sie ein neues Terminalfenster. Sie können dann mit Ihrem Modell über curl chatten:

curl http://127.0.0.1:8000/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Describe a sailboat in one short sentence?"
    }
  ]
}' | jq .

Die Ausgabe sieht in etwa so aus:

{
  "id": "chatcmpl-2235c39759c040daae23ce2addc40c0a",
  "object": "chat.completion",
  "created": 1756831629,
  "model": "openai/gpt-oss-120b",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "A sleek vessel gliding on water, its cloth sails billowing like captured wind.",
        "refusal": null,
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": [],
        "reasoning_content": "User asks: \"Describe a sailboat in one short sentence?\" We need to produce a short sentence description. Should comply with policy. It's fine. Provide a short sentence."
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 80,
    "total_tokens": 142,
    "completion_tokens": 62,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null,
  "kv_transfer_params": null
}

Leistung des Modells beobachten

Wenn Sie die Leistung Ihres Modells beobachten möchten, können Sie die vLLM-Dashboard-Integration in Cloud Monitoring verwenden. In diesem Dashboard können Sie wichtige Leistungsmesswerte für Ihr Modell wie Token-Durchsatz, Netzwerklatenz und Fehlerraten einsehen. Informationen finden Sie in der Monitoring-Dokumentation unter vLLM.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Ressourcen löschen

Löschen Sie nach Abschluss der Anleitung die Ressourcen, die Sie nicht mehr benötigen.

Führen Sie den folgenden Befehl aus, um das Deployment und den Dienst, die in der Datei vllm-gpt-oss-120b.yaml definiert sind, sowie das Kubernetes-Secret aus dem GKE-Cluster zu löschen:
```
envsubst < vllm-gpt-oss-120b.yaml | kubectl delete -f -
kubectl delete secret hf-secret
```
Führen Sie den folgenden Befehl aus, um den Cloud Storage-Bucket zu löschen:
```
gcloud storage rm --recursive gs://$GCS_BUCKET
```

So löschen Sie den GKE-Cluster:

gcloud container clusters delete $CLUSTER_NAME \
    --region=$REGION \
    --quiet

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, zum Beispiel eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, anstatt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Google Cloud -Projekt löschen:

gcloud projects delete PROJECT_ID