Offene Gemma-Modelle mit GPUs in GKE mit vLLM bereitstellen

Autopilot Standard

Wenn Sie Gemma 4-LLMs (Large Language Models) in Google Kubernetes Engine (GKE) mit dem vLLM-Framework mit GPUs bereitstellen möchten, müssen Sie einen GKE-Cluster mit unterstützten Beschleunigern wie NVIDIA B200, H100, RTX Pro 6000 oder L4-GPUs bereitstellen.

Wenn Sie die Modellgewichte für Gemma 4 abrufen möchten, können Sie den vordefinierten vLLM-Container so konfigurieren, dass die Gewichte aus dem Hugging Face-Repository heruntergeladen werden. Alternativ kann der Container Modellgewichte aus vorhandenem persistenten Speicher laden, z. B. durch Caching Ihrer Cloud Storage-Modell-Buckets auf einer Google Cloud Managed Lustre-Instanz.

Sobald die Gewichte geladen sind, stellt der vLLM-Container einen OpenAI-kompatiblen API-Endpunkt für die Inferenz mit hohem Durchsatz bereit.

Diese Anleitung richtet sich an ML-Entwickler (Machine Learning), Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die daran interessiert sind, Funktionen zur Kubernetes-Containerorchestrierung für die Bereitstellung von KI‑/ML-Arbeitslasten auf H200-, H100-, A100- und L4-GPU-Hardware zu nutzen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in Google Cloud Inhalten verweisen, finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.

Wenn Sie eine einheitliche verwaltete KI-Plattform benötigen, um ML-Modelle schnell und kostengünstig zu erstellen und bereitzustellen, empfehlen wir Ihnen, unsere Bereitstellungslösung Vertex AI zu testen.

Machen Sie sich vor dem Lesen dieser Seite mit den folgenden Themen vertraut:

Hintergrund

In diesem Abschnitt werden die in diesem Leitfaden verwendeten Schlüsseltechnologien beschrieben.

GPUs

Mit GPUs können Sie bestimmte Arbeitslasten wie maschinelles Lernen und Datenverarbeitung beschleunigen, die auf Ihren Knoten ausgeführt werden. GKE bietet eine Reihe von Maschinentypoptionen für die Knotenkonfiguration, einschließlich Maschinentypen mit NVIDIA H200-, H100-, L4- und A100-GPUs.

vLLM

vLLM ist ein hoch optimiertes Open-Source-LLM-Bereitstellungs-Framework, das den Bereitstellungsdurchsatz auf GPUs über Funktionen wie die Folgenden beschleunigen kann:

Optimierte Transformer-Implementierung mit PagedAttention
Kontinuierliche Batchverarbeitung zur Verbesserung des allgemeinen Bereitstellungsdurchsatzes
Tensor-Parallelität und verteilte Bereitstellung auf mehreren GPUs

Weitere Informationen finden Sie in der vLLM-Dokumentation.

Ziele

In dieser Anleitung wird eine Grundlage für das Verständnis und die praktische Bereitstellung von LLMs für die Inferenz in einer verwalteten Kubernetes-Umgebung geschaffen.

Bereiten Sie Ihre Umgebung mit einem GKE-Cluster im Autopilot- oder Standardmodus vor.
Stellen Sie einen vLLM-Container in Ihrem Cluster bereit.
vLLM verwenden, um das Gemma 4-Modell über curl und eine Webchat-Oberfläche bereitzustellen.

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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud 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.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud 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.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Sie benötigen die folgenden Rollen für das Projekt: roles/container.admin, roles/iam.serviceAccountAdmin
Rollen prüfen
1. Rufen Sie in der Google Cloud Console die Seite IAM auf.
  IAM aufrufen
2. Wählen Sie das Projekt aus.
3. Suchen Sie in der Spalte Hauptkonto nach allen Zeilen, in denen Sie oder eine Gruppe, zu der Sie gehören, angegeben sind. Fragen Sie Ihren Administrator, zu welchen Gruppen Sie gehören.
4. Prüfen Sie in allen Zeilen, in denen Sie angegeben oder enthalten sind, die Spalte Rolle, um zu sehen, ob die Liste der Rollen die erforderlichen Rollen enthält.
Rollen zuweisen
1. Rufen Sie in der Google Cloud Console die Seite IAM auf.
  IAM aufrufen
2. Wählen Sie das Projekt aus.
3. Klicken Sie auf Zugriffsrechte erteilen.
4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Das ist in der Regel die E‑Mail-Adresse eines Google-Kontos.
5. Klicken Sie auf Rolle auswählen und suchen Sie nach der Rolle.
6. Klicken Sie auf Weitere Rolle hinzufügen, wenn Sie weitere Rollen zuweisen möchten.
7. Klicken Sie auf Speichern.

Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für L4-GPUs hat. Weitere Informationen finden Sie unter GPUs und Zuteilungskontingente.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die inGoogle Cloudgehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich kubectl und gcloud CLI.

So richten Sie Ihre Umgebung mit Cloud Shell ein:

Starten Sie in der Google Cloud Console eine Cloud Shell-Sitzung. Klicken Sie dazu in der Google Cloud Console auf Cloud Shell aktivieren. Dadurch wird im unteren Bereich der Google Cloud console eine Sitzung gestartet.
Legen Sie die Standardumgebungsvariablen fest:
```
gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME
```
Ersetzen Sie die folgenden Werte:
- PROJECT_ID: Ihre Google Cloud Projekt-ID.
- REGION: eine Region, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1 für L4-GPU. Hier finden Sie Informationen dazu, welche GPUs in welcher Region verfügbar sind.
- ZONE: eine Zone, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1-b und us-central1-f für RTX PRO 6000-GPU. Hier finden Sie Informationen dazu, welche Zone welche GPUs bietet.
- CLUSTER_NAME: Der Name Ihres Clusters.

Google Cloud -Ressourcen erstellen und konfigurieren

Folgen Sie dieser Anleitung, um die erforderlichen Ressourcen zu erstellen.

GKE-Cluster und -Knotenpool erstellen

Sie können Gemma auf GPUs in einem GKE-Cluster im Autopilot- oder Standardmodus bereitstellen. Für eine vollständig verwaltete Kubernetes-Umgebung empfehlen wir die Verwendung eines Autopilot-Clusters. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

Autopilot

Führen Sie in Cloud Shell den folgenden Befehl aus:

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --release-channel=rapid

Ersetzen Sie die folgenden Werte:

PROJECT_ID: Ihre Google Cloud Projekt-ID.
CONTROL_PLANE_LOCATION: die Compute Engine-Region der Steuerungsebene des Clusters. Geben Sie eine Region an, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1 für L4-GPU.
CLUSTER_NAME: Der Name Ihres Clusters.

GKE erstellt einen Autopilot-Cluster mit CPU- und GPU-Knoten, wie von den bereitgestellten Arbeitslasten angefordert.

Standard

Führen Sie in Cloud Shell den folgenden Befehl aus, um einen Standardcluster zu erstellen:
```
gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --release-channel=rapid \
    --num-nodes=1
```
Ersetzen Sie die folgenden Werte:
- PROJECT_ID: Ihre Google Cloud Projekt-ID.
- CONTROL_PLANE_LOCATION: die Compute Engine-Region der Steuerungsebene des Clusters. Geben Sie eine Region an, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1 für L4-GPU.
- CLUSTER_NAME: Der Name Ihres Clusters.
Die Erstellung eines Clusters kann einige Minuten dauern.

Führen Sie den folgenden Befehl aus, um einen Knotenpool für Ihren Cluster mit der entsprechenden Festplattengröße zu erstellen:

  gcloud container node-pools create gpupool \
      --accelerator type=nvidia-rtx-pro-6000,count=1,gpu-driver-version=latest \
      --project=PROJECT_ID \
      --location=REGION \
      --node-locations=ZONE \
      --cluster=CLUSTER_NAME \
      --machine-type=g4-standard-48 \
      --num-nodes=1

GKE erstellt einen einzelnen Knotenpool mit einer RTX PRO. 6.000 GPUs pro Knoten.

Gemma 4-Modelle in vLLM mit Hugging Face-Gewichten bereitstellen

Wenn Sie Gemma 4-Modelle mit Hugging Face-Gewichtungen bereitstellen möchten, wenden Sie ein Kubernetes-Bereitstellungsmanifest für die ausgewählte Modellgröße an. Ein Deployment ist ein Kubernetes-API-Objekt, mit dem Sie mehrere Replikate von Pods ausführen können, die auf die Knoten in einem Cluster verteilt sind.

Prozedur

Durch Anwenden dieses Manifests wird das vLLM-Container-Image abgerufen, eine NVIDIA-GPU angefordert und die Gewichte werden automatisch von Hugging Face heruntergeladen, um die vLLM-Inferenz-Engine zu starten.

Gemma 4 E2B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 4 E2B (nur Texteingabe) bereitzustellen.

Erstellen Sie das folgende vllm-4-e2b-it.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-e2b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E2B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Wenden Sie das Manifest an:
```
kubectl apply -f vllm-4-e2b-it.yaml
```

Gemma 4 E4B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 4 E4B bereitzustellen.

Erstellen Sie das folgende vllm-4-e4b-it.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-e4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E4b-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Wenden Sie das Manifest an:
```
kubectl apply -f vllm-4-E4b-it.yaml
```
In unserem Beispiel begrenzen wir das Kontextfenster auf 32.000 Tokens mit der vLLM-Option --max-model-len=32768. Wenn Sie eine größere Kontextfenstergröße (bis zu 128.000 Tokens) benötigen, passen Sie das Manifest und die Knotenpoolkonfiguration mit mehr GPU-Kapazität an.

Gemma 4 26B-A4B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 4 26B-A4B bereitzustellen.

Erstellen Sie das folgende vllm-4-26b-a4b-it.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-26b-a4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-26B-A4B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Wenden Sie das Manifest an:
```
kubectl apply -f vllm-4-26b-a4b-it.yaml
```
In unserem Beispiel begrenzen wir die Größe des Kontextfensters mit der vLLM-Option --max-model-len=16384 auf 16 K. Wenn Sie ein größeres Kontextfenster (bis zu 128.000 Tokens) benötigen, passen Sie Ihr Manifest und die Knotenpoolkonfiguration mit mehr GPU-Kapazität an.

Gemma 4 31B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 4 31B bereitzustellen.

Erstellen Sie das folgende vllm-4-31b-it.yaml-Manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-31b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-31B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Wenden Sie das Manifest an:
```
kubectl apply -f vllm-4-31b-it.yaml
```
In unserem Beispiel begrenzen wir die Größe des Kontextfensters mit der vLLM-Option --max-model-len=16384 auf 16 K. Wenn Sie ein größeres Kontextfenster (bis zu 128.000 Tokens) benötigen, passen Sie das Manifest und die Knotenpoolkonfiguration mit mehr GPU-Kapazität an.

Überprüfung

Warten Sie, bis die Bereitstellung verfügbar ist:

kubectl wait --for=condition=Available --timeout=1800s deployment/vllm-gemma-deployment

So rufen Sie die Logs des laufenden Deployments auf:

kubectl logs -f -l app=gemma-server

Die Deployment-Ressource lädt die Gemma-Modelldaten herunter. Das kann einige Minuten dauern. Die Ausgabe sieht etwa so aus:

  ...
  ...
  (APIServer pid=1) INFO:     Started server process [1]
  (APIServer pid=1) INFO:     Waiting for application startup.
  (APIServer pid=1) INFO:     Application startup complete.

Nachdem die Hugging Face-Bereitstellung verfügbar ist, richten Sie die Portweiterleitung ein, um mit dem Modell zu interagieren.

Abgestimmtes Gemma-Modell aus Managed Lustre bereitstellen

Wenn Sie ein feinabgestimmtes Gemma-Modell (z. B. Gemma 3 27B) bereitstellen möchten, das bereits auf einer verwalteten Google Cloud Lustre-Instanz gespeichert ist, müssen Sie das entsprechende PersistentVolumeClaim (PVC) im vLLM-Container einbinden.

Vorbereitung

Prüfen Sie, ob in Ihrem GKE-Cluster ein PVC vorhanden ist, der mit Ihrer Lustre-Instanz verbunden ist. In diesem Beispiel hat der PVC den Namen gemma-lustre-pvc.

Informationen zum Erstellen eines PVC und eines PersistentVolume (PV) für eine vorhandene Instanz finden Sie unter Auf eine vorhandene verwaltete Lustre-Instanz zugreifen.

Prozedur

Speichern Sie das folgende YAML-Manifest als vllm-lustre-gemma.yaml. In diesem Beispiel wird der Lustre-PVC im Deployment in /data bereitgestellt und vLLM wird angewiesen, die Modellgewichte aus diesem lokalen Pfad zu laden.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-lustre
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/data/gemma-3-27b
        - --tensor-parallel-size=1
        resources:
          limits:
            nvidia.com/gpu: "1"
        volumeMounts:
        - name: model-weights
          mountPath: /data
      volumes:
      - name: model-weights
        persistentVolumeClaim:
          claimName: gemma-lustre-pvc
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest

Wenden Sie das Manifest auf den GKE-Cluster an:
```
kubectl apply -f vllm-lustre-gemma.yaml
```

Überprüfung

Wenn Sie prüfen möchten, ob das Modell erfolgreich aus dem Lustre-Volume geladen wurde, sehen Sie sich die Pod-Logs für die vLLM-Startsequenz an:

kubectl logs -l app=gemma-server

Modell bereitstellen

In diesem Abschnitt interagieren Sie mit dem Modell. Das Modell muss vollständig heruntergeladen sein, bevor Sie fortfahren.

Portweiterleitung einrichten

Führen Sie den folgenden Befehl aus, um die Portweiterleitung zum Modell einzurichten:

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

Die Ausgabe sieht in etwa so aus:

Forwarding from 127.0.0.1:8000 -> 8000

Mithilfe von curl mit dem Modell interagieren

In diesem Abschnitt wird gezeigt, wie Sie einen einfachen Smoke Test machen, um Ihre bereitgestellten Gemma 4-Modelle zu prüfen, die für Anleitungen optimiert wurden. Ersetzen Sie bei anderen Modellen gemma-4-e4b-it durch den Namen des jeweiligen Modells.

In diesem Beispiel wird gezeigt, wie Sie das für die Anleitung abgestimmte Gemma 4-Modell (E4B) mit reiner Texteingabe testen.

Verwenden Sie in einer neuen Terminalsitzung curl, um mit Ihrem Modell zu chatten:

curl http://127.0.0.1:8000/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
    "model": "google/gemma-4-26B-A4B-it",
    "messages": [
        {
          "role": "user",
          "content": "Why is the sky blue?"
        }
    ],
    "chat_template_kwargs": {
         "enable_thinking": true
    },
    "skip_special_tokens": false
}'

Die Ausgabe sieht dann ungefähr so aus:

{
  "id": "chatcmpl-be75ccfcbdf753d1",
  "object": "chat.completion",
  "created": 1775006187,
  "model": "google/gemma-4-26B-A4B-it",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The short answer is a phenomenon called **Rayleigh scattering**.\n\nTo understand how it works, you have to look at three things: sunlight, the Earth's atmosphere, and how light travels.\n\n### 1. Sunlight is a Rainbow\nAlthough sunlight looks white to us, it is actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet). Light travels as **waves**, and each color has a different wavelength:\n*   **Red light** travels in long, lazy, wide waves.\n*   **Blue and violet light** travel in short, choppy, tight waves.\n\n### 2. The Atmosphere is an Obstacle Course\nEarth's atmosphere is filled with gases (mostly nitrogen and oxygen). As sunlight travels through the atmosphere, it strikes the molecules of these gases. \n\nBecause the gas molecules are very small, they affect the colors differently based on their wavelength:\n*   The **long waves** (reds and yellows) pass through the atmosphere mostly straight, without hitting much. They are like large ocean waves that roll right over small pebbles.\n*   The **short waves** (blues and violets) strike the gas molecules and get scattered in every direction. They are like small ripples that hit a pebble and splash everywhere.\n\nBecause this blue light is being scattered in every direction by the air, when you look up, your eyes are catching that scattered blue light coming from every part of the sky.\n\n### 3. Why isn't the sky violet?\nIf violet light has an even shorter wavelength than blue light, you might wonder why the sky doesn't look purple. There are two main reasons:\n1.  **The Sun's output:** The Sun emits much more blue light than violet light.\n2.  **Human Biology:** Human eyes are much more sensitive to blue than to violet. Our eyes interpret the scatter of mixed blue and violet light simply as pale blue.\n\n---\n\n### Bonus: Why are sunsets red?\nWhen the sun is setting, it is much lower on the horizon. This means the sunlight has to travel through a much **thicker** layer of the atmosphere to reach your eyes. \n\nBy the time the light gets to you, the blue light has been scattered away completely로. Only the long-wavelength colors—the reds, oranges, and pinks—are able to make it through that thick layer of air without being scattered away, creating the beautiful colors of a sunset.",
        "refusal": null,
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": [],
        "reasoning": "\"Why is the sky blue?\"\nScience/Physics (Atmospheric scattering).\nExplain the phenomenon clearly, accurately, and engagingly.\n\n    *   Sunlight (white light) is made of a spectrum of colors (ROYGBIV).\n    *   Earth's atmosphere is filled with gases (nitrogen, oxygen) and particles.\n    *   Rayleigh Scattering: Shorter wavelengths (blue/violet) scatter more easily than longer wavelengths (red/yellow) when hitting small gas molecules.\n    *   The human eye's sensitivity: Why isn't it violet?\n\n    A good scientific explanation should follow a logical flow:\n    *   *Direct Answer:* The core mechanism (Rayleigh Scattering).\n    *   *The Components:* Sunlight and the Atmosphere.\n    *   *The Mechanism:* How light interacts with gas molecules.\n    *   *The Wavelength Factor:* Comparing colors.\n    *   *The \"Wait, why not violet?\" question:* Addressing human perception.\n    *   *Bonus/Related concept:* Why sunsets are red.\n\n        *   Use the term **Rayleigh Scattering**.\n        *   Summarize: Its how sunlight interacts with the Earth's atmosphere.\n\n        *   Sunlight looks white, but it's actually a mix of all colors (the rainbow).\n        *   Each color travels as a different wavelength. Red = long/lazy waves; Blue/Violet = short/choppy waves.\n\n        *   The atmosphere is mostly Nitrogen and Oxygen.\n        *   When sunlight hits these tiny gas molecules, the light gets scattered in all directions.\n\n        *   Blue light travels in shorter, smaller waves.\n        *   Because these waves are small, they strike the gas molecules more frequently and get scattered more easily than the longer red/yellow waves.\n        *   Result: When you look up, your eyes are catching this \"scattered\" blue light coming from every direction.\n\n        *   *Technically*, violet light has an even shorter wavelength than blue, so it scatters *even more*. Why isn't the sky violet?\n        *   Two reasons: 1. The Sun emits more blue light than violet light. 2. Human eyes are much more sensitive to blue than violet.\n\n        *   Briefly mention sunsets to provide a complete picture.\n        *   At sunset, light travels through *more* atmosphere. The blue is scattered away completely, leaving only the long red/orange waves to reach your eyes.\n\n    *   *Tone Check:* Is it too academic? Use analogies (like waves in water or skipping stones) if needed, but keep it concise.\n    *   *Clarity:* Ensure the distinction between wavelength and scattering is clear."
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": 106,
      "token_ids": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 21,
    "total_tokens": 1122,
    "completion_tokens": 1101,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null,
  "prompt_token_ids": null,
  "kv_transfer_params": null
}

Optional: Über eine Gradio-Chat-Oberfläche mit dem Modell interagieren

In diesem Abschnitt erstellen Sie eine Webchat-Anwendung, mit der Sie mit Ihrem abgestimmten Modell für Anweisungen interagieren können. Der Einfachheit halber wird in diesem Abschnitt nur der Testansatz mit dem 4B-it-Modell beschrieben.

Gradio ist eine Python-Bibliothek mit einem ChatInterface-Wrapper, der Benutzeroberflächen für Chatbots erstellt.

Chatoberfläche bereitstellen

Speichern Sie in Cloud Shell das folgende Manifest als gradio.yaml. Ändern Sie google/gemma-4-E4B-it in den Namen des Gemma 4-Modells, das Sie in Ihrem Deployment verwendet haben.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.7
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/v1/chat/completions"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "openai-chat"
        - name: MODEL_ID
          value: "google/gemma-4-E4B-it"
        - name: DISABLE_SYSTEM_MESSAGE
          value: "true"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 7860
  type: ClusterIP

Wenden Sie das Manifest an:
```
kubectl apply -f gradio.yaml
```

Warten Sie, bis die Bereitstellung verfügbar ist:

kubectl wait --for=condition=Available --timeout=900s deployment/gradio

Chatoberfläche verwenden

Führen Sie in Cloud Shell den folgenden Befehl aus:
```
kubectl port-forward service/gradio 8080:8080
```
Dadurch wird eine Portweiterleitung von Cloud Shell zum Gradio-Dienst erstellt.
Klicken Sie oben rechts in der Cloud Shell-Taskleiste auf den Button Webvorschau. Klicken Sie auf Vorschau auf Port 8080. Im Browser wird ein neuer Tab geöffnet.
Interagieren Sie über die Gradio-Chat-Oberfläche mit Gemma. Fügen Sie einen Prompt hinzu und klicken Sie auf Senden.

Probleme beheben

Wenn Sie die Empty reply from server-Meldung erhalten, hat der Container möglicherweise die Modelldaten noch nicht ganz heruntergeladen. Prüfen Sie die Logs des Pods noch einmal auf die Connected-Meldung, die angibt, dass das Modell einsatzbereit ist.
Wenn Connection refused angezeigt wird, prüfen Sie, ob die Portweiterleitung aktiv ist.

Modellleistung beobachten

So rufen Sie die Dashboards für die Messwerte zur Beobachtbarkeit eines Modells auf:

Rufen Sie in der Google Cloud Console die Seite Bereitgestellte Modelle auf.

Zu „Bereitgestellte Modelle“
Wenn Sie Details zur jeweiligen Bereitstellung aufrufen möchten, einschließlich der zugehörigen Messwerte, Protokolle und Dashboards, klicken Sie in der Liste auf den Modellnamen.
Klicken Sie auf der Seite mit den Modelldetails auf den Tab Beobachtbarkeit, um die folgenden Dashboards aufzurufen. Klicken Sie bei entsprechender Aufforderung auf Aktivieren, um die Messwerterfassung für den Cluster zu aktivieren.
- Auf dem Dashboard Infrastrukturnutzung werden Auslastungsmesswerte angezeigt.
- Im DCGM-Dashboard werden DCGM-Messwerte angezeigt.
- Wenn Sie vLLM verwenden, ist das Dashboard Modellleistung verfügbar. Dort werden Messwerte für die vLLM-Modellleistung angezeigt.

Sie können Messwerte auch in der vLLM-Dashboard-Integration in Cloud Monitoring aufrufen. Diese Messwerte werden für alle vLLM-Bereitstellungen ohne voreingestellte Filter aggregiert.

Damit Sie das Dashboard in Cloud Monitoring verwenden können, müssen Sie Google Cloud Managed Service for Prometheus in Ihrem GKE-Cluster aktivieren. Damit werden die Messwerte aus vLLM erfasst. vLLM stellt Messwerte standardmäßig im Prometheus-Format bereit. Sie müssen keinen zusätzlichen Exporter installieren. Informationen zum Erfassen von Messwerten aus Ihrem Modell mit Google Cloud Managed Service for Prometheus finden Sie in der Cloud 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.

Bereitgestellte Ressourcen löschen

Mit dem folgenden Befehl vermeiden Sie, dass Ihrem Google Cloud Konto die in dieser Anleitung erstellten Ressourcen in Rechnung gestellt werden:

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

Ersetzen Sie die folgenden Werte:

CONTROL_PLANE_LOCATION: die Compute Engine-Region der Steuerungsebene des Clusters.
CLUSTER_NAME: Der Name Ihres Clusters.

Nächste Schritte

GPUs in GKE
Gemma mit vLLM auf anderen Beschleunigern verwenden, einschließlich A100- und H100-GPUs, indem Sie den Beispielcode in GitHub aufrufen.
GPU-Arbeitslasten in Autopilot bereitstellen
GPU-Arbeitslasten in Standard bereitstellen
Sehen Sie sich das GitHub-Repository und die Dokumentation zu vLLM an.
Erfahren Sie mehr über den Vertex AI Model Garden.
Erfahren Sie, wie Sie optimierte KI/ML-Arbeitslasten über Funktionen zur GKE-Plattformorchestrierung ausführen.

Offene Gemma-Modelle mit GPUs in GKE mit vLLM bereitstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hintergrund

GPUs

vLLM

Ziele

Hinweis

Rollen prüfen

Rollen zuweisen

Umgebung vorbereiten

Google Cloud -Ressourcen erstellen und konfigurieren

GKE-Cluster und -Knotenpool erstellen

Autopilot

Standard

Gemma 4-Modelle in vLLM mit Hugging Face-Gewichten bereitstellen

Prozedur

Gemma 4 E2B-it

Gemma 4 E4B-it

Gemma 4 26B-A4B-it

Gemma 4 31B-it

Überprüfung

Abgestimmtes Gemma-Modell aus Managed Lustre bereitstellen

Vorbereitung

Prozedur

Überprüfung

Modell bereitstellen

Portweiterleitung einrichten

Mithilfe von curl mit dem Modell interagieren

Optional: Über eine Gradio-Chat-Oberfläche mit dem Modell interagieren

Chatoberfläche bereitstellen

Chatoberfläche verwenden

Probleme beheben

Modellleistung beobachten

Bereinigen

Bereitgestellte Ressourcen löschen

Nächste Schritte

Offene Gemma-Modelle mit GPUs in GKE mit vLLM bereitstellen