Mistral Small 4 mit GPUs in GKE mit vLLM bereitstellen

Wenn Sie Mistral-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 H100-GPUs bereitstellen.

Um das Modell „Mistral Small 4“ bereitzustellen, wird der vordefinierte vLLM-Container so konfiguriert, dass er Modellgewichte lädt. Gewichte werden aus Cloud Storage-Buckets geladen, die durch das Argument --model angegeben werden.

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, Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen zu nutzen, um KI‑/ML-Arbeitslasten auf H100-GPU-Hardware bereitzustellen.

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

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.

  1. Ihre Umgebung mit einem GKE-Cluster im Autopilot-Modus vorbereiten.
  2. Stellen Sie einen vLLM-Container in Ihrem Cluster bereit.
  3. vLLM verwenden, um das Mistral-Modell über die curl-Schnittstelle bereitzustellen.

Hinweis

  • In the Cloud de Confiance console, on the project selector page, select or create a Cloud de Confiance 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 Cloud de Confiance 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 Cloud de Confiance 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 Cloud de Confiance 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. Bei einem Nutzer in einem Mitarbeiteridentitätspool ist dies in der Regel dessen Kennung. Weitere Informationen erhalten Sie unter Mitarbeiteridentitätspool-Nutzer in IAM-Richtlinien darstellen oder von Ihrem Administrator.

    5. Klicken Sie auf Rolle auswählen und suchen Sie dann 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 H100-GPUs hat. Weitere Informationen finden Sie unter GPUs und Zuteilungskontingente.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie kubectl und die gcloud CLI, um Ressourcen zu verwalten, die aufCloud de Confiance by S3NSgehostet werden. Sie können sich mit der gcloud CLI autorisieren, um auf Cloud de Confiance by S3NSzuzugreifen.

Wenn Sie Ihre Umgebung mit der gcloud CLI einrichten möchten, legen Sie die Standardumgebungsvariablen in der gcloud CLI fest:

gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=u-france-east1
export CLUSTER_NAME=CLUSTER_NAME
export GSA_NAME=GSA_NAME
export KSA_NAME=KSA_NAME
export NAMESPACE=NAMESPACE
export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
export MODEL_BUCKET_NAME=MODEL_BUCKET_NAME

Ersetzen Sie die folgenden Werte:

  • PROJECT_ID: Ihre Cloud de Confiance Projekt-ID.
  • REGION: u-france-east1-Region, die H100-GPUs unterstützt. Hier finden Sie Informationen dazu, welche GPUs in welcher Region verfügbar sind.
  • CLUSTER_NAME: Der Name Ihres Clusters.
  • GSA_NAME: Der Name des Google-Dienstkontos, z. B. mistral-small-gsa.
  • KSA_NAME: Der Name des Kubernetes-ServiceAccount, z. B. mistral-small-ksa.
  • NAMESPACE: der Kubernetes-Namespace, z. B. default.
  • MODEL_BUCKET_NAME: Der Name des Cloud Storage-Bucket, in dem die Modellgewichte gespeichert werden. Er kann mit dem Namen des ausgewählten Modells identisch sein, z. B. mistral-small-4-119b-weights.

Cloud de Confiance -Ressourcen erstellen und konfigurieren

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

GKE-Cluster und -Knotenpool erstellen

Sie können Mistral auf GPUs in einem GKE Autopilot-Cluster bereitstellen. Autopilot-Cluster bieten eine vollständig verwaltete Kubernetes-Umgebung.

Führen Sie in der gcloud CLI den folgenden Befehl aus:

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

Ersetzen Sie die folgenden Werte:

  • PROJECT_ID: Ihre Cloud de Confiance Projekt-ID.
  • CLUSTER_NAME: Der Name Ihres Clusters.
  • REGION: Die Region, in der sich der Cluster befindet.

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

Cloud Storage-Bucket erstellen

  1. Führen Sie in der gcloud CLI den folgenden Befehl aus:

    gcloud storage buckets create gs://${MODEL_BUCKET_NAME} \
  --project=${PROJECT_ID} \
  --location=${REGION} \
  --uniform-bucket-level-access

    Dadurch wird ein Cloud Storage-Bucket zum Speichern der Modelldateien erstellt, die Sie von Hugging Face herunterladen.

  2. Modellgewichte herunterladen und hochladen:

    Sie müssen die Modellgewichte für Mistral Small 4 für die Versionen, die Sie bereitstellen möchten, abrufen (z.B. von Hugging Face oder anderen offiziellen Quellen). Organisieren Sie die heruntergeladenen Dateien lokal in Verzeichnissen. Beispiel:

    • ./mistral-small-4-119b-weights-local/ (mit allen Dateien für das Modell „Mistral Small 4“)

    Laden Sie diese Verzeichnisse mit den spezifischen Präfixen, die von den Bereitstellungsmanifesten erwartet werden, in Ihren Cloud Storage-Bucket hoch:

    # Upload files for the mistral-small-4 model
gcloud storage cp --recursive ./mistral-small-4-119b-weights-local/* gs://${MODEL_BUCKET_NAME}

    Diese Befehlsstruktur sorgt dafür, dass sich die Modelldateien an Pfaden wie gs://${MODEL_BUCKET_NAME}/config.json usw. befinden.

Workload Identity Federation for GKE für Cloud Storage-Zugriff konfigurieren

Damit Ihre Kubernetes-Pods sicher auf den Cloud Storage-Bucket mit den Modellgewichten zugreifen können, konfigurieren Sie die GKE Workload Identity-Föderation für GKE.

  1. Google-Dienstkonto (GSA) erstellen:

    gcloud iam service-accounts create ${GSA_NAME} \
  --project=${PROJECT_ID}

  2. GSA-E-Mail-Adresse ermitteln und exportieren:

    Das E-Mail-Format hängt davon ab, ob Ihre ${PROJECT_ID} auf eine Domain beschränkt ist (einen Doppelpunkt enthält).

    if [[ $PROJECT_ID == *:* ]]; then
  DOMAIN=$(echo $PROJECT_ID | cut -d: -f1)
  PROJ_NAME=$(echo $PROJECT_ID | cut -d: -f2)
  export GSA_EMAIL="${GSA_NAME}@${PROJ_NAME}.${DOMAIN}.s3ns.iam.gserviceaccount.com"
else
  export GSA_EMAIL="${GSA_NAME}@${PROJECT_ID}.s3ns.iam.gserviceaccount.com"
fi
  echo "Using GSA Email: ${GSA_EMAIL}"

  3. Erstellen Sie das Kubernetes-Dienstkonto (Kubernetes Service Account, KSA):

    Diese KSA wird in Ihrem Bereitstellungsmanifest verwendet.

    kubectl create serviceaccount ${KSA_NAME} --namespace ${NAMESPACE}

    Führen Sie den folgenden Befehl aus, um die Erstellung zu prüfen:

    kubectl get serviceaccounts --namespace ${NAMESPACE}

  4. Annotieren Sie das KSA, um es mit dem GSA zu verknüpfen:

    Diese Annotation teilt GKE mit, welches GSA das KSA imitieren kann.

    kubectl annotate serviceaccount ${KSA_NAME} \
  --namespace ${NAMESPACE} \
  iam.gke.io/gcp-service-account=${GSA_EMAIL}

  5. Gewähren Sie dem KSA die Berechtigung, die Identität des GSA zu übernehmen:

    Durch diese IAM-Bindung für das GSA kann das KSA als GSA fungieren.

    if [[ $PROJECT_ID == *:* ]]; then
  DOMAIN=$(echo $PROJECT_ID | cut -d: -f1)
  PROJ_NAME=$(echo $PROJECT_ID | cut -d: -f2)
  export WI_MEMBER="serviceAccount:${PROJ_NAME}.${DOMAIN}.s3ns.svc.id.goog[${NAMESPACE}/${KSA_NAME}]"
else
  export WI_MEMBER="serviceAccount:${PROJECT_ID}.s3ns.svc.id.goog[${NAMESPACE}/${KSA_NAME}]"
fi

gcloud iam service-accounts add-iam-policy-binding ${GSA_EMAIL} \
  --role roles/iam.workloadIdentityUser \
  --member="${WI_MEMBER}" \
  --project=${PROJECT_ID}

  6. Gewähren Sie der GSA die Berechtigung zum Lesen aus dem Bucket:

    Weisen Sie dem GSA die Rolle storage.objectViewer für den Bucket zu. 

    gcloud storage buckets add-iam-policy-binding gs://${MODEL_BUCKET_NAME} \
  --member="serviceAccount:${GSA_EMAIL}" \
  --role="roles/storage.objectViewer" \
  --project=${PROJECT_ID}

Mistral Small 4-Modell in vLLM bereitstellen

Wenn Sie das Modell „Mistral Small 4“ bereitstellen möchten, erstellen Sie Cloud Storage-Buckets für jedes Modell, um Modellgewichte zu speichern, und 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 automatisch eine Verbindung zu den Modellgewichten aus Cloud Storage-Buckets hergestellt, um die vLLM-Inferenz-Engine zu starten.

Mistral Small 4

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

  1. Erstellen Sie das folgende vllm-mistral-small.yaml-Manifest:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: a3-edgegpu-8g-nolssd
spec:
  priorities:
  - machineType: a3-edgegpu-8g-nolssd
    gpu:
      count: 8
      type: nvidia-h100-80gb
  nodePoolAutoCreation:
    enabled: true
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-mistral-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mistral-server
  template:
    metadata:
      labels:
        app: mistral-server
        ai.gke.io/model: mistral-small-4-119b-weights
        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: "48"
            memory: "200Gi"
            ephemeral-storage: "250Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "48"
            memory: "200Gi"
            ephemeral-storage: "250Gi"
            nvidia.com/gpu: "2"
        command: ["./entrypoint.sh"] # Use the image's entrypoint
        args:
        - "python"
        - "-m"
        - "vllm.entrypoints.api_server"
        - "--host=0.0.0.0"
        - "--port=8080"
        - "--model=gs://mistral-small-4-119b-weights" # YOUR Cloud Storage PATH
        - "--tensor-parallel-size=2"
        - "--enable-log-requests"
        - "--enable-chunked-prefill"
        - "--enable-prefix-caching"
        - "--enable-auto-tool-choice"
        - "--generation-config=auto"
        - "--tool-call-parser=mistral"
        - "--dtype=bfloat16"
        - "--max-num-seqs=256"
        - "--max-model-len=8192"
        - "--gpu-memory-utilization=0.90"
        - "--reasoning-parser=mistral"
        - "--trust-remote-code"
        ports:
        - containerPort: 8080
        env:
        - name: GOOGLE_CLOUD_UNIVERSE_DOMAIN
          value: ""
        - name: CLOUDSDK_CORE_UNIVERSE_DOMAIN
          value: ""
        - name: GCS_URI_ARG_KEY
          value: "model"
        - name: GCS_URI_ENV_KEY
          value: "AIP_STORAGE_URI"
        - name: LORA_ADAPTER_ARG_KEY
          value: "lora-modules"
        - name: HF_HUB_ENABLE_HF_TRANSFER
          value: "1"
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/compute-class: a3-edgegpu-8g-nolssd
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: mistral-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080

  2. Wenden Sie das Manifest an:

    kubectl apply -f vllm-mistral-small.yaml

    Wenn Sie die Kontextfenstergröße auf 16.000 Tokens begrenzen möchten, können Sie die vLLM-Option --max-model-len=16384 verwenden. Wenn Sie eine größere Kontextfenstergröße (bis zu 128.000 Tokens) benötigen, passen Sie Ihr Manifest und die Knotenpoolkonfiguration mit mehr GPU-Kapazität an.

Überprüfung

  1. Warten Sie, bis die Bereitstellung verfügbar ist:

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

  2. So rufen Sie die Logs des laufenden Deployments auf:

    kubectl logs -f -l app=mistral-server

    Die Deployment-Ressource lädt die Modelldaten für Mistral Small 4 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 Bereitstellung verfügbar ist, richten Sie die Portweiterleitung ein, um mit dem Modell zu interagieren.

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 svc/llm-service 8080:8080 --namespace default &

Die Ausgabe sieht in etwa so aus:

Forwarding from 127.0.0.1:8080 -> 8080

Mithilfe von curl mit dem Modell interagieren

In diesem Abschnitt wird gezeigt, wie Sie einen einfachen Smoke Test machen, um Ihre bereitgestellten Mistral-Modelle zu prüfen, die auf Anweisungen abgestimmt sind. Ersetzen Sie für andere Modelle mistral-small-4-119b-weights durch den Namen des jeweiligen Modells.

In diesem Beispiel wird gezeigt, wie Sie das auf Anweisungen abgestimmte Mistral-Modell mit reinen Texteingaben testen.

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

curl http://127.0.0.1:8080/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-Small-4-119B-2603-eagle",
    "prompt": "What is the capital of France?",
    "max_tokens": 50,
    "temperature": 0.7
  }'

Die Ausgabe sieht dann ungefähr so aus:

{
  "id": "cmpl-b5d649b6a2d7a330",
  "object": "text_completion",
  "created": 1781137490,
  "model": "openapi",
  "choices": [
    {
      "index": 0,
      "text": " This question is likely to have been asked millions of times, 
      and the answer is always the same: Paris. But why is Paris the capital 
      of France? The answer to this question is not as simple as 
      it may seem, as it involves a complex",
      "logprobs": null,
      "finish_reason": "length",
      "stop_reason": null,
      "token_ids": null,
      "prompt_logprobs": null,
      "prompt_token_ids": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 58,
    "completion_tokens": 50,
    "prompt_tokens_details": null
  },
  "kv_transfer_params": null
}

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:

  1. Rufen Sie in der Cloud de Confiance Console die Seite Bereitgestellte Modelle auf.

    Zu „Bereitgestellte Modelle“

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

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

    • Im 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 zusammengefasst.

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 Cloud de Confiance Konto die in dieser Anleitung erstellten Ressourcen in Rechnung gestellt werden:

gcloud container clusters delete CLUSTER_NAME \
    --location=REGION

Ersetzen Sie die folgenden Werte:

  • REGION: Die Region Ihres Clusters.
  • CLUSTER_NAME: Der Name Ihres Clusters.

Nächste Schritte