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

Autopilot Standard

---

Ce tutoriel vous explique comment diffuser un grand modèle de langage (LLM) Gemma, notre famille de modèles ouverts, utilisant des processeurs graphiques (GPU) sur Google Kubernetes Engine (GKE) avec le framework de diffusion d'interface de génération de texte (TGI) de Hugging Face.

Dans ce tutoriel, vous allez télécharger un modèle Gemma 2 (paramètres 2B, 9B et 27B) ou CodeGemma à partir de Hugging Face. Vous déployez ensuite le modèle sur un cluster GKE Autopilot ou Standard à l'aide d'un conteneur qui exécute TGI.

Ce guide est un bon point de départ si vous avez besoin du contrôle précis, de l'évolutivité, de la résilience, de la portabilité et de la rentabilité des services Kubernetes gérés lors du déploiement et de la diffusion de vos charges de travail d'IA/de ML. 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.

Expérience

En diffusant Gemma à l'aide de GPU sur GKE avec TGI, vous pouvez mettre en œuvre une solution de diffusion d'inférences robuste et prête pour la production avec tous les avantages de Kubernetes géré, y compris une évolutivité efficace et une meilleure disponibilité. 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.

Dans ce guide, nous présentons les modèles suivants :

• Gemma pour la génération de texte, vous pouvez également régler ces modèles pour vous spécialiser dans l'exécution de tâches spécifiques.
• CodeGemma est un ensemble de modèles puissants et légers capables d'effectuer diverses tâches de codage, telles que la complétion de code "fill-in-the-middle", la génération de code, la compréhension du langage naturel, le raisonnement mathématique et le suivi d'instructions.

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.

Avant d'utiliser des GPU dans GKE, nous vous recommandons de suivre le parcours de formation suivant :

1. Découvrez la disponibilité actuelle des versions des GPU.
2. Apprenez-en plus sur les GPU dans GKE.

Inférence de génération de texte (TGI)

TGI est le kit d'outils de Hugging Face pour le déploiement et la diffusion de LLM. TGI permet de générer du texte hautes performances pour les LLM Open Source courants, y compris Gemma. Les TGI incluent des fonctionnalités telles que:

• Implémentation optimisée du transformateur avec Flash Attention et PagedAttention
• Traitement par lots continu pour améliorer le débit global de diffusion
• Parallélisme Tensor pour une inférence plus rapide sur plusieurs GPU

Pour en savoir plus, consultez la documentation TGI.

Objectifs

Ce guide est destiné aux clients d'IA générative qui utilisent PyTorch, aux utilisateurs nouveaux ou existants de GKE, aux ingénieurs en ML, aux ingénieurs MLOps (DevOps) ou aux administrateurs de plate-forme qui s'intéressent à l'utilisation des fonctionnalités d'orchestration de conteneurs Kubernetes pour diffuser des LLM sur du matériel GPU H100, A100 et L4.

À la fin de ce guide, vous devriez être capable d'effectuer les étapes suivantes :

1. Préparez votre environnement avec un cluster GKE en mode Autopilot.
2. Déployez TGI sur votre cluster.
3. Utilisez TGI pour diffuser le modèle Gemma 2 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.

  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 colunn 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. Pour en savoir plus, consultez les pages À propos des GPU et Quotas d'allocation.

Accéder au modèle

Pour accéder aux modèles Gemma en vue du déploiement sur GKE, vous devez d'abord signer le contrat d'autorisation de licence, puis générer un jeton d'accès Hugging Face.

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 de consentement du modèle sur Kaggle.com.
2. Vérifiez l'autorisation à l'aide de votre compte Hugging Face.
3. Acceptez les conditions du modèle.

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

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 sur Google 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 console Google 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
   export PROJECT_ID=$(gcloud config get project)
   export REGION=REGION
   export CLUSTER_NAME=tgi
   export HF_TOKEN=HF_TOKEN
   

   Remplacez les valeurs suivantes :

   • PROJECT_ID : L'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.
   • 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 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

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} \
     --region=${REGION} \
     --workload-pool=${PROJECT_ID}.svc.id.goog \
     --release-channel=rapid \
     --num-nodes=1
   

   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 :

   Gemma 2 2B

   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 2 9B

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

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

   Gemma 2 27B

   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.

Créer un secret Kubernetes pour les identifiants Hugging Face

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}
   

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 -
   

Déployer TGI

Dans cette section, vous allez déployer le conteneur TGI pour diffuser le modèle Gemma que vous souhaitez utiliser.

Gemma 2 2B-it

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

1. Créez le fichier manifeste tgi-2-2b-it.yaml suivant :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-2b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
           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"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '1'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-2b-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
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 8000

2. Appliquez le fichier manifeste :

   kubectl apply -f tgi-2-2b-it.yaml
   

Gemma 2 9B-it

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

1. Créez le fichier manifeste tgi-2-9b-it.yaml suivant :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-9b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
           resources:
             requests:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '2'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-9b-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
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 8000

2. Appliquez le fichier manifeste :

   kubectl apply -f tgi-2-9b-it.yaml
   

Gemma 2 27B-it

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

1. Créez le fichier manifeste tgi-2-27b-it.yaml suivant :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-27b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
           resources:
             requests:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
             limits:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '4'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-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-l4
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 8000

2. Appliquez le fichier manifeste :

   kubectl apply -f tgi-2-27b-it.yaml
   

CodeGemma 7B-it

Suivez ces instructions pour déployer le modèle adapté aux instructions CodeGemma 7B.

1. Créez le fichier manifeste tgi-codegemma-1.1-7b-it.yaml suivant :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: codegemma-1.1-7b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: ghcr.io/huggingface/text-generation-inference:2.0.2
           resources:
             requests:
               cpu: "2"
               memory: "25Gi"
               ephemeral-storage: "40Gi"
               nvidia.com/gpu: 2
             limits:
               cpu: "10"
               memory: "25Gi"
               ephemeral-storage: "40Gi"
               nvidia.com/gpu: 2
           args:
           - --model-id=$(MODEL_ID)
           - --num-shard=2
           env:
           - name: MODEL_ID
             value: google/codegemma-1.1-7b-it
           - name: PORT
             value: "8000"
           - 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
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: gemma-server
     type: ClusterIP
     ports:
       - protocol: TCP
         port: 8000
         targetPort: 8000

2. Appliquez le fichier manifeste :

   kubectl apply -f tgi-codegemma-1.1-7b-it.yaml
   

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 pré-entraînés ou adaptés aux instructions déployés. Pour des raisons de simplicité, cette section décrit l'approche de test à l'aide des modèles adaptés aux instructions Gemma 2 et CodeGemma.

Gemma 2

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 http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

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

{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

CodeGemma

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

USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

curl -s -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .generated_text
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 2000
    }
}
EOF

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

def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

Réussite :Vous avez diffusé Gemma en utilisant des GPU sur GKE avec TGI. Vous pouvez maintenant interagir avec le modèle.

(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 2B-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

1. Dans Cloud Shell, enregistrez le fichier manifeste suivant sous le nom gradio.yaml :

   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.3
           resources:
             requests:
               cpu: "250m"
               memory: "512Mi"
             limits:
               cpu: "500m"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service:8000"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "gemma"
           - name: USER_PROMPT
             value: "<start_of_turn>user\nprompt<end_of_turn>\n"
           - name: SYSTEM_PROMPT
             value: "<start_of_turn>model\nprompt<end_of_turn>\n"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio
   spec:
     selector:
       app: gradio
     ports:
       - protocol: TCP
         port: 8080
         targetPort: 7860
     type: ClusterIP

2. Appliquez le fichier manifeste :

   kubectl apply -f gradio.yaml
   

3. Attendez que le déploiement soit disponible :

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

Utiliser l'interface de chat

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

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

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

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}

Étapes suivantes

• Apprenez-en plus sur les GPU dans GKE.
• Découvrez comment utiliser Gemma avec TGI 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.
• Consultez la documentation TGI.
• 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.