Cette page a été traduite par l'API Cloud Translation.

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

Ce tutoriel explique comment déployer et diffuser un grand modèle de langage (LLM) Gemma 3 à l'aide de GPU sur Google Kubernetes Engine (GKE) avec le framework de diffusion vLLM. Cela vous permet de comprendre et d'explorer le déploiement pratique d'un LLM pour l'inférence dans un environnement Kubernetes géré. Vous déployez un conteneur prédéfini qui exécute vLLM sur GKE. Vous configurez également GKE pour charger les poids Gemma 1B, 4B, 12B et 27B à partir de Hugging Face.

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/de 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 la section Rôles utilisateur et tâches courantes de l'utilisateur dans GKE Enterprise.

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.

Gemma

Gemma est un ensemble de modèles multimodaux d'intelligence artificielle (IA) générative, légers et disponibles publiquement, publiés sous licence ouverte. Ces modèles d'IA sont disponibles pour s'exécuter dans vos applications, votre matériel, vos appareils mobiles ou vos services hébergés. Gemma 3 introduit la multimodalité et prend en charge les entrées en langage visuel et les sorties textuelles. Elle gère des fenêtres de contexte pouvant contenir jusqu'à 128 000 jetons et est compatible avec plus de 140 langues. Gemma 3 offre également des fonctionnalités mathématiques, de raisonnement et de chat améliorées, y compris des sorties structurées et l'appel de fonction.

Vous pouvez utiliser les modèles Gemma pour la génération de texte, ou vous pouvez également les ajuster pour des tâches spécialisées.

Pour en savoir plus, consultez la documentation Gemma.

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:

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

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 3 via curl et une interface de chat Web.

Avant de commencer

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.
  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. Dans la liste Sélectionner un rôle, sélectionnez un rôle.
6. Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
7. Cliquez sur Enregistrer.

Créez un compte Hugging Face si vous n'en possédez pas.
Assurez-vous que votre projet dispose d'un quota suffisant pour les GPU L4. Pour en savoir plus, consultez les pages À propos des GPU et Quotas d'allocation.

Accéder au modèle

Pour accéder au modèle via Hugging Face, vous avez besoin d'un jeton Hugging Face.

Pour générer un nouveau jeton si vous n'en possédez pas, procédez comme suit:

Cliquez sur Your Profile > Settings > Access Tokens (Votre profil > Paramètres > Jetons d'accès).
Sélectionnez New Token (Nouveau jeton).
Spécifiez le nom de votre choix et un rôle d'au moins Read.
Sélectionnez Générer un jeton.
Copiez le jeton dans votre presse-papiers.

Préparer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées surGoogle Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin pour ce tutoriel, 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 console Google 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
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=CLUSTER_NAME
export HF_TOKEN=HF_TOKEN
```
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.
- CLUSTER_NAME : nom du cluster
- HF_TOKEN: jeton Hugging Face que vous avez généré précédemment.

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

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

Gemma 3 1B

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

GKE crée un pool de nœuds unique contenant un GPU L4 pour chaque nœud.

Gemma 3 4B

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

GKE crée un pool de nœuds unique contenant un GPU L4 pour chaque nœud.

Gemma 3 12B

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

GKE crée un pool de nœuds unique contenant quatre GPU L4 pour chaque nœud.

Gemma 3 27B

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

GKE crée un pool de nœuds unique contenant un GPU A100 80 Go.

Créer un secret Kubernetes pour les identifiants Hugging Face

Dans Cloud Shell, procédez comme suit :

Configurez kubectl pour qu'il puisse communiquer avec votre cluster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=REGION
```
Remplacez les valeurs suivantes :
- REGION : 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

Créez un secret Kubernetes contenant le jeton Hugging Face:

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

Remplacez HF_TOKEN par le jeton Hugging Face que vous avez généré précédemment.

Déployer vLLM

Dans cette section, vous allez déployer le conteneur vLLM pour diffuser le modèle Gemma que vous souhaitez utiliser. Pour déployer le modèle, ce tutoriel utilise des déploiements Kubernetes. Un déploiement est un objet d'API Kubernetes qui vous permet d'exécuter plusieurs réplicas de pods répartis entre les nœuds d'un cluster.

Gemma 3 1B-it

Suivez ces instructions pour déployer le modèle adapté aux instructions Gemma 3 1B (entrée textuelle uniquement).

Créez le fichier manifeste vllm-3-1b-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-3-1b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01
        resources:
          requests:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        - --host=0.0.0.0
        - --port=8000
        env:
        - name: MODEL_ID
          value: google/gemma-3-1b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Appliquez le fichier manifeste :
```
kubectl apply -f vllm-3-1b-it.yaml
```

Gemma 3 4B-it

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

Créez le fichier manifeste vllm-3-4b-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-3-4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01
        resources:
          requests:
            cpu: "2"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "2"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=32768
        - --max-num-seqs=4
        env:
        - name: MODEL_ID
          value: google/gemma-3-4b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Appliquez le fichier manifeste :
```
kubectl apply -f vllm-3-4b-it.yaml
```
Dans notre exemple, nous limitons la fenêtre de contexte à 32 Ko à l'aide de l'option vLLM --max-model-len=32768. Si vous souhaitez augmenter la taille de la fenêtre de contexte (jusqu'à 128 k) : ajustez votre fichier manifeste et la configuration du pool de nœuds avec une capacité de GPU plus importante.

Gemma 3 12B-it

Suivez ces instructions pour déployer le modèle adapté aux instructions Gemma 3 12B.

Créez le fichier manifeste vllm-3-12b-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-3-12b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01
        resources:
          requests:
            cpu: "4"
            memory: "32Gi"
            ephemeral-storage: "32Gi"
            nvidia.com/gpu: "2"
          limits:
            cpu: "4"
            memory: "32Gi"
            ephemeral-storage: "32Gi"
            nvidia.com/gpu: "2"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=2
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=16384
        - --max-num-seqs=4
        env:
        - name: MODEL_ID
          value: google/gemma-3-12b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Appliquez le fichier manifeste :
```
kubectl apply -f vllm-3-12b-it.yaml
```
Dans notre exemple, nous limitons la taille de la fenêtre de contexte à 16 Ko à l'aide de l'option vLLM --max-model-len=16384. Si vous souhaitez augmenter la taille de la fenêtre de contexte (jusqu'à 128 k jetons), ajustez la configuration de votre fichier manifeste et de votre pool de nœuds pour augmenter la capacité de votre GPU.

Gemma 3 27B-it

Suivez ces instructions pour déployer le modèle adapté aux instructions Gemma 3 27B.

Créez le fichier manifeste vllm-3-27b-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-3-27b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01
        resources:
          requests:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "120Gi"
            nvidia.com/gpu : "1"
          limits:
            cpu: "10"
            memory: "128Gi"
            ephemeral-storage: "120Gi"
            nvidia.com/gpu : "1"
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        - --host=0.0.0.0
        - --port=8000
        - --swap-space=16
        - --gpu-memory-utilization=0.95
        - --max-model-len=32768
        - --max-num-seqs=4
        env:
        - name: MODEL_ID
          value: google/gemma-3-27b-it
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-a100-80gb
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Appliquez le fichier manifeste :
```
kubectl apply -f vllm-3-27b-it.yaml
```
Dans notre exemple, nous limitons la taille de la fenêtre de contexte à 32 Ko à l'aide de l'option vLLM --max-model-len=32768. Si vous souhaitez augmenter la taille de la fenêtre de contexte (jusqu'à 128 k jetons), ajustez votre fichier manifeste et la configuration du pool de nœuds avec une capacité de GPU plus importante.

Un pod du cluster télécharge les pondérations du modèle à partir de Hugging Face et lance le moteur de diffusion.

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. Ce processus peut prendre quelques minutes. Le résultat ressemble à ce qui suit :

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

Assurez-vous que le modèle est entièrement téléchargé avant de passer à la section suivante.

Diffuser le modèle

Dans cette section, vous allez interagir avec le modèle.

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 adaptés aux instructions Gemma 3 déployés. Pour les autres modèles, remplacez gemma-3-4b-it par le nom du modèle concerné.

Cet exemple montre comment tester le modèle adapté aux instructions Gemma 3 4B 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-3-4b-it",
    "messages": [
        {
          "role": "user",
          "content": "Why is the sky blue?"
        }
    ]
}'

La sortie ressemble à ceci :

{
    "id": "chatcmpl-e4a2e624bea849d9b09f838a571c4d9e",
    "object": "chat.completion",
    "created": 1741763029,
    "model": "google/gemma-3-4b-it",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "reasoning_content": null,
                "content": "Okay, let's break down why the sky appears blue! It's a fascinating phenomenon rooted in physics, specifically something called **Rayleigh scattering**. Here's the explanation: ...",
                "tool_calls": []
            },
            "logprobs": null,
            "finish_reason": "stop",
            "stop_reason": 106
        }
    ],
    "usage": {
        "prompt_tokens": 15,
        "total_tokens": 668,
        "completion_tokens": 653,
        "prompt_tokens_details": null
    },
    "prompt_logprobs": null
}

(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-2-9b-it par google/gemma-3-4b-it ou par un autre nom de modèle Gemma 3 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.4
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/v1/chat/completions"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "openai-chat"
        - name: MODEL_ID
          value: "google/gemma-2-9b-it"
        - name: DISABLE_SYSTEM_MESSAGE
          value: "true"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 7860
  type: ClusterIP

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 observer les performances du modèle, vous pouvez utiliser l'intégration du tableau de bord vLLM dans Cloud Monitoring. Ce tableau de bord vous permet d'afficher des métriques de performances critiques telles que le débit des jetons, la latence des requêtes et les taux d'erreur.

Pour utiliser le tableau de bord vLLM, 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 un exportateur supplémentaire.

Vous pouvez ensuite afficher les métriques à l'aide du tableau de bord vLLM. Pour en savoir plus sur l'utilisation de Google Cloud Managed Service pour Prometheus afin de collecter des métriques à partir de votre modèle, consultez les conseils d'observabilité de la 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 ne soient facturées sur votre compte Google Cloud , exécutez la commande suivante:

gcloud container clusters delete CLUSTER_NAME \
    --region=REGION

Remplacez les valeurs suivantes :

REGION : 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

É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

Gemma

GPU

vLLM

Objectifs

Avant de commencer

Check for the roles

Grant the roles

Accéder au modèle

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

Gemma 3 1B

Gemma 3 4B

Gemma 3 12B

Gemma 3 27B

Créer un secret Kubernetes pour les identifiants Hugging Face

Déployer vLLM

Gemma 3 1B-it

Gemma 3 4B-it

Gemma 3 12B-it

Gemma 3 27B-it

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