Eseguire il deployment di un'applicazione AI agentica su GKE con Agent Development Kit (ADK) e Vertex AI

Standard

---

Questa guida mostra come eseguire il deployment e gestire applicazioni di AI/ML agentiche containerizzate utilizzando Google Kubernetes Engine (GKE). Combinando Google Agent Development Kit (ADK) con Vertex AI come fornitore di modelli linguistici di grandi dimensioni (LLM), puoi rendere operativi gli agenti AI in modo efficiente e su larga scala. Questa guida ti accompagna nell'intero processo di sviluppo e deployment in produzione su GKE di un agente basato su FastAPI e Gemini 2.0 Flash.

Questa guida è rivolta a ingegneri di machine learning (ML), sviluppatori e architetti cloud interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per pubblicare applicazioni di AI/ML con agenti. Per scoprire di più sui ruoli comuni e sulle attività di esempio nei contenuti di Google Cloud , consulta Ruoli e attività utente comuni di GKE Enterprise.

Prima di iniziare, assicurati di avere familiarità con quanto segue:

• GKE
• Containerizzazione con Docker
• Vertex AI

Sfondo

Questa guida combina diverse tecnologie Google per creare una piattaforma scalabile per l'AI agentica. GKE fornisce l'orchestrazione dei container per l'agente, che è creato utilizzando l'ADK. Utilizzando l'API Vertex AI per l'inferenza LLM, il cluster GKE non richiede hardware GPU specializzato, perché l'inferenza viene gestita dall'infrastruttura gestita di Google.

Google Agent Development Kit (ADK)

Agent Development Kit (ADK) è un framework flessibile e modulare per lo sviluppo e il deployment di agenti AI. Sebbene sia ottimizzato per Gemini e l'ecosistema Google, ADK è indipendente dal modello e dal deployment ed è progettato per la compatibilità con altri framework.

Per saperne di più, consulta la documentazione dell'ADK.

Servizio Kubernetes gestito GKE

GKE è un servizio Kubernetes gestito per il deployment, lo scaling e la gestione delle applicazioni containerizzate. GKE fornisce l'infrastruttura necessaria, tra cui risorse scalabili, computing distribuito e networking efficiente, per gestire le esigenze di calcolo degli LLM.

Per ulteriori informazioni sui concetti chiave di Kubernetes, consulta Inizia a scoprire Kubernetes. Per saperne di più su GKE e su come ti aiuta a scalare, automatizzare e gestire Kubernetes, consulta la panoramica di GKE.

Vertex AI

Vertex AI è la piattaforma ML unificata di Google Cloud, che consente agli sviluppatori di creare, implementare e scalare modelli di AI/ML. Per le applicazioni di AI agentica su GKE, Vertex AI fornisce strumenti e servizi essenziali, tra cui l'accesso a LLM come Gemini 2.0 Flash, infrastruttura gestita per l'addestramento e l'inferenza e funzionalità MLOps per una gestione efficiente del ciclo di vita.

Quando utilizzi gli LLM tramite l'API Vertex AI, l'inferenza del modello viene eseguita sull'infrastruttura gestita di Google, riducendo la necessità di quote specifiche di GPU o TPU nel cluster GKE.

Per saperne di più su Vertex AI per le applicazioni di AI agentica, consulta la documentazione di Vertex AI.

Gemini 2.0 Flash

Gemini 2.0 Flash offre funzionalità di nuova generazione e capacità migliorate progettate per carichi di lavoro agentici, tra cui maggiore velocità, utilizzo di strumenti integrati, generazione multimodale e una finestra contestuale da 1 milione di token. Gemini 2.0 Flash migliora il modello Flash precedente e offre una qualità superiore a velocità simili.

Per informazioni tecniche su Gemini 2.0 Flash (ad esempio benchmark delle prestazioni, informazioni sui nostri set di dati di addestramento, iniziative in materia di sostenibilità, utilizzo e limitazioni previsti e il nostro approccio all'etica e alla sicurezza), consulta la scheda del modello Gemini 2.0 Flash.

Obiettivi

Questa guida mostra come:

• Configura l'ambiente Google Cloud .
• Crea un'immagine container per l'agente.
• Esegui il deployment dell'agente in un cluster GKE.
• Testa l'agente di cui hai eseguito il deployment.

Costi

Questa guida utilizza i seguenti componenti fatturabili di Google Cloud:

• GKE
• Artifact Registry
• Cloud Build
• Vertex AI

Esamina i prezzi di ogni servizio per comprendere i costi potenziali.

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.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

• Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin, roles/artifactregistry.admin, roles/cloudbuild.builds.editor, 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 dell'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.

  Prepara l'ambiente

  Questo tutorial utilizza Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell è preinstallato con il software necessario per questo tutorial, tra cui kubectl, terraform e Google Cloud CLI.

  Per configurare l'ambiente con Cloud Shell:

  1. Nella console Google Cloud , avvia una sessione Cloud Shell e fai clic su Attiva Cloud Shell. Questa azione avvia una sessione nel riquadro inferiore della console Google Cloud .

  2. Imposta le variabili di ambiente predefinite:

     gcloud config set project PROJECT_ID
     export GOOGLE_CLOUD_LOCATION=REGION
     export PROJECT_ID=PROJECT_ID
     export GOOGLE_CLOUD_PROJECT=$PROJECT_ID
     export WORKLOAD_POOL=$PROJECT_ID.svc.id.goog
     export PROJECT_NUMBER=$(gcloud projects describe --format json $PROJECT_ID | jq -r ".projectNumber")
     

     Sostituisci i seguenti valori:

     • PROJECT_ID: il tuo Google Cloud ID progetto.
     • REGION: la regione Google Cloud (ad esempio, us-central1) in cui eseguire il provisioning del cluster GKE, di Artifact Registry e di altre risorse regionali.

  Clona il progetto di esempio

  1. Dal terminale di Cloud Shell, clona il repository del codice campione del tutorial:

     git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
     

  2. Vai alla directory del tutorial:

     cd kubernetes-engine-samples/ai-ml/adk-vertex
     

  Creare e configurare risorse Google Cloud

  Per eseguire il deployment dell'agente su GKE, esegui il provisioning delle risorseGoogle Cloud necessarie. Puoi eseguire il deployment dell'agente utilizzando la gcloud CLId per l'esecuzione diretta dalla riga di comando o Terraform per l'infrastruttura come codice.

  gcloud

  Questa sezione fornisce i comandi dell'interfaccia a riga di comando gcloud per configurare il cluster GKE, Artifact Registry e la federazione delle identità per i carichi di lavoro per GKE per una perfetta integrazione con Vertex AI. Assicurati di aver impostato le variabili di ambiente come descritto in Prepara l'ambiente.

  1. Crea un cluster GKE: puoi eseguire il deployment della tua applicazione agentica containerizzata in un cluster GKE Autopilot o Standard. Utilizza un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi workload, consulta Scegliere una modalità operativa GKE.

     Autopilot

     In Cloud Shell, esegui questo comando:

     gcloud container clusters create-auto CLUSTER_NAME \
             --location=$GOOGLE_CLOUD_LOCATION \
             --project=$PROJECT_ID
     

     Sostituisci CLUSTER_NAME con il nome del tuo cluster GKE Autopilot.

     Standard

     In Cloud Shell, esegui questo comando:

     gcloud container clusters create CLUSTER_NAME \
         --location=$GOOGLE_CLOUD_LOCATION \
         --project=$PROJECT_ID \
         --release-channel=stable \
         --num-nodes=1 \
         --machine-type=e2-medium \
         --workload-pool=$PROJECT_ID.svc.id.goog
     

     Sostituisci CLUSTER_NAME con il nome del tuo cluster Standard.

  2. Crea un repository Artifact Registry per il tuo container Docker: crea un repository Artifact Registry per archiviare e gestire in modo sicuro l'immagine container Docker dell'agente. Questo registro privato contribuisce a garantire che la tua applicazione sia immediatamente disponibile per il deployment in GKE e si integra con Cloud Build.

     gcloud artifacts repositories create adk-repo \
         --repository-format=docker \
         --location=$GOOGLE_CLOUD_LOCATION \
         --project=$PROJECT_ID
     

  3. Recupera l'URL del repository: esegui questo comando per verificare il percorso completo del repository. Utilizzerai questo formato del percorso per taggare l'immagine Docker nel passaggio successivo.

     gcloud artifacts repositories describe adk-repo \
         --location $GOOGLE_CLOUD_LOCATION \
         --project=$PROJECT_ID
     

  4. Concedi all'account di servizio predefinito di Compute Engine i ruoli IAM richiesti: per impostazione predefinita, l'account di servizio predefinito di Compute Engine non dispone delle autorizzazioni per eseguire il push delle immagini in Artifact Registry o per visualizzare oggetti in Cloud Storage o log. Concedi i ruoli necessari per queste operazioni.

     ROLES_TO_ASSIGN=(
         "roles/artifactregistry.writer"
         "roles/storage.objectViewer"
         "roles/logging.viewer"
     )
     
     for ROLE in "${ROLES_TO_ASSIGN[@]}"; do
         gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
             --member="serviceAccount:${PROJECT_NUMBER}[e-mail]" \
             --role="${ROLE}"
     done
     

  5. Crea ed esegui il push dell'immagine container dell'agente: esegui questo comando per creare l'immagine Docker ed eseguirne il push in Artifact Registry. Assicurati che il Dockerfile e il codice dell'applicazione si trovino nella directory /app.

     export IMAGE_URL="${GOOGLE_CLOUD_LOCATION}-docker.pkg.dev/${PROJECT_ID}/adk-repo/adk-agent:latest"
     
     gcloud builds submit \
         --tag "$IMAGE_URL" \
         --project="$PROJECT_ID" \
         app
     

  6. Verifica che l'immagine sia stata inviata:

     gcloud artifacts docker images list \
         $GOOGLE_CLOUD_LOCATION-docker.pkg.dev/$PROJECT_ID/adk-repo/adk-agent \
         --project=$PROJECT_ID
     

  Terraform

  Questa sezione descrive come utilizzare Terraform per eseguire il provisioning delle risorse Google Cloud. Il repository di esempio che hai clonato include i file di configurazione Terraform necessari.

  Nota :se utilizzi Terraform, assicurati di specificare il valore REGION nel file default_env.tfvars.

  1. Inizializza Terraform: vai alla directory terraform e inizializza Terraform.

     terraform init
     

  2. Rivedi il piano di esecuzione: questo comando mostra le modifiche all'infrastruttura che Terraform apporterà.

     terraform plan -var-file=default_env.tfvars
     

  3. Applica la configurazione: esegui il piano Terraform per creare le risorse nel tuo progetto Google Cloud . Conferma con yes quando richiesto.

     terraform apply -var-file=default_env.tfvars
     

     Dopo aver eseguito questi comandi, Terraform esegue il provisioning del cluster GKE e del repository Artifact Registry e configura i ruoli IAM e i service account necessari, inclusa la federazione delle identità dei workload per GKE.

  Per scoprire di più sull'utilizzo di Terraform, consulta Supporto di Terraform per GKE.

  Configura kubectl per comunicare con il cluster

  Se non hai configurato kubectl per comunicare con il cluster, esegui questo comando:

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

  Sostituisci CLUSTER_NAME con il nome del tuo cluster GKE.

  Configura la federazione delle identità per i workload per l'accesso a GKE

  Puoi saltare questo passaggio se utilizzi Terraform. Questo processo collega un service account Kubernetes (KSA) a un account di servizio IAM per concedere in modo sicuro all'agente l'accesso ai servizi Google Cloud .

  1. Crea un account di servizio per l'accesso a Vertex AI:

     gcloud iam service-accounts create vertex-sa \
         --project=$PROJECT_ID
     

  2. Concedi all'account di servizio il ruolo aiplatform.user. Ciò consente all'account di servizio di interagire con Vertex AI.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:vertex-sa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/aiplatform.user"
     

  3. Crea un KSA nel tuo cluster. Assicurati di seguire le istruzioni riportate in Configurare kubectl per comunicare con il cluster prima di eseguire questo comando.

     kubectl create serviceaccount vertex-sa
     

  4. Annota la chiave KSA per collegarla al tuo account di servizio:

     kubectl annotate serviceaccount vertex-sa \
         iam.gke.io/gcp-service-account=vertex-sa@$PROJECT_ID.iam.gserviceaccount.com
     

  5. Concedi al tuo account di servizio le autorizzazioni per agire come utente di Workload Identity Federation for GKE per il service account Kubernetes:

     gcloud iam service-accounts add-iam-policy-binding vertex-sa@$PROJECT_ID.iam.gserviceaccount.com \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:$PROJECT_ID.svc.id.goog[default/vertex-sa]"
     

  Esegui il deployment e configura l'applicazione agente

  Dopo aver configurato le risorse Google Cloud , prepara l'applicazione agente per il deployment e configura il relativo runtime su GKE. Ciò comporta la definizione del codice dell'agente, la creazione di un Dockerfile per containerizzarlo e la scrittura di un manifest Kubernetes per eseguirne il deployment nel cluster.

  1. Comprendere la struttura dell'applicazione agente: la directory /app contiene i file principali dell'applicazione agente:
     • main.py: il punto di ingresso dell'applicazione FastAPI, responsabile dell'esposizione dell'API dell'agente.
     • agent.py: contiene la logica dell'agente ADK, definendo come utilizza Vertex AI e gestisce le richieste.
     • __init__.py: inizializza il pacchetto Python.
     • requirements.txt: elenca tutte le dipendenze Python per l'agente.
     • Dockerfile: definisce come l'applicazione viene pacchettizzata in un'immagine Docker.

  2. Crea il manifest del deployment dell'agente: nella directory tutorials-and-examples/adk/vertex, crea il seguente manifest come file denominato agent-deployment.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: adk-agent-deployment
       labels:
         app: adk-agent
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: adk-agent
       template:
         metadata:
           labels:
             app: adk-agent
         spec:
           serviceAccountName: vertex-sa
           containers:
           - name: adk-agent
             image: IMAGE_URL
             ports:
             - containerPort: 8000
             env:
             - name: GOOGLE_CLOUD_PROJECT_ID
               value: PROJECT_ID
             - name: GOOGLE_CLOUD_LOCATION
               value: REGION
             - name: GOOGLE_GENAI_USE_VERTEXAI
               value: "1"
             - name: PORT
               value: "8000"
             resources:
               requests:
                 memory: "512Mi"
                 cpu: "500m"
               limits:
                 memory: "1Gi"
                 cpu: "1"
     

     Sostituisci i seguenti valori:

     • IMAGE_URL: l'URL completo dell'immagine Docker di cui hai eseguito il push in Artifact Registry (ad esempio, us-central1-docker.pkg.dev/${PROJECT_ID}/adk-repo/adk-agent:latest). Puoi ottenere questo valore dall'output del comando gcloud artifacts docker images list nella sezione precedente. In alternativa, esegui un comando come il seguente: sed -i "s|image: IMAGE_URL|image: $IMAGE_URL|" agent-deployment.yaml.
     • PROJECT_ID: il tuo ID progetto Google Cloud .
     • REGION: la Google Cloud regione in cui viene eseguito il provisioning del cluster GKE.

  3. Applica il manifest di deployment:

     kubectl apply -f agent-deployment.yaml
     

     Questo comando crea il deployment e i pod associati per l'applicazione agente nel cluster GKE.

  4. Esporre l'agente: puoi utilizzare questi metodi per esporre l'agente per l'accesso.

     • Per accedere all'agente dall'esterno del cluster, crea un servizio Kubernetes. Per un'API web, è comune un servizio di tipo LoadBalancer.

     • Per lo sviluppo e i test locali, utilizza il comando kubectl port-forward per accedere direttamente al tuo agente.

     LoadBalancer

     1. Crea il seguente manifest come file denominato agent-service.yaml:

        apiVersion: v1
        kind: Service
        metadata:
          name: adk-agent-service
        spec:
          selector:
            app: adk-agent
          type: LoadBalancer # Creates an external IP address for access
          ports:
          -   protocol: TCP
            port: 80
            targetPort: 8000 # Matches the containerPort exposed in the Deployment
        

     2. Applica il manifest:

        kubectl apply -f agent-service.yaml
        

        Il provisioning dell'indirizzo IP esterno potrebbe richiedere alcuni minuti.

     3. Verifica che l'indirizzo IP sia stato sottoposto al provisioning:

        kubectl get service adk-agent-service
        

        Cerca il valore EXTERNAL-IP nell'output. Una volta disponibile, utilizza questo indirizzo IP per interagire con l'agente di cui è stato eseguito il deployment.

     port-forward

     Se utilizzi principalmente port-forward, valuta la possibilità di utilizzare un tipo di servizio ClusterIP anziché LoadBalancer, in quanto il servizio ClusterIP è interno e consuma meno risorse.

     POD_NAME=$(kubectl get pods -l app=adk-agent -o jsonpath='{.items[0].metadata.name}')
     kubectl port-forward $POD_NAME 8000:8000
     

     Questo comando blocca il terminale, ma inoltra il traffico da localhost:8000 sulla macchina all'agente in esecuzione all'interno del cluster GKE.

  Testa l'agente di cui hai eseguito il deployment

  Ora che l'applicazione dell'agente è stata implementata ed esposta, testane la funzionalità.

  Questa sezione descrive come identificare l'endpoint dell'agente e testare la relativa API.

  1. Identifica l'endpoint dell'agente: a seconda di come hai scelto di esporre l'agente nella sezione precedente, identifica il suo endpoint accessibile:

     LoadBalancer

     1. Recupera l'indirizzo IP esterno:

        kubectl get service adk-agent-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
        

     2. Archivia l'indirizzo IP esterno in una variabile di ambiente per facilitarne l'utilizzo:

        export AGENT_IP=$(kubectl get service adk-agent-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
        

        L'URL di base del tuo agente è http://${AGENT_IP}.

     port-forward

     Assicurati che il comando kubectl port-forward venga eseguito in un terminale separato. L'URL di base del tuo agente è http://localhost:8000.

  2. Testa l'API dell'agente: testa l'API dell'agente effettuando una richiesta curl al relativo endpoint /run. L'agente prevede un payload JSON con un campo messaggio. Sostituisci AGENT_BASE_URL con http://${AGENT_IP} (per LoadBalancer) o http://localhost:8000 (per l'inoltro delle porte).

     1. Crea una nuova sessione. In questo modo l'agente si prepara per una nuova conversazione.

        # The user ID and session ID are arbitrary.
        # The appName must match the agent's Python package directory name (in this case, "capital-agent").
        curl -X POST AGENT_BASE_URL/apps/capital-agent/users/user-123/sessions/session-123
        

        Puoi elencare le app disponibili con il seguente comando:

        curl -X GET AGENT_BASE_URL/list-apps
        

     2. Invia una query all'agente utilizzando i dettagli della sessione del passaggio precedente.

        curl -X POST AGENT_BASE_URL/run \
        -H "Content-Type: application/json" \
        -d '{
          "appName": "capital-agent",
          "userId": "user-123",
          "sessionId": "session-123",
          "newMessage": {
            "role": "user",
            "parts": [{
              "text": "Hello, agent! What can you do for me?"
            }]
          }
        }'
        

        Dovresti ricevere una risposta JSON dal tuo agente, che indica che elabora correttamente le richieste e interagisce con il modello Gemini tramite Vertex AI. La risposta contiene la risposta generata dall'agente in base al tuo messaggio.

  3. Accedi all'interfaccia utente web dell'agente (se applicabile): se l'agente include un'interfaccia utente basata sul web, accedi navigando fino a AGENT_BASE_URL in un browser web. L'ADK in genere include una UI web di base per l'interazione e il debug. Ad esempio, se hai esposto l'agente tramite un bilanciamento del carico e il suo EXTERNAL-IP è 34.123.45.67, vai a http://34.123.45.67 nel browser.

  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:

  gcloud

  gcloud container clusters delete CLUSTER_NAME \
      --location=${GOOGLE_CLOUD_LOCATION} \
      --project=$PROJECT_ID
  
  gcloud projects remove-iam-policy-binding $PROJECT_ID \
      --member "serviceAccount:vertex-sa@$PROJECT_ID.iam.gserviceaccount.com" \
      --role "roles/aiplatform.user"
  
  gcloud iam service-accounts delete vertex-sa@$PROJECT_ID.iam.gserviceaccount.com
  
  gcloud artifacts repositories delete adk-repo \
      --location=$GOOGLE_CLOUD_LOCATION \
      --project=$PROJECT_ID
  

  Sostituisci CLUSTER_NAME con il nome del tuo cluster GKE.

  Terraform

  1. Nel terminale Cloud Shell, vai alla directory tutorials-and-examples/adk/vertex/:

     cd tutorials-and-examples/adk/vertex/
     

  2. Esegui questo comando per rimuovere tutte le risorse definite nei file di configurazione Terraform.

     cd terraform
     terraform destroy
     

  Passaggi successivi

  • Scopri come configurare Horizontal Pod Autoscaler (HPA) per regolare automaticamente le risorse dell'agente on demand.
  • Scopri come configurare Identity-Aware Proxy (IAP) per le tue applicazioni web in esecuzione suGoogle Cloud, fornendo un'autorizzazione centralizzata per l'accesso alla UI dell'agente.
  • Scopri come utilizzare Cloud Logging e Cloud Monitoring per ottenere informazioni dettagliate sulle prestazioni e sull'integrità dell'agente all'interno del cluster GKE.
  • Esplora gli esempi sperimentali in GKE AI Labs che possono aiutarti a utilizzare GKE per accelerare le tue iniziative di AI agentica.