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

vLLM in GKE verwenden, um die Inferenz mit DeepSeek-V3.2-Special durchzuführen

In dieser Anleitung wird gezeigt, wie Sie ein DeepSeek-V3.2-Speciale-Sprachmodell mit dem vLLM-Framework bereitstellen und verfügbar machen. Sie stellen dieses Modell in einem Autopilot-Cluster der GKE Enterprise-Version (Google Kubernetes Engine) bereit und nutzen eine einzelne virtuelle A4-Maschine (VM) mit 8 B200-GPUs.

In diesem Tutorial wird davon ausgegangen, dass Sie das Sprachmodell DeepSeek-V3.2-Speciale bereits geprüft haben und seine Funktionen den Anforderungen Ihres Anwendungsfalls entsprechen.

Diese Anleitung richtet sich an Entwickler von maschinellem Lernen (ML), Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen zur Verarbeitung von Inferenz-Arbeitslasten zu nutzen.

Ziele

Über Hugging Face auf DeepSeek-V3.2-Speciale zugreifen
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.
Mit DeepSeek-V3.2-Speciale über curl 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

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Installieren Sie die Google Cloud CLI.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst 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

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

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 „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

So erstellen Sie ein Google Cloud Projekt:
```
gcloud projects create PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.
Wählen Sie das von Ihnen erstellte Google Cloud Projekt 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:

Rollen, die zum Aktivieren von APIs erforderlich sind

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 Rolle „Inhaber“ (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

Installieren Sie die Google Cloud CLI.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst 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

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

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 „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

So erstellen Sie ein Google Cloud Projekt:
```
gcloud projects create PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.
Wählen Sie das von Ihnen erstellte Google Cloud Projekt 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:

Rollen, die zum Aktivieren von APIs erforderlich sind

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 . Beispiel: myemail@example.com
- ROLE: Die IAM-Rolle, die Sie Ihrem Nutzerkonto zuweisen.
Melden Sie sich in einem Hugging Face-Konto an oder erstellen Sie ein Konto.

Über Hugging Face auf DeepSeek-V3.2-Special zugreifen

So verwenden Sie Hugging Face für den Zugriff auf das Modell DeepSeek-V3.2-Speciale:

Melden Sie sich bei Hugging Face an.
Erstellen Sie ein Hugging Face-Zugriffstoken für read.
Kopieren und speichern Sie den Wert des read-Zugriffstokens. 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: der Name der Reservierung, die Sie zum Erstellen Ihres GKE-Cluster verwenden möchten. Geben Sie je nach Projekt, in dem die Reservierung vorhanden ist, einen der folgenden Werte an:
- Die Reservierung ist in Ihrem Projekt vorhanden: YOUR_RESERVATION_NAME
- Die Reservierung ist in einem anderen Projekt vorhanden und Ihr Projekt kann sie verwenden: projects/RESERVATION_PROJECT_ID/reservations/YOUR_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 Ihre Reservierung vorhanden ist.
YOUR_CLUSTER_NAME: Der Name des GKE-Cluster, der erstellt werden soll.
YOUR_GCS_BUCKET: der Name des Cloud Storage-Bucket, aus dem Sie das Modell herunterladen.
YOUR_HF_TOKEN: Das Hugging Face-Zugriffstoken, das Sie im vorherigen Abschnitt erstellt haben.
YOUR_NETWORK_NAME: Das Netzwerk, das vom GKE-Cluster verwendet wird. 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 vom GKE-Cluster verwendet wird. Geben Sie einen der folgenden Werte an:
- Wenn Sie ein benutzerdefiniertes Subnetzwerk erstellt haben, geben Sie den Namen des 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. Rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster auf, um zu prüfen, ob Google Cloud den Cluster erstellt hat.

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 zum Speichern Ihres Hugging Face-Tokens:

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 möchten, können Sie diesen Schritt überspringen. Ihr Bucket muss sich jedoch in derselben Region wie Ihr Cluster befinden und das Dienstkonto muss die erforderlichen write-Berechtigungen dafür haben.

Wenn Sie einen neuen Bucket zum Speichern des Modells verwenden möchten, führen Sie Folgendes aus:

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

deepseek-download-job.yaml-Datei erstellen:

apiVersion: batch/v1
kind: Job
metadata:
  name: deepseek-download-job
  namespace: default
spec:
  template:
    metadata:
      labels:
        app: deepseek-oss-downloader
    spec:
      restartPolicy: OnFailure
      containers:
      - name: downloader
        image: google/cloud-sdk:slim
        resources:
          requests:
            cpu: "8"
            memory: "32Gi"
          limits:
            cpu: "8"
            memory: "32Gi"
        env:
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        - name: HF_XET_HIGH_PERFORMANCE
          value: "0"
        - name: PIP_BREAK_SYSTEM_PACKAGES
          value: "1"
        command: ["/bin/sh", "-c"]
        args:
        - |
          set -e
          echo "Installing Hugging Face Hub CLI..."
          pip install -U "huggingface_hub[cli]"

          LOCAL_DIR="/mnt/model-download/deepseek-v3-2"
          mkdir -p "$LOCAL_DIR"

          echo "Downloading model from HF to local SSD using parallel workers..."
          hf download deepseek-ai/DeepSeek-V3.2-Speciale \
            --token "$HUGGING_FACE_HUB_TOKEN" \
            --local-dir "$LOCAL_DIR" \
            --max-workers 8

          DOWNLOAD_STATUS=$?

          if [ $DOWNLOAD_STATUS -ne 0 ]; then
            echo "ERROR: Model download failed with exit code $DOWNLOAD_STATUS"
            exit $DOWNLOAD_STATUS
          fi

          echo "Download to SSD complete. Syncing to GCS..."
          gcloud storage rsync "$LOCAL_DIR" "gs://$GCS_BUCKET/deepseek-v3-2" --recursive

          echo "Process successfully completed!"
        volumeMounts:
        - mountPath: /mnt/model-download
          name: download-storage
      volumes:
      - name: download-storage
        ephemeral:
          volumeClaimTemplate:
            spec:
              accessModes: [ "ReadWriteOnce" ]
              storageClassName: premium-rwo
              resources:
                requests:
                  storage: 800Gi

Wenden Sie das deepseek-download-job.yaml-Manifest an, um den Downloadjob zu initialisieren:
```
envsubst '$GCS_BUCKET' < deepseek-download-job.yaml | kubectl apply -f -
```
Führen Sie den folgenden Befehl aus, um den Abschlussstatus aufzurufen:
```
kubectl wait \
    --for=condition=Complete \
    --timeout=7200s job/deepseek-download-job
```
Das Flag --timeout gibt an, wie lange der Befehl den Job überwacht, bevor das Zeitlimit überschritten wird.

Die Jobressource lädt die DeepSeek-V3.2-Speciale-Modellgewichte von Hugging Face in Ihren Google Cloud Storage-Bucket herunter und verwendet dabei ein SSD-Volume. Der Download dauert etwa 40 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 Job zu löschen:
```
kubectl delete job deepseek-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. Führen Sie dazu die folgenden Schritte aus:

Erstellen Sie eine vllm-deepseek3-2.yaml-Datei mit der von Ihnen ausgewählten vLLM-Bereitstellung:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deepseek3-2-deploy
spec:
  replicas: 1
  selector:
    matchLabels:
      app: deepseek
  template:
    metadata:
      labels:
        app: deepseek
        ai.gke.io/model: deepseek-v3-2
        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:model-garden.pytorch-vllm-serve-release_20251126.00_p0
        resources:
          requests:
            cpu: "10"
            memory: "1000Gi"
            ephemeral-storage: "1Ti"
            nvidia.com/gpu: "8"
          limits:
            cpu: "10"
            memory: "1000Gi"
            ephemeral-storage: "1Ti"
            nvidia.com/gpu: "8"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/mnt/gcs/deepseek-v3-2
        - --tensor-parallel-size=8
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=131072
        - --max-num-seqs=16
        - --enable-chunked-prefill
        - --gpu-memory-utilization=0.90
        - --enforce-eager
        - --trust-remote-code
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
        - mountPath: /mnt/gcs
          name: gcs-bucket-volume
          readOnly: true
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 1800
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 1800
          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: deepseek-service
spec:
  selector:
    app: deepseek
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000
---
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: deepseek-monitoring
spec:
  selector:
    matchLabels:
      app: deepseek
  endpoints:
  - port: 8000
    path: /metrics
    interval: 30s

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

Mithilfe von curl mit DeepSeek-V3.2-Speciale interagieren

So prüfen Sie das bereitgestellte DeepSeek-V3.2-Speciale-Modell:

Richten Sie die Portweiterleitung für DeepSeek-V3.2-Speciale ein:
```
kubectl port-forward service/deepseek-service 8000:8000
```

Öffnen Sie ein neues Terminalfenster. Anschließend können Sie mit Ihrem Modell chatten, indem Sie curl verwenden:

time curl http://127.0.0.1:8000/v1/completions \
   -X POST \
   -H "Content-Type: application/json" \
   -d '{
     "model": "deepseek-ai/DeepSeek-V3.2-Speciale",
     "prompt": "<|im_start|>user\nExplain the ReAct (Reasoning + Acting) pattern in Agentic AI. Provide a concise Python pseudocode example showing the loop. Keep the explanation under 300 words.<|im_end|>\n<|im_start|>assistant\n",
     "max_tokens": 1024,
     "temperature": 0.7,
     "stream": false,
     "stop": ["<|im_end|>"]
   }' | jq .

Die Ausgabe sieht in etwa so aus:

{
  "id": "cmpl-be345f0499e949ed8500e533be2cfe3f",
  "object": "text_completion",
  "created": 1764803171,
  "model": "deepseek-ai/DeepSeek-V3.2-Speciale",
  "choices": [
    {
      "index": 0,
      "text": "The ReAct pattern integrates reasoning (thoughts) and actions (tool calls) within an agentic loop... [TRUNCATED FOR BREVITY] ...ReAct improves transparency and reliability by explicit reasoning steps.",
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": "<|im_end|>",
      "token_ids": null,
      "prompt_logprobs": null,
      "prompt_token_ids": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 57,
    "total_tokens": 317,
    "completion_tokens": 260,
    "prompt_tokens_details": null
  },
  "kv_transfer_params": null
}

Modellleistung beobachten

Um die Leistung Ihres Modells zu beobachten, können Sie die vLLM-Dashboard-Integration in Cloud Monitoring verwenden. In diesem Dashboard können Sie wichtige Leistungsmesswerte wie den Token-Durchsatz, die Anfrage-Latenz und die Fehlerraten einsehen.

Informationen zum Erfassen von Messwerten aus Ihrem Modell mit Google Cloud Managed Service for Prometheus finden Sie in der Dokumentation zu Monitoring 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.

Damit Ihrem Cloud-Rechnungskonto die in dieser Anleitung 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.

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 in der Datei vllm-deepseek3-2.yaml definierte Deployment und den Dienst sowie das Kubernetes-Secret aus dem GKE-Cluster zu löschen:
```
envsubst < vllm-deepseek3-2.yaml | kubectl delete -f -
kubectl delete secret hf-secret
```
Führen Sie den folgenden Befehl aus, um Ihren Cloud Storage-Bucket zu löschen:
```
gcloud storage rm --recursive gs://"$GCS_BUCKET"
```

So löschen Sie Ihren 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

Nächste Schritte

KI-optimierte GKE-Cluster verwalten