Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec vLLM

Pour diffuser Gemma 4 grands modèles de langage (LLM) Gemma sur Google Kubernetes Engine (GKE) avec le framework vLLM à l'aide de GPU, vous devez provisionner un cluster GKE avec des accélérateurs compatibles, tels que les GPU NVIDIA H100.

Pour diffuser les modèles Gemma 4, le conteneur vLLM prédéfini est configuré pour charger les pondérations du modèle. Les pondérations seront chargées à partir de buckets Cloud Storage (spécifiés par l'argument --model).

Une fois les pondérations chargées, le conteneur vLLM expose un point de terminaison d'API compatible avec OpenAI pour l'inférence à haut débit.

Ce tutoriel est destiné aux ingénieurs en machine learning (ML), aux administrateurs et opérateurs de plate-forme, ainsi qu'aux spécialistes des données et de l'IA qui souhaitent utiliser les fonctionnalités d'orchestration de conteneurs Kubernetes pour diffuser des charges de travail d'IA/ML sur du matériel GPU H100.

Avant de lire cette page, assurez-vous de connaître les éléments suivants :

Objectifs

Ce tutoriel fournit une base pour comprendre et explorer le déploiement pratique de LLM pour l'inférence dans un environnement Kubernetes géré.

  1. Préparez votre environnement avec un cluster GKE en mode Autopilot.
  2. Déployer un conteneur vLLM sur votre cluster.
  3. Utilisez vLLM pour diffuser le modèle Gemma 4 via l'interface curl.

Avant de commencer

  • 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

  • Assurez-vous de disposer des rôles suivants sur le projet : roles/container.admin, roles/iam.serviceAccountAdmin

    Vérifier les rôles

    1. Dans la Cloud de Confiance console, accédez à la page IAM.

      Accéder à IAM
    2. Sélectionnez le projet.

    3. Dans la colonne Compte principal, recherchez toutes les lignes qui vous identifient ou identifient un groupe dont vous faites partie. Pour savoir à quels groupes vous appartenez, contactez votre administrateur.

    4. Pour toutes les lignes qui vous spécifient ou vous incluent, consultez la colonne Rôle pour vous assurer que la liste inclut les rôles requis.

    Attribuer les rôles

    1. Dans la Cloud de Confiance console, accédez à la page IAM.

      Accéder à IAM
    2. Sélectionnez le projet.
    3. Cliquez sur Accorder l'accès.

    4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'identifiant associé à un utilisateur dans un pool d'identités de personnel. Pour en savoir plus, consultez Représenter les utilisateurs de pools de personnel dans les stratégies IAM ou contactez votre administrateur.

    5. Cliquez sur Sélectionner un rôle, puis recherchez le rôle.
    6. Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez tous les rôles supplémentaires.
    7. Cliquez sur Enregistrer.

Préparer votre environnement

Dans ce tutoriel, vous allez utiliser kubectl et gcloud CLI pour gérer les ressources hébergées sur Cloud de Confiance by S3NS. Vous pouvez vous authentifier avec gcloud CLI pour accéder à Cloud de Confiance by S3NS.

Pour configurer votre environnement avec gcloud CLI, procédez comme suit :

  1. Définissez les variables d'environnement par défaut dans gcloud CLI :

    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

    Remplacez les valeurs suivantes :

    • PROJECT_ID : votre Cloud de Confiance ID du projet.
    • REGION : région u-france-east1 compatible avec les GPU H100. Vous pouvez identifier les GPU disponibles dans chaque région.
    • CLUSTER_NAME : nom du cluster
    • GSA_NAME : nom du compte de service Google, par exemple gemma-gsa.
    • KSA_NAME : nom du compte de service Kubernetes, par exemple gemma-ksa.
    • NAMESPACE : espace de noms Kubernetes, par exemple default.
    • MODEL_BUCKET_NAME : nom du bucket Cloud Storage dans lequel les pondérations du modèle seront stockées. Il peut s'agir du même nom que le modèle sélectionné, par exemple gemma-4-26b-it.

Créer et configurer Cloud de Confiance des ressources

Suivez les instructions ci-dessous pour créer les ressources requises.

Créer un cluster GKE et un pool de nœuds

Vous pouvez diffuser les modèles Gemma sur des GPU dans un cluster GKE Autopilot. Le cluster Autopilot offre une expérience Kubernetes entièrement gérée.

Autopilot

Dans gcloud CLI, exécutez la commande suivante :

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

Remplacez les valeurs suivantes :

  • PROJECT_ID : votre Cloud de Confiance ID du projet.
  • CLUSTER_NAME : nom du cluster
  • REGION : région où se trouve votre cluster.

GKE crée un cluster Autopilot avec des nœuds de processeur et de GPU, à la demande des charges de travail déployées.

Créer un bucket Cloud Storage

  1. Dans gcloud CLI, exécutez la commande suivante :

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

    Cette opération crée un bucket Cloud Storage pour stocker les fichiers de modèle que vous téléchargez depuis Hugging Face.

  2. Téléchargez et importez les pondérations du modèle :

    Vous devez obtenir les pondérations du modèle Gemma pour les versions que vous comptez diffuser (par exemple, depuis Hugging Face ou d'autres sources officielles). Organisez les fichiers téléchargés localement dans des répertoires. Exemple :

    • ./gemma-4-26b-it-local/ (contenant tous les fichiers du modèle 26B IT)
    • ./gemma-4-31b-it-local/ (contenant tous les fichiers du modèle 31B IT)

    Importez ces répertoires dans votre bucket Cloud Storage avec les préfixes spécifiques attendus par les fichiers manifestes de déploiement :

    # Upload files for the 26B IT model
gcloud storage cp --recursive ./gemma-4-26b-it-local/* gs://${MODEL_BUCKET_NAME}

# Upload files for the 31B IT model
gcloud storage cp --recursive ./gemma-4-31b-it-local/* gs://${MODEL_BUCKET_NAME}

    Cette structure de commande garantit que les fichiers du modèle se trouvent dans des chemins d'accès tels que gs://${MODEL_BUCKET_NAME}/config.json, etc.

Configurer Workload Identity pour l'accès à Cloud Storage

Pour permettre à vos pods Kubernetes d'accéder de manière sécurisée au bucket Cloud Storage contenant les pondérations du modèle, vous allez configurer GKE Workload Identity.

  1. Créez le compte de service Google (GSA) :

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

  2. Déterminez et exportez l'adresse e-mail du GSA :

    Le format de l'adresse e-mail dépend du fait que votre ${PROJECT_ID} soit à l'échelle du domaine (contient un signe deux-points).

    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. Créez le compte de service Kubernetes (KSA) :

    Ce KSA est utilisé dans votre fichier manifeste de déploiement.

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

    Vérifier la création

    kubectl get serviceaccounts --namespace ${NAMESPACE}

  4. Annotez le KSA pour l'associer au GSA :

    Cette annotation indique à GKE quel GSA le KSA peut emprunter.

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

  5. Accordez au KSA l'autorisation d'emprunter l'identité du GSA :

    Cette liaison IAM sur le GSA permet au KSA d'agir en tant que GSA.

    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. Accordez au GSA l'autorisation de lire depuis le bucket :

    Accordez au GSA le rôle storage.objectViewer sur le bucket.

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

Déployer les modèles Gemma 4 sur vLLM

Pour déployer les modèles Gemma 4, créez des buckets Cloud Storage pour chaque modèle afin de stocker les pondérations du modèle, puis appliquez un fichier manifeste de déploiement Kubernetes pour la taille de modèle sélectionnée. Un déploiement est un objet d'API Kubernetes qui vous permet d'exécuter plusieurs instances dupliquées de pods répartis entre les nœuds d'un cluster.

Procédure

L'application de ce fichier manifeste extrait l'image de conteneur vLLM, demande un GPU NVIDIA et se connecte automatiquement aux pondérations du modèle à partir des buckets Cloud Storage pour démarrer le moteur d'inférence vLLM.

Gemma 4 26B-A4B-it

Suivez ces instructions pour déployer le modèle adapté aux instructions Gemma 4 26B-A4B.

  1. Créez le fichier manifeste vllm-4-26b-a4b-it.yaml suivant :

    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-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: ["./entrypoint.sh"] # Use the image's entrypoint
        args:
        - "python"
        - "-m"
        - "vllm.entrypoints.api_server"
        - "--host=0.0.0.0"
        - "--port=8080"
        - "--model=gs://gemma-4-26b-it" # YOUR Cloud Storage PATH
        - "--tensor-parallel-size=1"
        - "--max-num-seqs=128"
        - "--gpu-memory-utilization=0.9"
        - "--limit_mm_per_prompt.image=1"
        - "--enable-auto-tool-choice"
        - "--tool-call-parser=gemma4"
        - "--reasoning-parser=gemma4"
        ports:
        - containerPort: 8080
        env:
        - name: GOOGLE_CLOUD_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - name: CLOUDSDK_CORE_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - 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: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080

  2. Appliquez le fichier manifeste :

    kubectl apply -f vllm-4-26b-a4b-it.yaml

    Si vous le souhaitez, vous pouvez limiter la taille de la fenêtre de contexte à 16 K en utilisant l'option vLLM --max-model-len=16384. Si vous souhaitez une taille de fenêtre de contexte plus grande (jusqu'à 128 K), ajustez votre fichier manifeste et la configuration du pool de nœuds avec une capacité GPU plus importante.

Gemma 4 31B-it

Suivez ces instructions pour déployer le modèle adapté aux instructions Gemma 4 31B.

  1. Créez le fichier manifeste vllm-4-31b-it.yaml suivant :

    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-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: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["./entrypoint.sh"] # Use the image's entrypoint
        args:
        - "python"
        - "-m"
        - "vllm.entrypoints.api_server"
        - "--host=0.0.0.0"
        - "--port=8080"
        - "--model=gs://gemma-4-31b-it" # YOUR Cloud Storage PATH
        - "--tensor-parallel-size=1"
        - "--max-num-seqs=128"
        - "--gpu-memory-utilization=0.9"
        - "--limit_mm_per_prompt.image=1"
        - "--enable-auto-tool-choice"
        - "--tool-call-parser=gemma4"
        - "--reasoning-parser=gemma4"
        ports:
        - containerPort: 8080
        env:
        - name: GOOGLE_CLOUD_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - name: CLOUDSDK_CORE_UNIVERSE_DOMAIN
          value: "s3nsapis.fr"
        - 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: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080

  2. Appliquez le fichier manifeste :

    kubectl apply -f vllm-4-31b-it.yaml

    Dans notre exemple, nous limitons la taille de la fenêtre de contexte à 16 K en utilisant l'option vLLM --max-model-len=16384. Si vous souhaitez une taille de fenêtre de contexte plus grande (jusqu'à 128 K), ajustez votre fichier manifeste et la configuration du pool de nœuds avec une capacité GPU plus importante.

Validation

  1. Attendez que le déploiement soit disponible :

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

  2. Affichez les journaux du déploiement en cours d'exécution :

    kubectl logs -f -l app=gemma-server

    La ressource Déploiement télécharge les données du modèle Gemma. Ce processus peut prendre quelques minutes. Le résultat ressemble à ce qui suit :

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

Une fois le déploiement disponible, configurez le transfert de port pour interagir avec le modèle.

Diffuser le modèle

Dans cette section, vous allez interagir avec le modèle. Assurez-vous que le modèle est entièrement téléchargé avant de continuer.

Configurer le transfert de port

Exécutez la commande suivante pour configurer le transfert de port sur le modèle :

kubectl port-forward svc/llm-service 8080:8080 --namespace default &

Le résultat ressemble à ce qui suit :

Forwarding from 127.0.0.1:8080 -> 8080

Interagir avec le modèle à l'aide de curl

Cette section explique comment effectuer un test de fumée de base pour vérifier les modèles Gemma 4 adaptés aux instructions déployés. Pour les autres modèles, remplacez gemma-4-26B-A4B-it par le nom du modèle correspondant.

Cet exemple montre comment tester le modèle adapté aux instructions Gemma 4 26B avec une entrée en texte seul.

Dans une nouvelle session de terminal, utilisez curl pour discuter avec votre modèle :

curl http://127.0.0.1:8080/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
}'

La sortie ressemble à ceci :

{
  "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
}

Résoudre les problèmes

Observer les performances du modèle

Pour afficher les tableaux de bord des métriques d'observabilité d'un modèle, procédez comme suit :

  1. Dans la Cloud de Confiance console, accédez à la page Modèles déployés.

    Accéder à la page "Modèles déployés"

  2. Pour afficher des informations sur le déploiement spécifique, y compris ses métriques, ses journaux et ses tableaux de bord, cliquez sur le nom du modèle dans la liste.

  3. Sur la page d'informations sur le modèle, cliquez sur l'onglet Observabilité pour afficher les tableaux de bord suivants. Si vous y êtes invité, cliquez sur Activer pour activer la collecte de métriques pour le cluster.

    • Le tableau de bord Utilisation de l'infrastructure affiche les métriques d'utilisation.
    • Le tableau de bord DCGM affiche les métriques DCGM.
    • Si vous utilisez vLLM, le tableau de bord Performances du modèle est disponible et affiche les métriques concernant les performances du modèle vLLM.

Vous pouvez également afficher les métriques dans l'intégration du tableau de bord vLLM dans Cloud Monitoring. Ces métriques sont agrégées pour tous les déploiements vLLM sans filtres prédéfinis.

vLLM expose les métriques au format Prometheus par défaut. Vous n'avez pas besoin d'installer d'exportateur supplémentaire. Pour savoir comment utiliser Google Cloud Managed Service pour Prometheus afin de collecter des métriques à partir de votre modèle, consultez les vLLM vLLM dans la documentation Cloud Monitoring.

Libérer de l'espace

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer les ressources déployées

Pour éviter que les ressources que vous avez créées dans ce guide ne soient facturées sur votre Cloud de Confiance compte, exécutez la commande suivante :

gcloud container clusters delete CLUSTER_NAME \
    --location=REGION

Remplacez les valeurs suivantes :

  • REGION : région de votre cluster.
  • CLUSTER_NAME : nom du cluster

Étape suivante