Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec Triton et TensorRT-LLM

Autopilot Standard

---

Ce tutoriel explique comment déployer et diffuser un grand modèle de langage (LLM) Gemma à l'aide de GPU sur Google Kubernetes Engine (GKE) avec la pile de diffusion NVIDIA Triton et TensorRT-LLM. 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 avec Triton et TensorRT-LLM sur GKE. Vous configurez également GKE pour charger les pondérations Gemma 2B et 7B.

Conseil : Pour les déploiements en production sur GKE, nous vous recommandons vivement d'utiliser le 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 LLM sur du matériel GPU 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 l'utilisateur dans GKE Enterprise.

Si vous avez besoin d'une plate-forme d'IA gérée unifiée 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.

Gemma

Gemma est un ensemble de modèles 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. Vous pouvez utiliser les modèles Gemma pour la génération de texte, mais 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 H100, L4 et A100.

TensorRT-LLM

NVIDIA TensorRT-LLM (TRT-LLM) est un kit d'outils doté d'une API Python permettant d'assembler des solutions optimisées afin de définir des LLM et de créer des moteurs TensorRT qui effectuent des inférences de manière efficace sur les GPU NVIDIA. TensorRT-LLM inclut des fonctionnalités telles que :

• Implémentation optimisée du transformateur avec fusions des couches, mise en cache d'activation, réutilisation du tampon de mémoire et PagedAttention
• Traitement par lot en vol ou continu pour améliorer le débit global de diffusion
• Parallélisme Tensor et parallélisme des pipelines pour une diffusion distribuée sur plusieurs GPU
• Quantification (FP16, FP8, INT8)

Pour en savoir plus, consultez la documentation de TensorRT-LLM.

Triton

NVIDIA Triton Inference Server est un serveur d'inférence Open Source pour les applications d'IA et de ML. Triton accepte une inférence hautes performances sur les GPU NVIDIA et les processeurs avec des backends optimisés, y compris TensorRT et TensorRT-LLM. Triton inclut des fonctionnalités telles que :

• Inférence multi-GPU et multinœud
• Exécution simultanée de plusieurs modèles
• Assemblage ou chaînage du modèle
• Traitement par lot statique, dynamique et continu ou en vol des requêtes de prédiction

Pour en savoir plus, consultez la documentation de Triton.

Objectifs

1. Préparez votre environnement avec un cluster GKE en mode Autopilot.
2. Déployer un conteneur avec Triton et TritonRT-LLM sur votre cluster.
3. Utiliser Triton et TensorRT-LLM pour diffuser le modèle Gemma 2B ou 7B via curl.

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.

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

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.

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

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 tous les rôles supplémentaires.
  7. Cliquez sur Enregistrer.
  • Créez un compte Kaggle, 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.

  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
     

     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

  Accéder au modèle

  Pour accéder aux modèles Gemma, vous devez vous connecter à la plate-forme Kaggle et obtenir un jeton d'API Kaggle.

  Signer le contrat de consentement de la licence

  Vous devez signer le contrat de consentement pour utiliser Gemma. Procédez comme suit :

  1. Accédez à la page d'autorisation du modèle sur Kaggle.com.
  2. Connectez-vous à Kaggle si vous ne l'avez pas déjà fait.
  3. Cliquez sur Demande d'accès.
  4. Dans la section Choose Account for Consent (Choisir un compte pour le consentement), sélectionnez Verify via Kaggle Account (Vérifier via un compte Kaggle) pour utiliser votre compte Kaggle pour le consentement.
  5. Acceptez les Conditions d'utilisation du modèle.

  Générer un jeton d'accès

  Pour accéder au modèle via Kaggle, vous avez besoin d'un jeton d'API Kaggle. Pour générer un nouveau jeton si vous n'en possédez pas, procédez comme suit :

  1. Dans votre navigateur, accédez aux paramètres Kaggle.
  2. Dans la section "API", cliquez sur Créer un jeton.

  Un fichier nommé kaggle.json est téléchargé.

  Importer le jeton d'accès dans Cloud Shell

  Dans Cloud Shell, importez le jeton d'API Kaggle dans votre projet Google Cloud :

  1. Dans Cloud Shell, cliquez sur Plus > Importer.
  2. Sélectionnez "Fichier", puis cliquez sur Sélectionner des fichiers.
  3. Ouvrez le fichier kaggle.json.
  4. Cliquez sur Importer.

  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 l'utilisation de 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 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 \
    --cluster-version=1.28
  

  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

  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=REGION-a \
         --workload-pool=PROJECT_ID.svc.id.goog \
         --release-channel=rapid \
         --machine-type=e2-standard-4 \
         --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.

  2. Exécutez la commande suivante pour créer un pool de nœuds pour votre cluster :

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

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

  Créer un secret Kubernetes pour les identifiants Kaggle

  Dans ce tutoriel, vous utilisez un secret Kubernetes pour les identifiants Kaggle.

  Dans Cloud Shell, procédez comme suit :

  1. Configurez kubectl de manière à 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 pour stocker les identifiants Kaggle:

     kubectl create secret generic kaggle-secret \
         --from-file=kaggle.json \
         --dry-run=client -o yaml | kubectl apply -f -
     

  Créer une ressource PersistentVolume pour stocker des points de contrôle

  Dans cette section, vous allez créer un objet PersistentVolume sauvegardé par un disque persistant pour stocker les points de contrôle du modèle.

  1. Créez le fichier manifeste trtllm_checkpoint_pv.yaml suivant :

     apiVersion: v1
     kind: PersistentVolumeClaim
     metadata:
       name: model-data
     spec:
       accessModes:
       - ReadWriteOnce
       resources:
         requests:
           storage: 100G

  2. Appliquez le fichier manifeste :

     kubectl apply -f trtllm_checkpoint_pv.yaml
     

  Télécharger les fichiers du moteur TensorRT-LLM pour Gemma

  Dans cette section, vous allez exécuter un Job Kubernetes pour effectuer les tâches suivantes :

  • Téléchargez les fichiers du moteur TensorRT-LLM et stockez-les dans le PersistentVolume que vous avez créé précédemment.
  • Préparez les fichiers de configuration pour déployer le modèle sur le serveur Triton.

  Dans Kubernetes, un contrôleur Job crée un ou plusieurs pods et s'assure qu'ils exécutent correctement une tâche spécifique.

  Cette procédure peut prendre quelques minutes.

  Gemma 2B-it

  Le moteur TensorRT-LLM est créé à partir du point de contrôle PyTorch de Gemma du modèle Gemma 2B-it (adapté aux instructions) à l'aide de l'activation bfloat16, de GPU L4 ciblés d'une longueur de séquence d'entrée égale à 2 048 et d'une longueur de séquence de sortie égale à 1 024. Vous pouvez déployer le modèle sur un seul GPU L4.

  1. Créez le fichier manifeste job-download-gemma-2b.yaml suivant :

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: fetch-model-scripts
     data:
       fetch_model.sh: |-
         #!/usr/bin/bash -x
         pip install kaggle --break-system-packages && \
     
         MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
         VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
         ACTIVATION_DTYPE=bfloat16 && \
     
         TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
         ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
         TRITON_MODEL_REPO=/data/triton/model_repository && \
     
         mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
         mkdir -p ${ENGINE_PATH} && \
         mkdir -p ${TRITON_MODEL_REPO} && \
     
         kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
         rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
         find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
         find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \
     
         # copying configuration files
         echo -e "\nCreating configuration files" && \
         cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \
     
         # updating configuration files
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \
     
         echo -e "\nCompleted extraction to ${ENGINE_PATH}"
     ---
     apiVersion: batch/v1
     kind: Job
     metadata:
       name: data-loader-gemma-2b
       labels:
         app: data-loader-gemma-2b
     spec:
       ttlSecondsAfterFinished: 120
       template:
         metadata:
           labels:
             app: data-loader-gemma-2b
         spec:
           restartPolicy: OnFailure
           containers:
           - name: gcloud
             image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
             command:
             - /scripts/fetch_model.sh
             env:
             - name: KAGGLE_CONFIG_DIR
               value: /kaggle
             - name: MODEL_PATH
               value: "google/gemma/tensorrtllm/2b-it/2"
             - name: WORLD_SIZE
               value: "1"
             volumeMounts:
             - mountPath: "/kaggle/"
               name: kaggle-credentials
               readOnly: true
             - mountPath: "/scripts/"
               name: scripts-volume
               readOnly: true
             - mountPath: "/data"
               name: data
           volumes:
           - name: kaggle-credentials
             secret:
               defaultMode: 0400
               secretName: kaggle-secret
           - name: scripts-volume
             configMap:
               defaultMode: 0700
               name: fetch-model-scripts
           - name: data
             persistentVolumeClaim:
               claimName: model-data
           tolerations:
           - key: "key"
             operator: "Exists"
             effect: "NoSchedule"

  2. Appliquez le fichier manifeste :

     kubectl apply -f job-download-gemma-2b.yaml
     

  3. Affichez les journaux du job :

     kubectl logs -f job/data-loader-gemma-2b
     

     La sortie des journaux est semblable à celle-ci :

     ...
     Creating configuration files
     + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/2b/bfloat16/1-gpu/'
     + echo -e '\nCreating configuration files'
     ...
     

  4. Attendez que la tâche soit terminée :

     kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-2b
     

     Le résultat ressemble à ce qui suit :

     job.batch/data-loader-gemma-2b condition met
     

  5. Vérifiez que le job a bien été exécuté (cela peut prendre quelques minutes) :

     kubectl get job/data-loader-gemma-2b
     

     Le résultat ressemble à ce qui suit :

     NAME             COMPLETIONS   DURATION   AGE
     data-loader-gemma-2b   1/1           ##s        #m##s
     

  Gemma 7B-it

  Le moteur TensorRT-LLM est créé à partir du point de contrôle PyTorch de Gemma du modèle Gemma 7B-it (adapté aux instructions) à l'aide de l'activation bfloat16, de GPU L4 ciblés d'une longueur de séquence d'entrée égale à 1 024 et d'une longueur de séquence de sortie égale à 512. Vous pouvez déployer le modèle sur un seul GPU L4.

  1. Créez le fichier manifeste job-download-gemma-7b.yaml suivant :

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: fetch-model-scripts
     data:
       fetch_model.sh: |-
         #!/usr/bin/bash -x
         pip install kaggle --break-system-packages && \
     
         MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
         VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
         ACTIVATION_DTYPE=bfloat16 && \
     
         TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
         ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
         TRITON_MODEL_REPO=/data/triton/model_repository && \
     
         mkdir -p ${ENGINE_PATH} && \
         mkdir -p ${TRITON_MODEL_REPO} && \
     
         kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
         rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
         find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
         find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \
     
         # copying configuration files
         echo -e "\nCreating configuration files" && \
         cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \
     
         # updating configuration files
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
         python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \
     
         echo -e "\nCompleted extraction to ${ENGINE_PATH}"
     ---
     apiVersion: batch/v1
     kind: Job
     metadata:
       name: data-loader-gemma-7b
       labels:
         app: data-loader-gemma-7b
     spec:
       ttlSecondsAfterFinished: 120
       template:
         metadata:
           labels:
             app: data-loader-gemma-7b
         spec:
           restartPolicy: OnFailure
           containers:
           - name: gcloud
             image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
             command:
             - /scripts/fetch_model.sh
             env:
             - name: KAGGLE_CONFIG_DIR
               value: /kaggle
             - name: MODEL_PATH
               value: "google/gemma/tensorrtllm/7b-it/2"
             - name: WORLD_SIZE
               value: "1"
             volumeMounts:
             - mountPath: "/kaggle/"
               name: kaggle-credentials
               readOnly: true
             - mountPath: "/scripts/"
               name: scripts-volume
               readOnly: true
             - mountPath: "/data"
               name: data
           volumes:
           - name: kaggle-credentials
             secret:
               defaultMode: 0400
               secretName: kaggle-secret
           - name: scripts-volume
             configMap:
               defaultMode: 0700
               name: fetch-model-scripts
           - name: data
             persistentVolumeClaim:
               claimName: model-data
           tolerations:
           - key: "key"
             operator: "Exists"
             effect: "NoSchedule"

  2. Appliquez le fichier manifeste :

     kubectl apply -f job-download-gemma-7b.yaml
     

  3. Affichez les journaux du job :

     kubectl logs -f job/data-loader-gemma-7b
     

     La sortie des journaux est semblable à celle-ci :

     ...
     Creating configuration files
     + echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/7b/bfloat16/1-gpu/'
     + echo -e '\nCreating configuration files'
     ...
     

  4. Attendez que la tâche soit terminée :

     kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-7b
     

     Le résultat ressemble à ce qui suit :

     job.batch/data-loader-gemma-7b condition met
     

  5. Vérifiez que le job a bien été exécuté (cela peut prendre quelques minutes) :

     kubectl get job/data-loader-gemma-7b
     

     Le résultat ressemble à ce qui suit :

     NAME             COMPLETIONS   DURATION   AGE
     data-loader-gemma-7b   1/1           ##s        #m##s
     

  Assurez-vous que la tâche a bien été exécutée avant de passer à la section suivante.

  Déployer Triton

  Dans cette section, vous allez déployer un conteneur utilisant Triton avec le backend TensorRT-LLM pour diffuser le modèle Gemma que vous souhaitez utiliser.

  1. Créez le fichier manifeste deploy-triton-server.yaml suivant :

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: launch-tritonserver
     data:
       entrypoint.sh: |-
         #!/usr/bin/bash -x
         # Launch Triton Inference server
     
         WORLD_SIZE=1
         TRITON_MODEL_REPO=/data/triton/model_repository
     
         python3 /tensorrtllm_backend/scripts/launch_triton_server.py \
           --world_size ${WORLD_SIZE} \
           --model_repo ${TRITON_MODEL_REPO}
     
         tail -f /dev/null
     ---
     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: triton-gemma-deployment
       labels:
         app: gemma-server
         version: v1 
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gemma-server 
           version: v1
       template:
         metadata:
           labels:
             app: gemma-server
             ai.gke.io/model: gemma
             ai.gke.io/inference-server: triton
             examples.ai.gke.io/source: user-guide
             version: v1
         spec:
           containers:
           - name: inference-server 
             image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
             imagePullPolicy: IfNotPresent
             resources:
               requests:
                 ephemeral-storage: "40Gi"
                 memory: "40Gi"
                 nvidia.com/gpu: 1
               limits:
                 ephemeral-storage: "40Gi"
                 memory: "40Gi"
                 nvidia.com/gpu: 1
             command:
             - /scripts/entrypoint.sh
             volumeMounts:
             - mountPath: "/scripts/"
               name: scripts-volume
               readOnly: true
             - mountPath: "/data"
               name: data
             ports:
               - containerPort: 8000
                 name: http
               - containerPort: 8001
                 name: grpc
               - containerPort: 8002
                 name: metrics
             livenessProbe:
               failureThreshold: 60
               initialDelaySeconds: 600
               periodSeconds: 5
               httpGet:
                 path: /v2/health/live
                 port: http
             readinessProbe:
               failureThreshold: 60
               initialDelaySeconds: 600
               periodSeconds: 5
               httpGet:
                 path: /v2/health/ready
                 port: http
           securityContext:
             runAsUser: 1000
             fsGroup: 1000
           volumes:
           - name: scripts-volume
             configMap:
               defaultMode: 0700
               name: launch-tritonserver
           - name: data
             persistentVolumeClaim:
               claimName: model-data
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-l4
           tolerations:
           - key: "key"
             operator: "Exists"
             effect: "NoSchedule"
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: triton-server
       labels:
         app: gemma-server 
     spec:
       type: ClusterIP
       ports:
         - port: 8000
           targetPort: http
           name: http-inference-server
         - port: 8001
           targetPort: grpc
           name: grpc-inference-server
         - port: 8002
           targetPort: metrics
           name: http-metrics
       selector:
         app: gemma-server

  2. Appliquez le fichier manifeste :

     kubectl apply -f deploy-triton-server.yaml
     

  3. Attendez que le déploiement soit disponible :

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

  4. Affichez les journaux à partir du fichier manifeste :

     kubectl logs -f -l app=gemma-server
     

     La ressource de déploiement lance le serveur Triton et charge les données du modèle. Ce processus peut prendre quelques minutes (jusqu'à 20 minutes, plus). Le résultat ressemble à ce qui suit :

     I0216 03:24:57.387420 29 server.cc:676]
     +------------------+---------+--------+
     | Model            | Version | Status |
     +------------------+---------+--------+
     | ensemble         | 1       | READY  |
     | postprocessing   | 1       | READY  |
     | preprocessing    | 1       | READY  |
     | tensorrt_llm     | 1       | READY  |
     | tensorrt_llm_bls | 1       | READY  |
     +------------------+---------+--------+
     
     ....
     ....
     ....
     
     I0216 03:24:57.425104 29 grpc_server.cc:2519] Started GRPCInferenceService at 0.0.0.0:8001
     I0216 03:24:57.425418 29 http_server.cc:4623] Started HTTPService at 0.0.0.0:8000
     I0216 03:24:57.466646 29 http_server.cc:315] Started Metrics Service at 0.0.0.0:8002
     

  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/triton-server 8000:8000
  

  Le résultat ressemble à ce qui suit :

  Forwarding from 127.0.0.1:8000 -> 8000
  Forwarding from [::1]:8000 -> 8000
  Handling connection for 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 le modèle adapté aux instructions déployé. Par souci de simplicité, cette section décrit l'approche de test uniquement avec le modèle adapté aux instructions 2B.

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

  USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"
  
  curl -X POST localhost:8000/v2/models/ensemble/generate \
    -H "Content-Type: application/json" \
    -d @- <<EOF
  {
      "text_input": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
      "temperature": 0.9,
      "max_tokens": 128
  }
  EOF
  

  Le résultat suivant affiche un exemple de réponse du modèle :

  {
    "context_logits": 0,
    "cum_log_probs": 0,
    "generation_logits": 0,
    "model_name": "ensemble",
    "model_version": "1",
    "output_log_probs": [0.0,0.0,...],
    "sequence_end": false,
    "sequence_id": 0,
    "sequence_start": false,
    "text_output":"Python.\n\nPython is an excellent choice for beginners due to its simplicity, readability, and extensive documentation. Its syntax is close to natural language, making it easier for beginners to understand and write code. Python also has a vast collection of libraries and tools that make it versatile for various projects. Additionally, Python's dynamic nature allows for easier learning and experimentation, making it a perfect choice for newcomers to get started.Here are some specific reasons why Python is a good choice for beginners:\n\n- Simple and Easy to Read: Python's syntax is designed to be close to natural language, making it easier for"
  }
  

  Réussite : Vous avez diffusé Gemma avec succès à l'aide de GPU sur GKE avec Triton et TensorRT-LLM.

  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.

  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 \
      --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 déployer des charges de travail GPU dans Autopilot.
  • Découvrez comment déployer des charges de travail GPU dans Standard.
  • Explorez le dépôt GitHub et la documentation TensorRT-LLM.
  • 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.