Gestisci Gemma utilizzando TPU su GKE con JetStream

Autopilot Standard

---

Questo tutorial mostra come pubblicare un modello linguistico di grandi dimensioni (LLM) Gemma utilizzando le unità di elaborazione tensoriale (TPU) su Google Kubernetes Engine (GKE). Esegui il deployment di un container predefinito con JetStream e MaxText in GKE. Inoltre, configura GKE per caricare i pesi di Gemma 7B da Cloud Storage in fase di runtime.

Questo tutorial è rivolto a ingegneri di machine learning (ML), amministratori e operatori di piattaforme e specialisti di dati e AI interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la pubblicazione di LLM. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti diGoogle Cloud , consulta Ruoli e attività comuni degli utenti GKE.

Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:

• Modalità Autopilot e Standard
• Disponibilità della versione TPU attuale con l'architettura di sistema Cloud TPU
• TPU in GKE

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questo tutorial.

Gemma

Gemma è un insieme di modelli di intelligenza artificiale (AI) generativa, leggeri e disponibili pubblicamente rilasciati con una licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione nelle tue applicazioni, hardware, dispositivi mobili o servizi ospitati. Puoi utilizzare i modelli Gemma per la generazione di testo, ma puoi anche ottimizzarli per attività specializzate.

Per saperne di più, consulta la documentazione di Gemma.

TPU

Le TPU sono circuiti integrati specifici per le applicazioni (ASIC) sviluppati da Google e utilizzati per accelerare i modelli di machine learning e AI creati utilizzando framework come TensorFlow, PyTorch e JAX.

Questo tutorial illustra l'erogazione del modello Gemma 7B. GKE esegue il deployment del modello su nodi TPUv5e a singolo host con topologie TPU configurate in base ai requisiti del modello per la gestione dei prompt con bassa latenza.

JetStream

JetStream è un framework open source per la pubblicazione di inferenze sviluppato da Google. JetStream consente un'inferenza ad alte prestazioni, ad alta velocità effettiva e ottimizzato per la memoria su TPU e GPU. Fornisce ottimizzazioni avanzate delle prestazioni, tra cui tecniche di batching continuo e quantizzazione, per facilitare il deployment degli LLM. JetStream consente il servizio PyTorch/XLA e JAX TPU per ottenere prestazioni ottimali.

Per scoprire di più su queste ottimizzazioni, consulta i repository dei progetti JetStream PyTorch e JetStream MaxText.

MaxText

MaxText è un'implementazione LLM JAX performante, scalabile e adattabile, basata su librerie JAX open source come Flax, Orbax e Optax. L'implementazione LLM solo decodificatore di MaxText è scritta in Python. Sfrutta in modo intensivo il compilatore XLA per ottenere prestazioni elevate senza dover creare kernel personalizzati.

Per scoprire di più sui modelli e sulle dimensioni dei parametri più recenti supportati da MaxText, consulta il repository del progetto MaxText.

Obiettivi

1. Prepara un cluster GKE Autopilot o Standard con la topologia TPU consigliata in base alle caratteristiche del modello.
2. Esegui il deployment dei componenti JetStream su GKE.
3. Recupera e pubblica il modello ottimizzato Gemma 7B.
4. Pubblica e interagisci con il modello pubblicato.

Architettura

Questa sezione descrive l'architettura GKE utilizzata in questo tutorial. L'architettura comprende un cluster GKE Autopilot o Standard che esegue il provisioning delle TPU e ospita i componenti JetStream per eseguire il deployment e pubblicare i modelli.

Il seguente diagramma mostra i componenti di questa architettura:

Questa architettura include i seguenti componenti:

• Un cluster regionale GKE Autopilot o Standard.
• Due node pool di sezioni TPU a host singolo che ospitano il deployment di JetStream.
• Il componente Service distribuisce il traffico in entrata a tutte le repliche JetStream HTTP.
• JetStream HTTP è un server HTTP che accetta le richieste come wrapper per il formato richiesto di JetStream e le invia al client GRPC di JetStream.
• Maxengine è un server JetStream che esegue l'inferenza con il batch continuo.

Prima di iniziare

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

Verify 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

Verify 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, roles/resourcemanager.projectIamAdmin

  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.

     Vai a IAM
  2. Seleziona il progetto.
  3. Fai clic su Concedi l'accesso.

  4. Nel campo Nuove entità, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.

  5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
  6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
  7. Fai clic su Salva.
  • Assicurati di disporre di una quota sufficiente per otto chip TPU v5e PodSlice Lite. In questo tutorial utilizzi le istanze on demand.
  • Crea un account Kaggle, se non ne hai già uno.

  Ottenere l'accesso al modello

  Per accedere al modello Gemma per il deployment su GKE, devi prima firmare il contratto di consenso alla licenza.

  Firmare il contratto di consenso alla licenza

  Per utilizzare Gemma devi firmare il contratto di consenso. Segui queste istruzioni:

  1. Accedi alla pagina di consenso del modello Gemma su Kaggle.com.
  2. Accedi a Kaggle, se non l'hai ancora fatto.
  3. Fai clic su Richiedi l'accesso.
  4. Nella sezione Scegli l'account per il consenso, seleziona Verifica tramite l'account Kaggle per utilizzare il tuo account Kaggle per il consenso.
  5. Accetta i Termini e condizioni del modello.

  Generare un token di accesso

  Per accedere al modello tramite Kaggle, devi disporre di un token API Kaggle.

  Segui questi passaggi per generare un nuovo token se non ne hai già uno:

  1. Nel browser, vai alle impostazioni di Kaggle.
  2. Nella sezione API, fai clic su Crea nuovo token.

  Viene scaricato un file denominato kaggle.json.

  Prepara l'ambiente

  In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell include il software preinstallato necessario per questo tutorial, tra cui kubectl e gcloud CLI.

  Per configurare l'ambiente con Cloud Shell:

  1. Nella console Google Cloud , avvia una sessione di Cloud Shell facendo clic su Attiva Cloud Shell nella Google Cloud console. Viene avviata una sessione nel riquadro inferiore della console Google Cloud .

  2. Imposta le variabili di ambiente predefinite:

     gcloud config set project PROJECT_ID
     gcloud config set billing/quota_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
     

     Sostituisci i seguenti valori:

     • PROJECT_ID: il tuo Google Cloud ID progetto.
     • CLUSTER_NAME: il nome del tuo cluster GKE.
     • BUCKET_NAME: il nome del tuo bucket Cloud Storage. Non è necessario specificare il prefisso gs://.
     • REGION: la regione in cui si trovano il cluster GKE, il bucket Cloud Storage e i nodi TPU. La regione contiene zone in cui sono disponibili i tipi di macchine TPU v5e (ad esempio us-west1, us-west4, us-central1, us-east1, us-east5 o europe-west4). Per i cluster Autopilot, assicurati di disporre di risorse di zona TPU v5e sufficienti per la regione che preferisci.
     • (Solo cluster Standard) LOCATION: la zona in cui sono disponibili le risorse TPU (ad esempio, us-west4-a). Per i cluster Autopilot, non è necessario specificare la zona, ma solo la regione.
     • CLUSTER_VERSION: la versione di GKE, che deve supportare il tipo di macchina che vuoi utilizzare. Tieni presente che la versione GKE predefinita potrebbe non essere disponibile per la TPU di destinazione. Per un elenco delle versioni GKE minime disponibili per tipo di macchina TPU, consulta Disponibilità delle TPU in GKE.

  Creare e configurare risorse Google Cloud

  Segui queste istruzioni per creare le risorse richieste.

  Nota: potrebbe essere necessario creare una prenotazione di capacità per l'utilizzo di alcuni acceleratori. Per scoprire come prenotare e utilizzare le risorse prenotate, consulta Utilizzo di risorse di zona prenotate.

  Crea un cluster GKE

  Puoi pubblicare Gemma su TPU in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi carichi di lavoro, consulta Scegliere una modalità operativa GKE.

  Autopilot

  In Cloud Shell, esegui questo comando:

  gcloud container clusters create-auto ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --region=${REGION} \
    --cluster-version=${CLUSTER_VERSION}
  

  Standard

  1. Crea un cluster GKE Standard regionale che utilizzi Workload Identity Federation for 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 creazione del cluster potrebbe richiedere diversi minuti.

  2. Esegui questo comando per creare un node pool per il tuo 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 crea un pool di nodi TPU v5e con una topologia 2x4 e due nodi.

  Crea un bucket Cloud Storage

  In Cloud Shell, esegui questo comando:

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

  In questo modo viene creato un bucket Cloud Storage per archiviare i file del modello che scarichi da Kaggle.

  Carica il token di accesso su Cloud Shell

  In Cloud Shell, puoi caricare il token API Kaggle nel tuo Google Cloud progetto:

  1. In Cloud Shell, fai clic su Altro > Carica.
  2. Seleziona File e fai clic su Scegli file.
  3. Apri il file kaggle.json.
  4. Fai clic su Carica.

  Crea un secret Kubernetes per le credenziali Kaggle

  In Cloud Shell:

  1. Configura kubectl per comunicare con il cluster:

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

  2. Crea un secret per archiviare le credenziali Kaggle:

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

  Configura l'accesso ai tuoi workload utilizzando Workload Identity Federation for GKE

  Assegna un ServiceAccount Kubernetes all'applicazione e configura questo ServiceAccount Kubernetes in modo che funga da account di servizio IAM.

  1. Crea un account di servizio IAM per la tua applicazione:

     gcloud iam service-accounts create wi-jetstream
     

  2. Aggiungi un'associazione di policy IAM per il tuo account di servizio IAM per gestire 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
     

  3. Consenti al service account Kubernetes di rappresentare l'account di servizio IAM aggiungendo un'associazione dei criteri IAM tra i due service account. Questa associazione consente al service account Kubernetes di agire come account di servizio 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]"
     

  4. Annota il account di servizio Kubernetes con l'indirizzo email del account di servizio IAM:

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

  Converti i checkpoint del modello

  In questa sezione, creerai un Job per:

  1. Scarica il checkpoint Orbax di base da Kaggle.
  2. Carica il checkpoint in un bucket Cloud Storage.
  3. Converti il checkpoint in un checkpoint compatibile con MaxText.
  4. Annulla la scansione del checkpoint da utilizzare per la pubblicazione.

  Esegui il deployment del job di conversione del checkpoint del modello

  Segui queste istruzioni per scaricare e convertire i file checkpoint del modello Gemma 7B. Questo tutorial utilizza un job Kubernetes. Un controller Job in Kubernetes crea uno o più pod e garantisce che eseguano correttamente un'attività specifica.

  1. Crea il seguente manifest come 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.4
             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
     

  2. Applica il manifest:

     kubectl apply -f job-7b.yaml
     

  3. Attendi l'avvio dell'esecuzione del pod che pianifica il job:

     kubectl get pod -w
     

     L'output sarà simile al seguente e l'operazione potrebbe richiedere alcuni minuti:

     NAME                  READY   STATUS              RESTARTS   AGE
     data-loader-7b-abcd   0/1     ContainerCreating   0          28s
     data-loader-7b-abcd   1/1     Running             0          51s
     

     Per i cluster Autopilot, il provisioning delle risorse TPU richieste potrebbe richiedere alcuni minuti.

  4. Visualizza i log del job:

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

     Al termine del job, l'output è simile al seguente:

     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
     

  Esegui il deployment di JetStream

  In questa sezione, esegui il deployment del container JetStream per pubblicare il modello Gemma.

  Segui queste istruzioni per eseguire il deployment del modello Gemma 7B ottimizzato per le istruzioni. Questo tutorial utilizza un deployment Kubernetes. Un deployment è un oggetto API Kubernetes che consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.

  1. Salva il seguente manifest di Deployment come jetstream-gemma-deployment.yaml:

     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
     

     Il manifest imposta le seguenti proprietà chiave:

     • tokenizer_path: il percorso del tokenizer del modello.
     • load_parameters_path: il percorso nel bucket Cloud Storage in cui sono archiviati i checkpoint.
     • per_device_batch_size: la dimensione del batch di decodifica per dispositivo, dove un chip TPU equivale a un dispositivo.
     • max_prefill_predict_length: la lunghezza massima del riempimento automatico durante l'autoregressione.
     • max_target_length: la lunghezza massima della sequenza.
     • model_name: il nome del modello (gemma-7b).
     • ici_fsdp_parallelism: il numero di shard per il parallelismo dei dati completamente suddivisi (FSDP).
     • ici_tensor_parallelism: il numero di shard per il parallelismo dei tensori.
     • ici_autoregressive_parallelism: il numero di shard per il parallelismo autoregressivo.
     • prometheus_port: porta per esporre le metriche di Prometheus. Rimuovi questo argomento se le metriche non sono necessarie.
     • scan_layers: flag booleano dei livelli di scansione (booleano).
     • weight_dtype: il tipo di dati del peso (bfloat16).

  2. Applica il manifest:

     kubectl apply -f jetstream-gemma-deployment.yaml
     

  3. Verifica il deployment:

     kubectl get deployment
     

     L'output è simile al seguente:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     maxengine-server                  2/2     2            2           ##s
     

     Per i cluster Autopilot, il provisioning delle risorse TPU richieste potrebbe richiedere alcuni minuti.

  4. Visualizza i log del server HTTP per verificare che il modello sia stato caricato e compilato. Il completamento di questa operazione potrebbe richiedere alcuni minuti.

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

     L'output è simile al seguente:

     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)
     

  5. Visualizza i log di MaxEngine e verifica che la compilazione sia stata completata.

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

     L'output è simile al seguente:

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

  Pubblica il modello

  In questa sezione, interagisci con il modello.

  Configurare il port forwarding

  Puoi accedere al deployment di JetStream tramite il servizio ClusterIP che hai creato nel passaggio precedente. I servizi ClusterIP sono raggiungibili solo dall'interno del cluster. Pertanto, per accedere al servizio dall'esterno del cluster, completa i seguenti passaggi:

  Per stabilire una sessione di port forwarding, esegui questo comando:

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

  Operazione riuscita: hai pubblicato Gemma utilizzando le TPU su GKE con JetStream. Ora puoi interagire con il modello.

  Interagisci con il modello utilizzando curl

  1. Verifica di poter accedere al server HTTP JetStream aprendo un nuovo terminale ed eseguendo questo comando:

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

     Il completamento della richiesta iniziale può richiedere diversi secondi a causa del riscaldamento del modello. L'output è simile al seguente:

     {
         "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"
     }
     

  (Facoltativo) Interagisci con il modello tramite un'interfaccia di chat Gradio

  In questa sezione, creerai un'applicazione di chat web che ti consente di interagire con il modello ottimizzato per le istruzioni.

  Gradio è una libreria Python che ha un wrapper ChatInterface che crea interfacce utente per chatbot.

  Implementare l'interfaccia di chat

  1. In Cloud Shell, salva il seguente manifest come 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-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
     

  2. Applica il manifest:

     kubectl apply -f gradio.yaml
     

  3. Attendi che il deployment sia disponibile:

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

  Utilizzare l'interfaccia di chat

  1. In Cloud Shell, esegui questo comando:

     kubectl port-forward service/gradio 8080:8080
     

     In questo modo viene creato un port forwarding da Cloud Shell al servizio Gradio.

  2. Fai clic sul pulsante Anteprima web, che si trova in alto a destra nella barra delle app di Cloud Shell. Fai clic su Anteprima sulla porta 8080. Nel browser si apre una nuova scheda.

  3. Interagisci con Gemma utilizzando l'interfaccia di chat di Gradio. Aggiungi un prompt e fai clic su Invia.

  Risoluzione dei problemi

  • Se visualizzi il messaggio Empty reply from server, è possibile che il container non abbia completato il download dei dati del modello. Controlla di nuovo i log del pod per il messaggio Connected che indica che il modello è pronto per essere utilizzato.
  • Se visualizzi Connection refused, verifica che il port forwarding sia attivo.

  Esegui la pulizia

  Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

  Elimina le risorse di cui è stato eseguito il deployment

  Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse che hai creato in questa guida, esegui i seguenti comandi e segui le istruzioni:

  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
  

  Passaggi successivi

  • Scopri come eseguire i modelli Gemma su GKE e come eseguire carichi di lavoro di AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.
  • Scopri di più sulle TPU in GKE.
  • Esplora il repository GitHub di JetStream.
  • Esplora Vertex AI Model Garden.