Gestisci Gemma utilizzando le TPU su GKE con JetStream

Questa guida illustra come pubblicare un Modello linguistico di grandi dimensioni (LLM) Gemma (LLM) utilizzando Tensor Processing Unit (TPU) su Google Kubernetes Engine (GKE) con Da JetStream a MaxText. In questa guida viene scaricato il Pesi del modello ottimizzato con l'istruzione dei parametri Gemma 7B su Cloud Storage ed eseguirne il deployment Pilota automatico o Standard utilizzando un container che esegue JetStream.

Se hai bisogno di scalabilità, resilienza e costi contenuti offerti dalle funzionalità di Kubernetes durante il deployment JetStream, questa guida è un buon punto di partenza.

Contesto

Mediante la gestione di Gemma mediante le TPU su GKE con JetStream, puoi creare una soluzione di pubblicazione solida e pronta per la produzione con tutte i vantaggi di Kubernetes gestito, ad esempio efficienza in termini di costi, scalabilità e maggiore disponibilità. Questa sezione descrive le tecnologie chiave usate in questo tutorial.

Gemma

Gemma è un insieme di intelligenza artificiale (AI) generativa aperta e leggera rilasciati con licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione in applicazioni, hardware, dispositivi mobili o servizi in hosting. Puoi utilizzare i modelli Gemma per la generazione del testo, ma puoi anche e ottimizzare questi modelli per attività specializzate.

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

TPU

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

Prima di utilizzare le TPU in GKE, ti consigliamo di completare nel seguente percorso di apprendimento:

  1. Scopri di più sulla disponibilità attuale della versione di TPU con l'architettura di sistema Cloud TPU.
  2. Scopri di più sulle TPU in GKE.

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

JetStream

JetStream è un'inferenza open source di pubblicazione sviluppato da Google. JetStream consente prestazioni elevate, velocità effettiva elevata e inferenza ottimizzato per la memoria su TPU e GPU. it offre ottimizzazioni avanzate delle prestazioni, tra cui processi batch e tecniche di quantizzazione, per facilitare l'implementazione dei modelli LLM. JetStream abilita Funzionalità PyTorch/XLA e TPU JAX per ottenere prestazioni ottimali.

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

MaxText

MaxText è una piattaforma performante, scalabile e un'implementazione LLM JAX adattabile, basata su librerie JAX open source come Lino, Orbax e Optax. Decoder-only di MaxText L'implementazione dei modelli LLM è scritta in Python. Sfrutta molto 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 progetto MaxtText.

Obiettivi

Questo tutorial è destinato ai clienti di IA generativa che utilizzano JAX, prodotti nuovi per gli utenti esistenti di GKE, ML Engineer, MLOps (DevOps) engineer amministratori di piattaforma interessati all'utilizzo di container Kubernetes di orchestrazione per la distribuzione degli LLM.

Questo tutorial illustra i seguenti passaggi:

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

Architettura

Questa sezione descrive l'architettura di GKE utilizzata in questo tutorial. L'architettura comprende un motore GKE Autopilot Cluster standard che esegue il provisioning di TPU e ospita componenti JetStream per eseguire il deployment e distribuire i modelli.

Il seguente diagramma mostra i componenti di questa architettura:

Architettura del cluster GKE con pool di nodi TPU a host singolo che contengono i componenti HTTP Maxengine e Max.

Questa architettura include i seguenti componenti:

  • Un cluster GKE Autopilot o Standard a livello di regione.
  • Due pool di nodi di sezione TPU con host singolo che ospitano il deployment JetStream.
  • Il componente del servizio distribuisce il traffico in entrata a tutte le repliche JetStream HTTP.
  • JetStream HTTP è un server HTTP che accetta le richieste come wrapper per JetStream richiede il formato richiesto e lo invia al client GRPC di JetStream.
  • Maxengine è un server JetStream che esegue l'inferenza con batch continui.

Prima di iniziare

  • Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

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

    Go to project selector

  • Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  • Attiva l'API richiesta.

    Abilita l'API

    •

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

    Go to project selector

  • Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  • Attiva l'API richiesta.

    Abilita l'API

    •

  • Assicurati di disporre dei seguenti ruoli nel progetto: roles/container.admin, roles/iam.serviceAccountAdmin

    Verifica i ruoli

    1. Nella console Google Cloud, vai alla pagina IAM.

      Vai a IAM
    2. Seleziona il progetto.

    3. Nella colonna Entità, individua la riga contenente il tuo indirizzo email.

      Se il tuo indirizzo email non è in questa colonna, significa che non disponi di alcun ruolo.

    4. Nella colonna Ruolo per la riga contenente il tuo indirizzo email, controlla se l'elenco dei ruoli include quelli richiesti.

    Concedi i ruoli

    1. Nella console Google Cloud, vai alla pagina IAM.

      Vai a IAM
    2. Seleziona il progetto.
    3. Fai clic su Concedi l'accesso.
    4. Nel campo Nuove entità, inserisci il tuo indirizzo email.
    5. Nell'elenco Seleziona un ruolo, scegli un ruolo.
    6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ciascun ruolo aggiuntivo.
    7. Fai clic su Salva.
  • Assicurati di avere una quota sufficiente per otto chip TPU v5e PodSlice Lite. In questo tutorial vengono utilizzate le istanze on demand.
  • Crea un account Kaggle, se non ne hai già uno.

Ottieni l'accesso al modello

Per ottenere l'accesso al modello Gemma per il deployment in GKE, devi prima firmare il contratto di consenso per la licenza.

Devi firmare il contratto di consenso per utilizzare Gemma. Segui queste istruzioni:

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

Genera un token di accesso

Per accedere al modello tramite Kaggle, ti serve un token API Kaggle.

Segui questa procedura 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 Create New Token (Crea nuovo token).

È stato scaricato un file denominato kaggle.json.

prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate in Google Cloud. Cloud Shell è preinstallato con il software necessario per questo tutorial, inclusi kubectl e con gcloud CLI.

Per configurare l'ambiente con Cloud Shell, segui questi passaggi:

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

  2. Imposta le variabili di ambiente predefinite:

    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

    Sostituisci i seguenti valori:

    • PROJECT_ID: il tuo ID progetto Google Cloud.
    • CLUSTER_NAME: il nome del tuo cluster GKE.
    • BUCKET_NAME: il nome del tuo bucket Cloud Storage. Non è necessario specificare il prefisso gs://.
    • REGION_NAME: la regione in cui GKE cluster, il bucket Cloud Storage e i nodi TPU. La regione contiene zone in cui sono disponibili tipi di macchine TPU v5e (ad esempio, us-west1, us-west4, us-central1, us-east1, us-east5 o europe-west4).
    • (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 ma solo la regione.

Creazione e configurazione delle risorse Google Cloud

Segui queste istruzioni per creare le risorse richieste.

Crea un cluster GKE

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

Autopilot

In Cloud Shell, esegui questo comando:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.29

GKE crea un cluster Autopilot con CPU e TPU come richiesto dai carichi di lavoro di cui è stato eseguito il deployment.

Standard

  1. Crea un cluster GKE Standard a livello di regione che utilizza la Federazione delle identità per i carichi di lavoro per GKE.

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

    La creazione del cluster potrebbe richiedere diversi minuti.

  2. Esegui questo comando per creare pool di nodi 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}

Questo crea un bucket Cloud Storage in cui archiviare i file del modello scaricare da Kaggle.

Carica il token di accesso su Cloud Shell

In Cloud Shell, puoi caricare il token dell'API Kaggle in 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 di Kubernetes per le credenziali di Kaggle

In Cloud Shell, segui questi passaggi:

  1. Configura kubectl per comunicare con il tuo cluster:

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

  2. Crea un secret per archiviare le credenziali di Kaggle:

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

Configura l'accesso ai carichi di lavoro utilizzando la federazione delle identità per i carichi di lavoro per GKE

Assegnare un ServiceAccount Kubernetes all'applicazione e configurare l'account Kubernetes in modo che agisca come 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 dei criteri IAM per il tuo account di servizio IAM a 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 all'account di servizio Kubernetes di impersonare l'account di servizio IAM aggiungendo un account IAM l'associazione di criteri tra i due account di servizio. Questa associazione consente a Kubernetes ServiceAccount per 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 l'account di servizio Kubernetes con l'indirizzo email account di servizio:

    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 di base Orbax 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 l'elaborazione.

Esegui il deployment del job di conversione del checkpoint del modello

Segui queste istruzioni per scaricare e convertire Gemma 7B dei file di punti di controllo del modello.

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

  2. Applica il manifest:

    kubectl apply -f job-7b.yaml

  3. Visualizza i log dal job:

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

    Una volta completato il 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 eseguirai il deployment del container JetStream per gestire l'oggetto Gemma model.

Segui queste istruzioni per eseguire il deployment di Gemma 7B modello ottimizzato per le istruzioni.

  1. Crea il seguente manifest jetstream-gemma-deployment.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: maxengine-server
spec:
  replicas: 2
  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
        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 tokenizzatore 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 della precompilazione quando si esegue 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 con sharding completo (FSDP).
    • ici_tensor_parallelism: il numero di shard per il parallelismo del tensore.
    • ici_autoregressive_parallelism: il numero di shard per il parallelismo autoregressivo.
    • scan_layers: flag booleano dei livelli di scansione (booleano).
    • weight_dtype: il tipo di dati sul 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

  4. Visualizza i log del server HTTP per verificare che il modello sia stato caricato e compilato. Il server potrebbe impiegare qualche minuto per completare questa operazione.

    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 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 devi interagire con il modello.

Configura il port forwarding

Puoi accedere al deployment JetStream tramite il servizio ClusterIP che creato nel passaggio precedente. I servizi ClusterIP sono raggiungibili solo dall'interno nel cluster. Pertanto, per accedere al servizio dall'esterno del cluster, devi completare segui questi passaggi:

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

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

Interagire 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) Interagire con il modello tramite un'interfaccia di chat con Google Radio.

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

Gradio è una libreria Python che include Wrapper ChatInterface che crea le interfacce utente per i chatbot.

Esegui il deployment dell'interfaccia di chat

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

  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

    Viene creato un port forwarding da Cloud Shell al servizio Gradio.

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

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

Risoluzione dei problemi

  • Se viene visualizzato il messaggio Empty reply from server, è possibile che il contenitore non abbia terminato il download dei dati del modello. Controlla di nuovo nei log del pod il messaggio Connected che indica che il modello è pronto per la pubblicazione.
  • Se vedi 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 creati in questa guida, esegui questi 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