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

Autopilot Standard

Pour diffuser des grands modèles de langage (LLM) Gemma 4 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 B200, H100, RTX Pro 6000 ou L4.

Pour obtenir les pondérations du modèle Gemma 4, vous pouvez configurer le conteneur vLLM prédéfini pour les télécharger depuis le dépôt Hugging Face. Le conteneur peut également charger les pondérations du modèle à partir d'un stockage persistant existant, par exemple en mettant en cache vos buckets de modèle Cloud Storage sur une instance Google Cloud Managed Lustre.

Une fois les poids chargés, 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 H200, H100, A100 et L4. Pour en savoir plus sur les rôles courants et les exemples de tâches que nous citons dans le contenu Google Cloud , consultez Rôles utilisateur et tâches courantes de GKE.

Si vous avez besoin d'une plate-forme d'IA gérée unifiée conçue pour créer et diffuser rapidement des modèles de ML à moindre coût, nous vous recommandons d'essayer notre solution de déploiement Vertex AI.

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

Arrière-plan

Cette section décrit les principales technologies utilisées dans ce guide.

GPU

Les GPU vous permettent d'accélérer des charges de travail spécifiques exécutées sur vos nœuds, telles que le machine learning et le traitement de données. GKE fournit toute une gamme d'options de types de machines pour la configuration des nœuds, y compris les types de machines avec des GPU NVIDIA H200, H100, L4 et A100.

vLLM

vLLM est un framework de diffusion LLM Open Source hautement optimisé qui peut augmenter le débit de diffusion sur les GPU, avec des fonctionnalités telles que les suivantes :

Implémentation optimisée du transformateur avec PagedAttention
Traitement par lots continu pour améliorer le débit global de diffusion
Parallélisme des Tensors et diffusion distribuée sur plusieurs GPU

Pour en savoir plus, consultez la documentation vLLM.

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

Préparer votre environnement avec un cluster GKE en mode Autopilot ou Standard.
Déployer un conteneur vLLM sur votre cluster.
Utilisez vLLM pour diffuser le modèle Gemma 4 via curl et une interface de chat Web.

Avant de commencer

Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $de crédits sans frais pour exécuter, tester et déployer des charges de travail.

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

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

Enable the API

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

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

Enable the API

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 console Google Cloud , 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 console Google Cloud , 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'adresse e-mail d'un compte Google.
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.

Assurez-vous que votre projet dispose d'un quota suffisant pour les GPU L4. Pour en savoir plus, consultez À propos des GPU et Quotas d'allocation.

Préparer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées surGoogle Cloud. Les logiciels dont vous avez besoin pour ce tutoriel sont préinstallés sur Cloud Shell, y compris kubectl et gcloud CLI.

Pour configurer votre environnement avec Cloud Shell, procédez comme suit :

Dans la console Google Cloud , lancez une session Cloud Shell en cliquant sur Activer Cloud Shell dans la consoleGoogle Cloud . Une session s'ouvre dans le volet inférieur de la console Google Cloud .
Définissez les variables d'environnement par défaut :
```
gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME
```
Remplacez les valeurs suivantes :
- PROJECT_ID : ID de votre projet Google Cloud.
- REGION : région compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1 pour les GPU L4. Vous pouvez consulter les GPU disponibles dans chaque région.
- ZONE : zone compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1-b et us-central1-f pour les GPU RTX PRO 6000. Vous pouvez identifier les zones dans lesquelles les GPU sont disponibles.
- CLUSTER_NAME : nom du cluster

Créer et configurer des ressources Google Cloud

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 ou GKE Standard. Nous vous recommandons d'utiliser un cluster GKE Autopilot pour une expérience Kubernetes entièrement gérée. Pour choisir le mode de fonctionnement GKE le mieux adapté à vos charges de travail, consultez la section Choisir un mode de fonctionnement GKE.

Autopilot

Dans Cloud Shell, exécutez la commande suivante :

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

Remplacez les valeurs suivantes :

PROJECT_ID : ID de votre projet Google Cloud.
CONTROL_PLANE_LOCATION : région Compute Engine du plan de contrôle de votre cluster. Indiquez une région compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1 pour les GPU L4.
CLUSTER_NAME : nom du 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.

Standard

Dans Cloud Shell, exécutez la commande suivante pour créer un cluster GKE Standard :
```
gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --release-channel=rapid \
    --num-nodes=1
```
Remplacez les valeurs suivantes :
- PROJECT_ID : ID de votre projet Google Cloud.
- CONTROL_PLANE_LOCATION : région Compute Engine du plan de contrôle de votre cluster. Indiquez une région compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1 pour les GPU L4.
- CLUSTER_NAME : nom du cluster
La création du cluster peut prendre plusieurs minutes.

Pour créer un pool de nœuds pour votre cluster avec la taille de disque appropriée, exécutez la commande suivante :

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

GKE crée un pool de nœuds unique contenant un RTX PRO. 6 000 GPU pour chaque nœud.

Déployer des modèles Gemma 4 sur vLLM à l'aide des pondérations Hugging Face

Pour déployer des modèles Gemma 4 à l'aide de pondérations Hugging Face, appliquez un fichier manifeste de déploiement Kubernetes pour la taille de modèle sélectionnée. Un déploiement est un objet de l'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 télécharge automatiquement les poids depuis Hugging Face pour démarrer le moteur d'inférence vLLM.

Gemma 4 E2B-it

Suivez ces instructions pour déployer le modèle adapté aux instructions Gemma 4 E2B (entrée de texte uniquement).

Créez le fichier manifeste vllm-4-e2b-it.yaml suivant :

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

Appliquez le fichier manifeste :
```
kubectl apply -f vllm-4-e2b-it.yaml
```

Gemma 4 E4B-it

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

Créez le fichier manifeste vllm-4-e4b-it.yaml suivant :

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

Appliquez le fichier manifeste :
```
kubectl apply -f vllm-4-E4b-it.yaml
```
Dans notre exemple, nous limitons la fenêtre de contexte à 32 K à l'aide de l'option vLLM --max-model-len=32768. 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é de GPU plus importante.

Gemma 4 26B-A4B-it

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

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

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

Appliquez le fichier manifeste :
```
kubectl apply -f vllm-4-26b-a4b-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 la configuration de votre fichier manifeste et de votre pool de nœuds avec une capacité de GPU plus importante.

Gemma 4 31B-it

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

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

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

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é de GPU plus importante.

Validation

Attendez que le déploiement soit disponible :

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

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 Hugging Face disponible, configurez le transfert de port pour interagir avec le modèle.

Déployer Gemma affiné depuis Managed Lustre

Pour diffuser un modèle Gemma affiné (tel que Gemma 3 27B) déjà stocké sur une instance Google Cloud Managed Lustre, vous devez monter le PersistentVolumeClaim (PVC) correspondant sur le conteneur vLLM.

Prérequis

Assurez-vous de disposer d'un PVC existant dans votre cluster GKE qui se connecte à votre instance Lustre. Dans cet exemple, la PVC est nommée gemma-lustre-pvc.

Pour savoir comment créer un PVC et un PersistentVolume (PV) pour une instance existante, consultez Accéder à une instance Managed Lustre existante.

Procédure

Enregistrez le manifeste YAML suivant sous le nom vllm-lustre-gemma.yaml. Dans cet exemple, le déploiement installe le PVC Lustre sur /data et demande à vLLM de charger les pondérations du modèle à partir de ce chemin d'accès local.

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

Appliquez le fichier manifeste au cluster GKE :
```
kubectl apply -f vllm-lustre-gemma.yaml
```

Validation

Pour vérifier que le modèle a bien été chargé à partir du volume Lustre, consultez les journaux du pod pour la séquence de démarrage vLLM :

kubectl logs -l app=gemma-server

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

Le résultat ressemble à ce qui suit :

Forwarding from 127.0.0.1:8000 -> 8000

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-e4b-it par le nom du modèle concerné.

Cet exemple montre comment tester le modèle Gemma 4 E4B adapté aux instructions avec une entrée textuelle uniquement.

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

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

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
}

(Facultatif) Interagir avec le modèle via une interface de chat Gradio

Dans cette section, vous allez créer une application de chat Web qui vous permet d'interagir avec votre modèle adapté aux instructions. Par souci de simplicité, cette section ne décrit que l'approche de test utilisant le modèle 4B-it.

Gradio est une bibliothèque Python dotée d'un wrapper ChatInterface qui crée des interfaces utilisateur pour les chatbots.

Déployer l'interface de chat

Dans Cloud Shell, enregistrez le fichier manifeste suivant sous le nom gradio.yaml. Remplacez google/gemma-4-E4B-it par le nom du modèle Gemma 4 que vous avez utilisé dans votre déploiement.

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

Appliquez le fichier manifeste :
```
kubectl apply -f gradio.yaml
```

Attendez que le déploiement soit disponible :

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

Utiliser l'interface de chat

Dans Cloud Shell, exécutez la commande suivante :
```
kubectl port-forward service/gradio 8080:8080
```
Cela crée un transfert de port de Cloud Shell vers le service Gradio.
Cliquez sur le bouton Aperçu sur le Web qui se trouve en haut à droite de la barre des tâches Cloud Shell. Cliquez sur Preview on Port 8080 (Aperçu sur le port 8080). Un nouvel onglet s'ouvre dans le navigateur.
Interagissez avec Gemma via l'interface de chat Gradio. Ajoutez une requête et cliquez sur Envoyer.

Résoudre les problèmes

Si le message Empty reply from server s'affiche, il est possible que le conteneur n'ait pas terminé le téléchargement des données du modèle. Vérifiez à nouveau dans les journaux du pod le message Connected indiquant que le modèle est prêt à être diffusé.
Si Connection refused s'affiche, vérifiez que le transfert de port est actif.

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 :

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

Accéder à "Modèles déployés"
Pour afficher des informations sur un 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.
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 de 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.

Pour utiliser le tableau de bord dans Cloud Monitoring, vous devez activer Google Cloud Managed Service pour Prometheus, qui collecte les métriques de vLLM, dans votre cluster GKE. 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 conseils d'observabilité vLLM dans la documentation Cloud Monitoring.

Effectuer un nettoyage

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 soient facturées sur votre compte Google Cloud , exécutez la commande suivante :

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

Remplacez les valeurs suivantes :

CONTROL_PLANE_LOCATION : région Compute Engine du plan de contrôle de votre cluster.
CLUSTER_NAME : nom du cluster

Étapes suivantes

Apprenez-en plus sur les GPU dans GKE.
Découvrez comment utiliser Gemma avec vLLM sur d'autres accélérateurs, y compris les GPU A100 et H100, en affichant l'exemple de code dans GitHub.
Découvrez comment déployer des charges de travail GPU dans Autopilot.
Découvrez comment déployer des charges de travail GPU dans GKE Standard.
Explorez le dépôt GitHub et la documentation de vLLM.
Explorez Vertex AI Model Garden.
Découvrez comment exécuter des charges de travail d'IA/ML optimisées avec les fonctionnalités d'orchestration de plate-forme GKE.

Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec vLLM Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Arrière-plan

GPU

vLLM

Objectifs

Avant de commencer

Vérifier les rôles

Attribuer les rôles

Préparer votre environnement

Créer et configurer des ressources Google Cloud

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

Autopilot

Standard

Déployer des modèles Gemma 4 sur vLLM à l'aide des pondérations Hugging Face

Procédure

Gemma 4 E2B-it

Gemma 4 E4B-it

Gemma 4 26B-A4B-it

Gemma 4 31B-it

Validation

Déployer Gemma affiné depuis Managed Lustre

Prérequis

Procédure

Validation

Diffuser le modèle

Configurer le transfert de port

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

(Facultatif) Interagir avec le modèle via une interface de chat Gradio

Déployer l'interface de chat

Utiliser l'interface de chat

Résoudre les problèmes

Observer les performances du modèle

Effectuer un nettoyage

Supprimer les ressources déployées

Étapes suivantes

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