Diese Seite wurde von der Cloud Translation API übersetzt.

Offene Gemma-Modelle mit GPUs in GKE mit vLLM bereitstellen

Autopilot Standard

In dieser Anleitung wird beschrieben, wie Sie ein Gemma 3-LLM (Large Language Model) mit GPUs in Google Kubernetes Engine (GKE) mit dem vLLM-Bereitstellungs-Framework bereitstellen. Dies bietet eine Grundlage für das Verständnis und die Untersuchung der praktischen LLM-Bereitstellung für die Inferenz in einer verwalteten Kubernetes-Umgebung. Sie stellen einen vorgefertigten Container, in dem vLLM ausgeführt wird, in GKE bereit. Sie konfigurieren GKE auch so, dass die Gewichte für Gemma 1B, 4B, 12B und 27B von Hugging Face geladen werden.

Diese Anleitung richtet sich an Entwickler von maschinellem Lernen (ML), 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 Enterprise-Nutzerrollen und ‑Aufgaben.

Wenn Sie eine einheitliche verwaltete KI-Plattform benötigen, die für die schnelle und kostengünstige Entwicklung und Bereitstellung von ML-Modellen konzipiert ist, empfehlen wir Ihnen, unsere Bereitstellungslösung Vertex AI auszuprobieren.

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.

Gemma

Gemma ist eine Reihe offen verfügbarer, einfacher und auf generativer KI basierender multimodaler Modelle, die unter einer offenen Lizenz veröffentlicht wurden. Diese KI-Modelle können in Ihren Anwendungen, Geräten, Mobilgeräten oder gehosteten Diensten ausgeführt werden. Gemma 3 führt Multimodalität ein und unterstützt Vision-Language-Eingaben und Textausgaben. Das Modell kann Kontextfenster mit bis zu 128.000 Tokens verarbeiten und unterstützt über 140 Sprachen. Gemma 3 bietet auch verbesserte Funktionen für Mathematik, Schlussfolgerungen und Chat, einschließlich strukturierter Ausgaben und Funktionsaufrufen.

Sie können die Gemma-Modelle zur Textgenerierung verwenden. Sie können diese Modelle jedoch auch für spezielle Aufgaben optimieren.

Weitere Informationen finden Sie in der Gemma-Dokumentation.

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

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 3-Modell über curl und eine Webchat-Oberfläche bereitzustellen.

Hinweise

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

Check for the roles

In the Google Cloud console, go to the IAM page.
Go to IAM
Select the project.
In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

Grant the roles

In the Google Cloud console, go to the IAM page.
IAM aufrufen
Wählen Sie das Projekt aus.
Klicken Sie auf Zugriffsrechte erteilen.
Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Das ist in der Regel die E‑Mail-Adresse eines Google-Kontos.
Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
Klicken Sie auf Weitere Rolle hinzufügen, wenn Sie weitere Rollen zuweisen möchten.
Klicken Sie auf Speichern.

Erstellen Sie ein Hugging Face-Konto, falls Sie noch keines haben.
Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für L4-GPUs hat. Weitere Informationen finden Sie unter GPUs und Zuteilungskontingente.

Zugriff auf das Modell erhalten

Für den Zugriff auf das Modell über Hugging Face benötigen Sie ein Hugging Face-Token.

Führen Sie die folgenden Schritte aus, um ein neues Token zu generieren, 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.
Kopieren Sie das Token in die Zwischenablage.

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 CLUSTER_NAME=CLUSTER_NAME
export HF_TOKEN=HF_TOKEN
```
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.
- CLUSTER_NAME: Der Name Ihres Clusters.
- HF_TOKEN ist das Hugging Face-Token, das Sie zuvor generiert haben.

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 \
    --region=REGION \
    --release-channel=rapid

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.
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 \
    --region=REGION \
    --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.
- REGION: eine Region, 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:

Gemma 3 1B

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-8 \
    --num-nodes=1

GKE erstellt einen einzelnen Knotenpool mit einer L4-GPU für jeden Knoten.

Gemma 3 4B

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-8 \
    --num-nodes=1

GKE erstellt einen einzelnen Knotenpool mit einer L4-GPU für jeden Knoten.

Gemma 3 12B

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-48 \
    --num-nodes=1

GKE erstellt einen einzelnen Knotenpool mit vier L4-GPUs für jeden Knoten.

Gemma 3 27B

gcloud container node-pools create gpupool \
    --accelerator type=nvidia-a100-80gb,count=1,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=REGION \
    --node-locations=REGION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=a2-ultragpu-1g \
    --disk-type=pd-ssd \
    --num-nodes=1 \
    --disk-size=256

GKE erstellt einen einzelnen Knotenpool mit einer A100 80 GB-GPU.

Kubernetes-Secret für Hugging Face-Anmeldedaten erstellen

Gehen Sie in Cloud Shell so vor:

Konfigurieren Sie kubectl für die Kommunikation mit Ihrem Cluster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=REGION
```
Ersetzen Sie die folgenden Werte:
- REGION: eine Region, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1 für L4-GPU.
- CLUSTER_NAME: Der Name Ihres Clusters.

Erstellen Sie ein Kubernetes-Secret, das das Hugging Face-Token enthält:

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

Ersetzen Sie HF_TOKEN durch das Hugging Face-Token, das Sie zuvor generiert haben.

vLLM bereitstellen

In diesem Abschnitt stellen Sie den vLLM-Container für das Gemma-Modell bereit, das Sie verwenden möchten. In dieser Anleitung werden Kubernetes-Deployments verwendet, um das Modell bereitzustellen. 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.

Gemma 3 1B-it

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

Erstellen Sie das folgende vllm-3-1b-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-3-1b-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:20250312_0916_RC01
        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.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        - --host=0.0.0.0
        - --port=8000
        env:
        - name: MODEL_ID
          value: google/gemma-3-1b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        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-3-1b-it.yaml
```

Gemma 3 4B-it

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

Erstellen Sie das folgende vllm-3-4b-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-3-4b-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:20250312_0916_RC01
        resources:
          requests:
            cpu: "2"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "2"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=32768
        - --max-num-seqs=4
        env:
        - name: MODEL_ID
          value: google/gemma-3-4b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        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-3-4b-it.yaml
```
In unserem Beispiel begrenzen wir das Kontextfenster auf 32.000 Tokens mit der vLLM-Option --max-model-len=32768. 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.

Gemma 3 12B-it

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

Erstellen Sie das folgende vllm-3-12b-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-3-12b-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:20250312_0916_RC01
        resources:
          requests:
            cpu: "4"
            memory: "32Gi"
            ephemeral-storage: "32Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "4"
            memory: "32Gi"
            ephemeral-storage: "32Gi"
            nvidia.com/gpu: "2"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=2
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=16384
        - --max-num-seqs=4
        env:
        - name: MODEL_ID
          value: google/gemma-3-12b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        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-3-12b-it.yaml
```
In unserem Beispiel begrenzen wir die Größe des Kontextfensters mit der vLLM-Option --max-model-len=16384 auf 16.000 Tokens. Wenn Sie ein größeres Kontextfenster (bis zu 128.000 Tokens) benötigen, passen Sie Ihr Manifest und Ihre Knotenpoolkonfiguration mit mehr GPU-Kapazität an.

Gemma 3 27B-it

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

Erstellen Sie das folgende vllm-3-27b-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-3-27b-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:20250312_0916_RC01
        resources:
          requests:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "120Gi"
            nvidia.com/gpu : "1"
          limits:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "120Gi"
            nvidia.com/gpu : "1"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        - --host=0.0.0.0
        - --port=8000
        - --swap-space=16
        - --gpu-memory-utilization=0.95
        - --max-model-len=32768
        - --max-num-seqs=4
        env:
        - name: MODEL_ID
          value: google/gemma-3-27b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-a100-80gb
        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-3-27b-it.yaml
```
In unserem Beispiel begrenzen wir die Größe des Kontextfensters mit der vLLM-Option --max-model-len=32768 auf 32.000 Tokens. 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.

Ein Pod im Cluster lädt die Modellgewichtungen von Hugging Face herunter und startet die Bereitstellungs-Engine.

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 Modelldaten herunter. Das kann einige Minuten dauern. Die Ausgabe sieht in etwa so aus:

INFO:     Automatically detected platform cuda.
...
INFO      [launcher.py:34] Route: /v1/chat/completions, Methods: POST
...
INFO:     Started server process [13]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
Default STARTUP TCP probe succeeded after 1 attempt for container "vllm--google--gemma-3-4b-it-1" on port 8080.

Das Modell muss vollständig heruntergeladen sein, bevor Sie mit dem nächsten Abschnitt fortfahren.

Modell bereitstellen

In diesem Abschnitt interagieren Sie mit dem Modell.

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 3-Modelle zu prüfen, die für Anleitungen optimiert wurden. Ersetzen Sie bei anderen Modellen gemma-3-4b-it durch den Namen des jeweiligen Modells.

In diesem Beispiel wird gezeigt, wie Sie das für die Anleitung abgestimmte Gemma 3 4B-Modell 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-3-4b-it",
    "messages": [
        {
          "role": "user",
          "content": "Why is the sky blue?"
        }
    ]
}'

Die Ausgabe sieht dann ungefähr so aus:

{
    "id": "chatcmpl-e4a2e624bea849d9b09f838a571c4d9e",
    "object": "chat.completion",
    "created": 1741763029,
    "model": "google/gemma-3-4b-it",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "reasoning_content": null,
                "content": "Okay, let's break down why the sky appears blue! It's a fascinating phenomenon rooted in physics, specifically something called **Rayleigh scattering**. Here's the explanation: ...",
                "tool_calls": []
            },
            "logprobs": null,
            "finish_reason": "stop",
            "stop_reason": 106
        }
    ],
    "usage": {
        "prompt_tokens": 15,
        "total_tokens": 668,
        "completion_tokens": 653,
        "prompt_tokens_details": null
    },
    "prompt_logprobs": 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-2-9b-it in google/gemma-3-4b-it oder in einen anderen Namen eines Gemma 3-Modells, den 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.4
        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-2-9b-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 die Schaltfläche 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

Sie können die Modellleistung mit der vLLM-Dashboard-Integration in Cloud Monitoring beobachten. In diesem Dashboard können Sie wichtige Leistungsmesswerte wie den Token-Durchsatz, die Anfrage-Latenz und die Fehlerraten einsehen.

Wenn Sie das vLLM-Dashboard verwenden möchten, müssen Sie Google Cloud Managed Service for Prometheus in Ihrem GKE-Cluster aktivieren. Damit werden die Messwerte von vLLM erfasst. vLLM stellt Messwerte standardmäßig im Prometheus-Format bereit. Sie müssen keinen zusätzlichen Exporter installieren.

Anschließend können Sie die Messwerte über das vLLM-Dashboard aufrufen. 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 \
    --region=REGION

Ersetzen Sie die folgenden Werte:

REGION: eine Region, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1 für L4-GPU.
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

Gemma

GPUs

vLLM

Ziele

Hinweise

Check for the roles

Grant the roles

Zugriff auf das Modell erhalten

Umgebung vorbereiten

Google Cloud -Ressourcen erstellen und konfigurieren

GKE-Cluster und -Knotenpool erstellen

Autopilot

Standard

Gemma 3 1B

Gemma 3 4B

Gemma 3 12B

Gemma 3 27B

Kubernetes-Secret für Hugging Face-Anmeldedaten erstellen

vLLM bereitstellen

Gemma 3 1B-it

Gemma 3 4B-it

Gemma 3 12B-it

Gemma 3 27B-it

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