Diffuser Gemma à l'aide de TPU sur GKE avec JetStream

Autopilot Standard

Ce guide vous explique comment diffuser un grand modèle de langage (LLM) Gemma à l'aide des TPU (Tensor Processing Units) sur Google Kubernetes Engine (GKE) avec JetStream via MaxText. Dans ce guide, vous téléchargez les pondérations de modèle ajustées par l'instruction Gemma 7B dans Cloud Storage et les déployez sur un cluster GKE Autopilot ou Standard utilisant un conteneur exécutant JetStream.

Si vous avez besoin de l'évolutivité, de la résilience et de la rentabilité offertes par les fonctionnalités de Kubernetes lors du déploiement de votre modèle sur JetStream, ce guide est un bon point de départ.

Contexte

En diffusant Gemma à l'aide de TPU sur GKE avec JetStream, vous pouvez créer une solution de diffusion robuste et prête pour la production avec tous les avantages de la plate-forme Kubernetes gérée, y compris en termes de rentabilité, évolutivité et haute disponibilité. Cette section décrit les principales technologies utilisées dans ce tutoriel.

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.

TPU

Les TPU sont des circuits intégrés propres aux applications (Application-Specific Integrated Circuit ou ASIC), développés spécifiquement par Google et permettant d'accélérer le machine learning et les modèles d'IA créés à l'aide de frameworks tels que TensorFlow, PyTorch et JAX.

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

Découvrez la disponibilité actuelle des versions de TPU avec l'architecture système de Cloud TPU.
Apprenez-en plus sur les TPU dans GKE.

Ce tutoriel couvre la diffusion du modèle Gemma 7B. GKE déploie le modèle sur des nœuds TPUv5e à hôte unique avec des topologies TPU configurées en fonction des exigences du modèle pour diffuser des requêtes avec une faible latence.

JetStream

JetStream est un framework de service d'inférence Open Source développé par Google. JetStream permet des inférences hautes performances, à haut débit et à mémoire optimisée sur les TPU et les GPU. Il fournit des optimisations de performances avancées, y compris des techniques de traitement par lot et de quantification continues, pour faciliter le déploiement de LLM. JetStream permet la diffusion des TPU PyTorch/XLA et JAX pour obtenir des performances optimales.

Pour en savoir plus sur ces optimisations, reportez-vous aux dépôts de projets JetStream PyTorch et JetStream MaxText.

MaxText

MaxText est une implémentation LLM JAX performante, évolutive et adaptable, basée sur des bibliothèques JAX Open Source telles que Flax, Orbax et Optax. L'implémentation LLM uniquement décodeur de MaxText est écrite en Python. Elle exploite fortement le compilateur XLA pour atteindre de hautes performances sans avoir à créer de noyau personnalisé.

Pour en savoir plus sur les derniers modèles et tailles de paramètres compatibles avec MaxText, consultez le dépôt du projet MaxText.

Objectifs

Ce tutoriel est destiné aux clients d'IA générative qui utilisent JAX, aux utilisateurs nouveaux ou existants de GKE, aux ingénieurs en ML, aux ingénieurs MLOps (DevOps) ou aux administrateurs de plate-forme qui souhaitent utiliser les fonctionnalités d'orchestration de conteneurs Kubernetes pour diffuser des LLM.

Ce tutoriel couvre les étapes suivantes :

Préparer un cluster GKE Autopilot ou standard avec la topologie TPU recommandée en fonction des caractéristiques du modèle.
Déployer les composants JetStream sur GKE
Obtenir et publier le modèle réglé pour les instructions Gemma 7B.
Diffuser le modèle publié et interagir avec lui.

Architecture

Cette section décrit l'architecture GKE utilisée dans ce tutoriel. L'architecture comprend un cluster GKE Autopilot ou standard qui provisionne des TPU et héberge les composants JetStream pour déployer et diffuser les modèles.

Le schéma suivant montre les composants de cette architecture:

Architecture d'un cluster GKE avec des pools de nœuds TPU à hôte unique contenant les composants Maxengine et Max HTTP.

Cette architecture comprend les composants suivants :

Un cluster régional GKE Autopilot ou Standard.
Deux pools de nœuds de tranche TPU à hôte unique qui hébergent le déploiement JetStream.
Le composant de service répartit le trafic entrant sur toutes les instances répliquées JetStream HTTP.
JetStream HTTP est un serveur HTTP qui accepte les requêtes en tant que wrapper au format requis par JetStream et les envoie au client GRPC de JetStream.
Maxengine est un serveur JetStream qui effectue des inférences avec traitement par lot continu.

Avant de commencer

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role 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.

Assurez-vous de disposer d'un quota suffisant pour huit puces PodSlice Lite TPU v5e. Dans ce tutoriel, vous utilisez des instances à la demande.
Créez un compte Kaggle, si vous n'en possédez pas.

Accéder au modèle

Pour accéder au modèle Gemma en vue du déploiement sur GKE, vous devez d'abord signer le contrat d'autorisation de licence.

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

Accédez à la page de consentement du modèle Gemma sur Kaggle.com.
Connectez-vous à Kaggle si vous ne l'avez pas déjà fait.
Cliquez sur Demande d'accès.
Dans la section Choose Account for Consent (Choisir un compte pour le consentement), sélectionnez Verify via Kaggle Account (Valider via un compte Kaggle) pour utiliser votre compte Kaggle pour le consentement.
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:

Dans votre navigateur, accédez aux paramètres Kaggle.
Dans la section API, cliquez sur Create New Token (Créer un jeton).

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

Préparer l'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 :

Dans la console Google Cloud, lancez une session Cloud Shell en cliquant sur Activer Cloud Shell dans la console Google Cloud. Une session s'ouvre dans le volet inférieur de la console Google Cloud.
Définissez les variables d'environnement par défaut :
```
gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME=CLUSTER_NAME
export BUCKET_NAME=BUCKET_NAME
export REGION=REGION
export LOCATION=LOCATION
export CLUSTER_VERSION=CLUSTER_VERSION
```
Remplacez les valeurs suivantes :
- PROJECT_ID : ID de votre projet Google Cloud.
- CLUSTER_NAME : nom de votre cluster GKE.
- BUCKET_NAME : nom du bucket Cloud Storage. Vous n'avez pas besoin de spécifier le préfixe gs://.
- REGION : région où se trouvent le cluster GKE, le bucket Cloud Storage et les nœuds TPU. La région contient des zones où les types de machines TPU v5e sont disponibles (par exemple, us-west1, us-west4, us-central1, us-east1, us-east5 ou europe-west4). Pour les clusters Autopilot, assurez-vous de disposer de ressources zonales TPU v5e suffisantes pour la région de votre choix.
- (Cluster standard uniquement) LOCATION : zone où les ressources TPU sont disponibles (par exemple, us-west4-a). Pour les clusters Autopilot, il n'est pas nécessaire de spécifier la zone, mais uniquement la région.
- CLUSTER_VERSION : version de GKE, qui doit être compatible avec le type de machine que vous souhaitez utiliser. Notez que la version de GKE par défaut peut ne pas être disponible pour votre TPU cible. Pour obtenir la liste des versions minimales de GKE disponibles par type de machine TPU, consultez la page Disponibilité des TPU dans GKE.

Créer et configurer des ressources Google Cloud

Suivez les instructions ci-dessous pour créer les ressources requises.

Créer un cluster GKE

Vous pouvez diffuser les modèles Gemma sur des TPU 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} \
  --cluster-version=${CLUSTER_VERSION}

Standard

Créez un cluster GKE Standard régional qui utilise la fédération d'identité de charge de travail pour GKE.

gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --cluster-version=${CLUSTER_VERSION} \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${REGION}

La création du cluster peut prendre plusieurs minutes.

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

gcloud container node-pools create gemma-7b-tpu-nodepool \
  --cluster=${CLUSTER_NAME} \
  --machine-type=ct5lp-hightpu-8t \
  --project=${PROJECT_ID} \
  --num-nodes=2 \
  --region=${REGION} \
  --node-locations=${LOCATION}

GKE crée un pool de nœuds TPU v5e avec une topologie 2x4 et deux nœuds.

Créer un bucket Cloud Storage

Dans Cloud Shell, exécutez la commande suivante :

gcloud storage buckets create gs://${BUCKET_NAME} --location=${REGION}

Cette opération crée un bucket Cloud Storage pour stocker les fichiers de modèle que vous téléchargez depuis Kaggle.

Importer le jeton d'accès dans Cloud Shell

Dans Cloud Shell, vous pouvez importer le jeton d'API Kaggle dans votre projet Google Cloud:

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

Créer un secret Kubernetes pour les identifiants Kaggle

Dans Cloud Shell, procédez comme suit :

Configurez kubectl de manière à communiquer avec votre cluster :

gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}

Créez un secret pour stocker les identifiants Kaggle:

kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json

Configurer l'accès à vos charges de travail à l'aide de la fédération d'identité de charge de travail pour GKE

Attribuez un compte de service Kubernetes à l'application et configurez ce compte de service Kubernetes pour qu'il agisse en tant que compte de service IAM.

Créez un compte de service IAM pour votre application :
```
gcloud iam service-accounts create wi-jetstream
```

Ajoutez une liaison de stratégie IAM pour votre compte de service IAM afin de gérer Cloud Storage :

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.objectUser

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.insightsCollectorService

Autorisez le compte de service Kubernetes à emprunter l'identité du compte de service IAM en ajoutant une liaison de stratégie IAM entre les deux comptes de service. Cette liaison permet au compte de service Kubernetes d'agir en tant que compte de service IAM.
```
gcloud iam service-accounts add-iam-policy-binding wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
```

Annotez le compte de service Kubernetes avec l'adresse e-mail du compte de service IAM.

kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com

Convertir les points de contrôle du modèle

Dans cette section, vous allez créer une tâche pour effectuer les opérations suivantes :

Téléchargez le point de contrôle Orbax de base depuis Kaggle.
Importez le point de contrôle dans un bucket Cloud Storage.
Convertissez le point de contrôle en point de contrôle compatible MaxText.
Annulez l'analyse du point de contrôle à utiliser pour la diffusion.

Déployer la tâche de conversion du point de contrôle du modèle

Suivez ces instructions pour télécharger et convertir les fichiers de point de contrôle du modèle Gemma 7B.

Créez le fichier manifeste suivant sous le nom job-7b.yaml.

apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-7b
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.2
        args:
        - -b=BUCKET_NAME
        - -m=google/gemma/maxtext/7b-it/2
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret

Appliquez le fichier manifeste :
```
kubectl apply -f job-7b.yaml
```
Attendez que le pod planifiant le Job commence à s'exécuter :
```
kubectl get pod -w
```
Le résultat sera semblable à ce qui suit. Cela peut prendre quelques minutes:
```
NAME                  READY   STATUS              RESTARTS   AGE
data-loader-7b-abcd   0/1     ContainerCreating   0          28s
data-loader-7b-abcd   1/1     Running             0          51s
```
Pour les clusters Autopilot, le provisionnement des ressources TPU requises peut prendre quelques minutes.

Affichez les journaux de la tâche:

kubectl logs -f jobs/data-loader-7b

Une fois la tâche terminée, le résultat ressemble à ce qui suit :

Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
+ echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items'

Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items

Déployer JetStream

Dans cette section, vous allez déployer le conteneur JetStream pour diffuser le modèle Gemma.

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

Créez le fichier manifeste jetstream-gemma-deployment.yaml suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: maxengine-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: maxengine-server
  template:
    metadata:
      labels:
        app: maxengine-server
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: maxengine-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.2
        args:
        - model_name=gemma-7b
        - tokenizer_path=assets/tokenizer.gemma
        - per_device_batch_size=4
        - max_prefill_predict_length=1024
        - max_target_length=2048
        - async_checkpointing=false
        - ici_fsdp_parallelism=1
        - ici_autoregressive_parallelism=-1
        - ici_tensor_parallelism=1
        - scan_layers=false
        - weight_dtype=bfloat16
        - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
        - prometheus_port=PROMETHEUS_PORT
        ports:
        - containerPort: 9000
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
        ports:
        - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: maxengine-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000
  - protocol: TCP
    name: jetstream-grpc
    port: 9000
    targetPort: 9000

Le fichier manifeste définit les propriétés clés suivantes:

tokenizer_path : chemin d'accès à la fonction de tokenisation de votre modèle.
load_parameters_path: chemin d'accès dans le bucket Cloud Storage où vos points de contrôle sont stockés.
per_device_batch_size: taille du lot de décodage par appareil, où une puce TPU équivaut à un appareil.
max_prefill_predict_length : longueur maximale du préremplissage lors de la régression automatique.
max_target_length : longueur maximale de la séquence.
model_name: nom du modèle (gemma-7b).
ici_fsdp_parallelism : nombre de segments pour le parallélisme des données entièrement segmentées (FSDP).
ici_tensor_parallelism : nombre de segments pour le parallélisme des Tensors.
ici_autoregressive_parallelism: nombre de segments pour le parallélisme autorégressif.
prometheus_port: port pour exposer les métriques Prometheus. Supprimez cet argument si les métriques ne sont pas nécessaires.
scan_layers: option booléenne de balayage des couches (booléenne).
weight_dtype : type de données de pondération (bfloat16).

Appliquez le fichier manifeste :

kubectl apply -f jetstream-gemma-deployment.yaml

Vérifiez le déploiement :
```
kubectl get deployment
```
Le résultat ressemble à ce qui suit :
```
NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
maxengine-server                  2/2     2            2           ##s
```
Pour les clusters Autopilot, le provisionnement des ressources TPU requises peut prendre quelques minutes.

Affichez les journaux du serveur HTTP pour vérifier que le modèle a été chargé et compilé. Le serveur peut prendre quelques minutes pour effectuer cette opération.

kubectl logs deploy/maxengine-server -f -c jetstream-http

Le résultat ressemble à ce qui suit :

kubectl logs deploy/maxengine-server -f -c jetstream-http

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Consultez les journaux MaxEngine et vérifiez que la compilation est terminée.

kubectl logs deploy/maxengine-server -f -c maxengine-server

Le résultat ressemble à ce qui suit :

2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec
2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------

Diffuser le modèle

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

Configurer le transfert de port

Vous pouvez accéder au déploiement JetStream via le service ClusterIP que vous avez créé à l'étape précédente. Les services ClusterIP ne sont accessibles qu'à partir du cluster. Par conséquent, pour accéder au service en dehors du cluster, procédez comme suit :

Pour établir une session de transfert de port, exécutez la commande suivante:

kubectl port-forward svc/jetstream-svc 8000:8000

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

Vérifiez que vous pouvez accéder au serveur HTTP JetStream en ouvrant un nouveau terminal et en exécutant la commande suivante :

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8000/generate \
--data \
'{
    "prompt": "What are the top 5 programming languages",
    "max_tokens": 200
}'

L'exécution de la requête initiale peut prendre plusieurs secondes en raison de l'échauffement du modèle. Le résultat ressemble à ce qui suit :

{
    "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools"
}

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

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

Déployer l'interface de chat

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

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: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://jetstream-http-svc:8000"
        - name: LLM_ENGINE
          value: "max"
        - 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

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

Attendez que le déploiement soit disponible :

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

Utiliser l'interface de chat

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

Résoudre les problèmes

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

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer les ressources déployées

Pour éviter que les ressources que vous avez créées dans ce guide ne soient facturées sur votre compte Google Cloud, exécutez les commandes suivantes et suivez les instructions :

gcloud container clusters delete ${CLUSTER_NAME} --region=${REGION}

gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

gcloud storage rm --recursive gs://BUCKET_NAME

Étapes suivantes

Découvrez comment exécuter des modèles Gemma sur GKE et comment exécuter des charges de travail d'IA ou de ML optimisées grâce aux fonctionnalités d'orchestration de plates-formes GKE.
Apprenez-en plus sur les TPU dans GKE.
Explorez le dépôt GitHub JetStream.
Explorez Vertex AI Model Garden.

Diffuser Gemma à l'aide de TPU sur GKE avec JetStream

Contexte

Gemma

TPU

JetStream

MaxText

Objectifs

Architecture

Avant de commencer

Check for the roles

Grant the roles

Accéder au modèle

Signer le contrat de consentement de la licence

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

Préparer l'environnement

Créer et configurer des ressources Google Cloud

Créer un cluster GKE

Autopilot

Standard

Créer un bucket Cloud Storage

Importer le jeton d'accès dans Cloud Shell

Créer un secret Kubernetes pour les identifiants Kaggle

Configurer l'accès à vos charges de travail à l'aide de la fédération d'identité de charge de travail pour GKE

Convertir les points de contrôle du modèle

Déployer la tâche de conversion du point de contrôle du modèle

Déployer JetStream

Diffuser le modèle

Configurer le transfert de port

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

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

Déployer l'interface de chat

Utiliser l'interface de chat

Résoudre les problèmes

Effectuer un nettoyage

Supprimer les ressources déployées

Étapes suivantes