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

Autopilot Standard

Ce tutoriel explique comment déployer et diffuser un grand modèle de langage (LLM) Llama 4 à l'aide de GPU sur Google Kubernetes Engine (GKE) avec le framework de diffusion vLLM. Vous disposerez ainsi des bases nécessaires pour comprendre et explorer le déploiement pratique de LLM pour l'inférence dans un environnement Kubernetes géré. Vous déployez un conteneur prédéfini exécutant vLLM sur GKE. Vous configurez également GKE pour charger Llama depuis Hugging Face.

Conseil : Pour les déploiements en production sur GKE, nous vous recommandons vivement d'utiliser le guide de démarrage rapide de l'inférence afin d'obtenir des bonnes pratiques et des configurations personnalisées pour l'inférence de votre modèle.

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 :

• Mode Autopilot et mode Standard
• Disponibilité actuelle des versions des GPU
• GPU dans GKE

Arrière-plan

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

Llama

Llama est un grand modèle de langage de Meta conçu pour diverses tâches de traitement du langage naturel, y compris la génération de texte, la traduction et les systèmes de questions-réponses. GKE offre l'infrastructure requise pour répondre aux besoins d'entraînement et de diffusion distribués des modèles de cette envergure. Pour en savoir plus, consultez la documentation Llama.

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

1. Préparer votre environnement avec un cluster GKE en mode Autopilot ou Standard.
2. Déployer un conteneur vLLM sur votre cluster.
3. Utilisez vLLM pour diffuser les modèles Llama 4 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.

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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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

• 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 tous les rôles supplémentaires.
  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 H100 et H200. Pour en savoir plus, consultez Planifier le quota de GPU et Quota de GPU.

  Accéder au modèle

  Remarque : Vous devez signer le contrat de consentement pour utiliser Llama dans le dépôt Hugging Face.

  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:

  1. Cliquez sur Your Profile > Settings > Access Tokens (Votre profil > Paramètres > Jetons d'accès).
  2. Sélectionnez New Token (Nouveau jeton).
  3. Spécifiez le nom de votre choix et un rôle d'au moins Read.
  4. Sélectionnez Générer un jeton.
  5. 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 :

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

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

  Remarque : Vous devrez peut-être créer une réservation de capacité pour utiliser certains accélérateurs. Pour savoir comment réserver et consommer des ressources réservées, consultez la section Consommer des ressources zonales réservées.

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

  Vous pouvez diffuser des modèles Llama 4 sur des GPU dans un cluster GKE Autopilot ou 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

  1. 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 H100.
     • CLUSTER_NAME : nom du cluster

     La création du cluster peut prendre plusieurs minutes.

  2. 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-h100-80gb,count=1,gpu-driver-version=latest \
         --project=PROJECT_ID \
         --location=REGION \
         --node-locations=REGION-a \
         --cluster=CLUSTER_NAME \
         --machine-type=a3-highgpu-8g \
         --disk-type=pd-ssd \
         --num-nodes=1 \
         --disk-size=256
     

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

  Créer un secret Kubernetes pour les identifiants Hugging Face

  Dans Cloud Shell, procédez comme suit :

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

  2. 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 les modèles Llama 4 que vous souhaitez utiliser :

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

  Remarque : Nous vous déconseillons d'utiliser des modèles de base tels que Llama 3 8B pour les chatbots de production en raison de problèmes de sécurité. Pour en savoir plus sur les bonnes pratiques, consultez Instructions système pour la sécurité.

  Pour déployer le modèle, ce tutoriel utilise des déploiements Kubernetes. 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.

  Llama 4 Maverick 17B-128e

  Pour déployer le modèle Llama 4 Maverick 17B-128E, suivez ces instructions :

  1. Créez le fichier manifeste vllm-llama4-maverick-17b-128e.yaml suivant :

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: llama-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: llama-server
       template:
         metadata:
           labels:
             app: llama-server
             ai.gke.io/model: Llama-4-Maverick-17B-128E
             ai.gke.io/inference-server: vllm
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: 157
                 memory: 2067Gi
                 ephemeral-storage: 850Gi
                 nvidia.com/gpu : 8
               limits:
                 cpu: 157
                 memory: 2067Gi
                 ephemeral-storage: 850Gi
                 nvidia.com/gpu : 8
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --host=0.0.0.0
             - --port=7080
             - --swap-space=16
             - --max-model-len=131072
             - --gpu-memory-utilization=0.95
             - --disable-log-stats
             - --dtype=auto
             - --kv-cache-dtype=auto
             - --max-num-seqs=64
             - --model=meta-llama/Llama-4-Maverick-17B-128E
             - --tensor-parallel-size=8
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: 'meta-llama/Llama-4-Maverick-17B-128E'
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
               medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-h200-141gb
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llama-service
     spec:
       selector:
         app: llama-server
       type: ClusterIP
       ports:
       - protocol: TCP
         port: 8000
         targetPort: 7080
     ---
     apiVersion: v1
     kind: Secret
     metadata:
       name: hf-secret
     type: Opaque
     stringData:
       hf_api_token: {{HF_TOKEN}}

  2. Appliquez le fichier manifeste :

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

     Dans notre exemple, nous limitons la fenêtre de contexte à 128 K en utilisant l'option --max-model-len=131072 de vLLM.

  Llama 4 Maverick 17B-128e-it

  Pour déployer le modèle adapté aux instructions Llama 4 Maverick 17B-128e, suivez ces instructions :

  1. Créez le fichier manifeste vllm-llama4-maverick-17b-128e-instruct.yaml suivant :

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: llama-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: llama-server
       template:
         metadata:
           labels:
             app: llama-server
             ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct
             ai.gke.io/inference-server: vllm
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: 157
                 memory: 2067Gi
                 ephemeral-storage: 850Gi
                 nvidia.com/gpu : 8
               limits:
                 cpu: 157
                 memory: 2067Gi
                 ephemeral-storage: 850Gi
                 nvidia.com/gpu : 8
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --host=0.0.0.0
             - --port=7080
             - --swap-space=16
             - --max-model-len=131072
             - --gpu-memory-utilization=0.95
             - --disable-log-stats
             - --dtype=auto
             - --kv-cache-dtype=auto
             - --max-num-seqs=64
             - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct
             - --tensor-parallel-size=8
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct'
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
               medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-h200-141gb
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llama-service
     spec:
       selector:
         app: llama-server
       type: ClusterIP
       ports:
       - protocol: TCP
         port: 8000
         targetPort: 7080
     ---
     apiVersion: v1
     kind: Secret
     metadata:
       name: hf-secret
     type: Opaque
     stringData:
       hf_api_token: {{HF_TOKEN}}

  2. Appliquez le fichier manifeste :

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

     Dans notre exemple, nous limitons la fenêtre de contexte à 128 K en utilisant l'option --max-model-len=131072 de vLLM.

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

  Pour déployer le modèle Llama 4 Maverick 17B-128e-Instruct-FP8, suivez ces instructions :

  1. Créez le fichier manifeste vllm-llama4-maverick-17b-128e-instruct-fp8.yaml suivant :

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: llama-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: llama-server
       template:
         metadata:
           labels:
             app: llama-server
             ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct-FP8
             ai.gke.io/inference-server: vllm
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: 146
                 memory: 1311Gi
                 ephemeral-storage: 600Gi
                 nvidia.com/gpu : 8
               limits:
                 cpu: 146
                 memory: 1311Gi
                 ephemeral-storage: 600Gi
                 nvidia.com/gpu : 8
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --host=0.0.0.0
             - --port=7080
             - --swap-space=16
             - --max-model-len=524288
             - --gpu-memory-utilization=0.90
             - --disable-log-stats
             - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8
             - --tensor-parallel-size=8
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8'
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
               medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-h100-80gb
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llama-service
     spec:
       selector:
         app: llama-server
       type: ClusterIP
       ports:
       - protocol: TCP
         port: 8000
         targetPort: 7080
     ---
     apiVersion: v1
     kind: Secret
     metadata:
       name: hf-secret
     type: Opaque
     stringData:
       hf_api_token: {{HF_TOKEN}}

  2. Appliquez le fichier manifeste :

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

     Dans notre exemple, nous limitons la fenêtre de contexte à 512 Ko en utilisant l'option --max-model-len=524288 de vLLM.

  Llama 4 Scout 17B-16e

  Pour déployer le modèle Llama 4 Scout 17B-16E, suivez ces instructions :

  1. Créez le fichier manifeste vllm-llama4-scout-17b-16e.yaml suivant :

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: llama-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: llama-server
       template:
         metadata:
           labels:
             app: llama-server
             ai.gke.io/model: Llama-4-Scout-17B-16E
             ai.gke.io/inference-server: vllm
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: 146
                 memory: 1311Gi
                 ephemeral-storage: 600Gi
                 nvidia.com/gpu : 8
               limits:
                 cpu: 146
                 memory: 1311Gi
                 ephemeral-storage: 600Gi
                 nvidia.com/gpu : 8
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --host=0.0.0.0
             - --port=7080
             - --swap-space=16
             - --max-model-len=262144
             - --limit_mm_per_prompt
             - '{"image": 5}'
             - --disable-log-stats
             - --model=meta-llama/Llama-4-Scout-17B-16E
             - --tensor-parallel-size=8
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64        
             - name: MODEL_ID
               value: 'meta-llama/Llama-4-Scout-17B-16E'
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
               medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-h100-80gb
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llama-service
     spec:
       selector:
         app: llama-server
       type: ClusterIP
       ports:
       - protocol: TCP
         port: 8000
         targetPort: 7080
     ---
     apiVersion: v1
     kind: Secret
     metadata:
       name: hf-secret
     type: Opaque
     stringData:
       hf_api_token: {{HF_TOKEN}}

  2. Appliquez le fichier manifeste :

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

     Dans notre exemple, nous limitons la fenêtre de contexte à 256 K en utilisant l'option --max-model-len=262144 vLLM.

  Llama 4 Scout 17B-16e-it

  Pour déployer le modèle adapté aux instructions Llama 4 Scout 17B-16e Instruct, suivez ces instructions :

  1. Créez le fichier manifeste vllm-llama4-scout-17b-16e-instruct.yaml suivant :

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: llama-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: llama-server
       template:
         metadata:
           labels:
             app: llama-server
             ai.gke.io/model: Llama-4-Scout-17B-16E-Instruct
             ai.gke.io/inference-server: vllm
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: 146
                 memory: 1311Gi
                 ephemeral-storage: 600Gi
                 nvidia.com/gpu : 8
               limits:
                 cpu: 146
                 memory: 1311Gi
                 ephemeral-storage: 600Gi
                 nvidia.com/gpu : 8
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --host=0.0.0.0
             - --port=7080
             - --swap-space=16
             - --max-model-len=1310720
             - --limit_mm_per_prompt
             - '{"image": 5}'
             - --disable-log-stats
             - --model=meta-llama/Llama-4-Scout-17B-16E-Instruct
             - --tensor-parallel-size=8
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: 'meta-llama/Llama-4-Scout-17B-16E-Instruct'
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
               medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-h100-80gb
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llama-service
     spec:
       selector:
         app: llama-server
       type: ClusterIP
       ports:
       - protocol: TCP
         port: 8000
         targetPort: 7080
     ---
     apiVersion: v1
     kind: Secret
     metadata:
       name: hf-secret
     type: Opaque
     stringData:
       hf_api_token: {{HF_TOKEN}}

  2. Appliquez le fichier manifeste :

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

     Dans notre exemple, nous limitons la fenêtre de contexte à 1 280 K en utilisant l'option --max-model-len=1310720 de vLLM.

  Attendez que le déploiement soit disponible :

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

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

  kubectl logs -f -l app=llama-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:     Started server process [145]
  INFO:     Waiting for application startup.
  INFO:     Application startup complete.
  ...
  INFO 04-07 13:36:29 [async_llm.py:228] Added request chatcmpl-4149ea4cf35e48559f9f819dcdbbb23e.
  INFO:     127.0.0.1:44018 - "POST /v1/chat/completions HTTP/1.1" 200 OK
  

  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

  Pour configurer le transfert de port sur le modèle, exécutez la commande suivante :

  kubectl port-forward service/llama-service 8080:8000
  

  Le résultat ressemble à ce qui suit :

  Forwarding from 127.0.0.1:8080 -> 7080
  

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

  Cette section explique comment effectuer un test de fumée de base pour vérifier le modèle Llama adapté aux instructions déployé. Pour les autres modèles, remplacez meta-llama/Llama-4-Scout-17B-16E par le nom du modèle concerné.

  Cet exemple montre comment tester le modèle Llama 4 Scout 17B-16E avec une entrée de texte uniquement.

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

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

  Le résultat ressemble à ce qui suit :

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

  Réussite : Vous avez diffusé Llama avec succès en utilisant des GPU sur GKE avec vLLM. Vous pouvez maintenant interagir avec le modèle.

  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 le message 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 :

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

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

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

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