Llama-Modelle mit GPUs in GKE mit vLLM bereitstellen

In dieser Anleitung erfahren Sie, wie Sie ein Llama-Modell 4-Large Language Model (LLM) mit GPUs in der Google Kubernetes Engine (GKE) mit dem vLLM-Bereitstellungs-Framework bereitstellen und verfügbar machen. Dies bildet die Grundlage für das Verständnis und die Erforschung 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. Außerdem konfigurieren Sie GKE so, dass das Llama von Hugging Face geladen wird.

Diese Anleitung richtet sich an Entwickler für maschinelles Lernen (ML), Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die Kubernetes-Container-Orchestrierungsfunktionen für die Bereitstellung von KI‑/ML-Arbeitslasten auf H200-, H100-, A100- und L4-GPU-Hardware nutzen möchten. 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, 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.

Llama

Llama ist ein Large Language Model von Meta, das für eine Vielzahl von Aufgaben im Bereich der Verarbeitung natürlicher Sprache entwickelt wurde, einschließlich Textgenerierung, Übersetzung und Fragebeantwortung. GKE bietet die erforderliche Infrastruktur, um das verteilte Training und Bereitstellen von Modellen dieser Größenordnung zu unterstützen. Weitere Informationen finden Sie in der Llama-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.

Lernziele

  1. Bereiten Sie Ihre Umgebung mit einem GKE-Cluster im Autopilot- oder Standardmodus vor.
  2. Stellen Sie einen vLLM-Container in Ihrem Cluster bereit.
  3. Verwenden Sie vLLM, um Llama 4-Modelle ü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

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. 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.

    4. 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

    1. In the Google Cloud console, go to the IAM page.

      Zu IAM
    2. Wählen Sie das Projekt aus.
    3. Klicken Sie auf Zugriff erlauben.

    4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Dies ist in der Regel die E-Mail-Adresse eines Google-Kontos.

    5. Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
    6. Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
    7. 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 H100- und H200-GPUs hat. Weitere Informationen finden Sie unter GPU-Kontingent planen und GPU-Kontingent.

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:

  1. Klicken Sie auf Profil > Einstellungen > Zugriffstokens.
  2. Wählen Sie Neues Token aus.
  3. Geben Sie einen Namen Ihrer Wahl und eine Rolle von mindestens Read an.
  4. Wählen Sie Token generieren aus.
  5. 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:

  1. Starten Sie in der Google Cloud -Konsole eine Cloud Shell-Sitzung. Klicken Sie dazu in der Google Cloud -Konsole auf Symbol für die Cloud Shell-Aktivierung Cloud Shell aktivieren. Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.

  2. 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: 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 Llama 4-Modelle auf GPUs in einem GKE Autopilot- oder Standardcluster 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

  1. 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 H100-GPU.
    • CLUSTER_NAME: Der Name Ihres Clusters.

    Die Erstellung eines Clusters kann einige Minuten dauern.

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

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

    GKE erstellt einen einzelnen Knotenpool mit acht H100-GPUs mit 80 GB.

Kubernetes-Secret für Hugging Face-Anmeldedaten erstellen

Gehen Sie in Cloud Shell so vor:

  1. Konfigurieren Sie kubectl so, dass es mit Ihrem Cluster kommunizieren kann:

    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.

  2. 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 zuvor generierte Hugging Face-Token.

vLLM bereitstellen

In diesem Abschnitt stellen Sie den vLLM-Container für die Llama 4-Modelle bereit, die Sie verwenden möchten:

  • Llama 4 Maverick 17B-128E
  • Llama 4 Scout 17B-16E

In dieser Anleitung werden Kubernetes-Bereitstellungen 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.

Llama 4 Maverick 17B-128e

So richten Sie das Modell Llama 4 Maverick 17B-128E ein:

  1. Erstellen Sie das folgende vllm-llama4-maverick-17b-128e.yaml-Manifest:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Maverick-17B-128E
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        resources:
          requests:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=131072
        - --gpu-memory-utilization=0.95
        - --disable-log-stats
        - --dtype=auto
        - --kv-cache-dtype=auto
        - --max-num-seqs=64
        - --model=meta-llama/Llama-4-Maverick-17B-128E
        - --tensor-parallel-size=8
        env:
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Maverick-17B-128E'
        - 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-h200-141gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

  2. Wenden Sie das Manifest an:

    kubectl apply -f vllm-llama4-maverick-17b-128e.yaml

    In unserem Beispiel begrenzen wir das Kontextfenster auf 128 K, indem wir die Option --max-model-len=131072 vLLM verwenden.

Llama 4 Maverick 17B-128e-it

So stellen Sie das für die Anleitung abgestimmte Modell Llama 4 Maverick 17B-128e bereit:

  1. Erstellen Sie das folgende vllm-llama4-maverick-17b-128e-instruct.yaml-Manifest:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        resources:
          requests:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 157
            memory: 2067Gi
            ephemeral-storage: 850Gi
            nvidia.com/gpu : 8
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=131072
        - --gpu-memory-utilization=0.95
        - --disable-log-stats
        - --dtype=auto
        - --kv-cache-dtype=auto
        - --max-num-seqs=64
        - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct
        - --tensor-parallel-size=8
        env:
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct'
        - 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-h200-141gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

  2. Wenden Sie das Manifest an:

    kubectl apply -f vllm-llama4-maverick-17b-128e-instruct.yaml

    In unserem Beispiel begrenzen wir das Kontextfenster auf 128 K, indem wir die Option --max-model-len=131072 vLLM verwenden.

Llama 4 Maverick 17B-128e-it-fp8

So stellen Sie das Modell Llama 4 Maverick 17B-128e-Instruct-FP8 bereit:

  1. Erstellen Sie das folgende vllm-llama4-maverick-17b-128e-instruct-fp8.yaml-Manifest:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct-FP8
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        resources:
          requests:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=524288
        - --gpu-memory-utilization=0.90
        - --disable-log-stats
        - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8
        - --tensor-parallel-size=8
        env:
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8'
        - 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-h100-80gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

  2. Wenden Sie das Manifest an:

    kubectl apply -f vllm-llama4-maverick-17b-128e-instruct-fp8.yaml

    In unserem Beispiel begrenzen wir das Kontextfenster auf 512 K, indem wir die Option --max-model-len=524288 vLLM verwenden.

Llama 4 Scout 17B-16e

So stellen Sie das Modell Llama 4 Scout 17B-16E bereit:

  1. Erstellen Sie das folgende vllm-llama4-scout-17b-16e.yaml-Manifest:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Scout-17B-16E
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        resources:
          requests:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=262144
        - --limit_mm_per_prompt='image=5'
        - --disable-log-stats
        - --model=meta-llama/Llama-4-Scout-17B-16E
        - --tensor-parallel-size=8
        env:
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Scout-17B-16E'
        - 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-h100-80gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

  2. Wenden Sie das Manifest an:

    kubectl apply -f vllm-llama4-scout-17b-16e.yaml

    In unserem Beispiel begrenzen wir das Kontextfenster auf 256 K, indem wir die Option --max-model-len=262144 vLLM verwenden.

Llama 4 Scout 17B-16e-it

So stellen Sie das für die Anleitung abgestimmte Modell Llama 4 Scout 17B-16e Instruct bereit:

  1. Erstellen Sie das folgende vllm-llama4-scout-17b-16e-instruct.yaml-Manifest:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: llama-server
  template:
    metadata:
      labels:
        app: llama-server
        ai.gke.io/model: Llama-4-Scout-17B-16E-Instruct
        ai.gke.io/inference-server: vllm
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        resources:
          requests:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
          limits:
            cpu: 146
            memory: 1311Gi
            ephemeral-storage: 600Gi
            nvidia.com/gpu : 8
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --host=0.0.0.0
        - --port=7080
        - --swap-space=16
        - --max-model-len=1310720
        - --limit_mm_per_prompt='image=5'
        - --disable-log-stats
        - --model=meta-llama/Llama-4-Scout-17B-16E-Instruct
        - --tensor-parallel-size=8
        env:
        - name: MODEL_ID
          value: 'meta-llama/Llama-4-Scout-17B-16E-Instruct'
        - 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-h100-80gb
---
apiVersion: v1
kind: Service
metadata:
  name: llama-service
spec:
  selector:
    app: llama-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 7080
---
apiVersion: v1
kind: Secret
metadata:
  name: hf-secret
type: Opaque
stringData:
  hf_api_token: {{HF_TOKEN}}

  2. Wenden Sie das Manifest an:

    kubectl apply -f vllm-llama4-scout-17b-16e-instruct.yaml

    In unserem Beispiel begrenzen wir das Kontextfenster auf 1.280 K, indem wir die Option --max-model-len=1310720 vLLM verwenden.

Warten Sie, bis die Bereitstellung verfügbar ist:

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

So rufen Sie die Logs des laufenden Deployments auf:

kubectl logs -f -l app=llama-server

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

INFO:     Started server process [145]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
...
INFO 04-07 13:36:29 [async_llm.py:228] Added request chatcmpl-4149ea4cf35e48559f9f819dcdbbb23e.
INFO:     127.0.0.1:44018 - "POST /v1/chat/completions HTTP/1.1" 200 OK

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/llama-service 8080:8000

Die Ausgabe sieht etwa so aus:

Forwarding from 127.0.0.1:8080 -> 7080

Mithilfe von curl mit dem Modell interagieren

In diesem Abschnitt wird gezeigt, wie Sie einen einfachen Smoke Test durchführen, um das bereitgestellte Llama-Modell zu prüfen, das mithilfe von Anleitungen optimiert wurde. Ersetzen Sie bei anderen Modellen meta-llama/Llama-4-Scout-17B-16E durch den Namen des jeweiligen Modells.

In diesem Beispiel wird gezeigt, wie Sie das Llama 4 Scout 17B-16E-Modell mit reiner Texteingabe testen.

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

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-4-Scout-17B-16E",
    "messages": [{"role": "user", "content": "San Francisco is a"}],
    "max_tokens": 7,
    "temperature": 0
  }'

Die Ausgabe sieht etwa so aus:

"message":{"role":"assistant","reasoning_content":null,"content":"San Francisco is a city","tool_calls":[]}

Probleme beheben

  • Wenn Sie die Meldung Empty reply from server 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 die Meldung Connection refused angezeigt wird, prüfen Sie, ob die Portweiterleitung aktiv ist.

Modellleistung beobachten

Sie können die Modellleistung mithilfe der vLLM-Dashboard-Integration in Cloud Monitoring beobachten. In diesem Dashboard können Sie wichtige Leistungsmesswerte wie Tokendurchsatz, Anfragelatenz und Fehlerraten abrufen.

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

Sie können die Messwerte dann über das vLLM-Dashboard aufrufen. Informationen zur Verwendung von Google Cloud Managed Service for Prometheus zum Erfassen von Messwerten aus Ihrem Modell 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

Führen Sie den folgenden Befehl aus, damit Ihrem Google Cloud -Konto die in dieser Anleitung erstellten Ressourcen nicht 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