Applicazione RAG agentica AlloyDB con MCP Toolbox

1. Introduzione

In questo codelab imparerai a creare un cluster AlloyDB, a eseguire il deployment del toolbox MCP e a configurarlo per utilizzare AlloyDB come origine dati. Poi creerai un'applicazione RAG interattiva di esempio che utilizza il toolbox di cui è stato eseguito il deployment per basare le sue richieste.

Puoi trovare maggiori informazioni su MCP Toolbox nella pagina di documentazione e nell'applicazione di esempio Cymbal Air qui.

Questo lab fa parte di una raccolta dedicata alle funzionalità di AI di AlloyDB. Puoi leggere di più sulla pagina di AlloyDB AI nella documentazione e consultare altri lab.

Prerequisiti

• Una comprensione di base della console Google Cloud
• Competenze di base nell'interfaccia a riga di comando e in Google Cloud Shell

Cosa imparerai a fare

• Come eseguire il deployment del cluster AlloyDB con l'integrazione di Vertex AI
• Come connettersi ad AlloyDB
• Come configurare ed eseguire il deployment del servizio MCP Toolbox
• Come eseguire il deployment di un'applicazione di esempio utilizzando il servizio di cui hai eseguito il deployment

Che cosa ti serve

• Un account Google Cloud e un progetto Google Cloud
• Un browser web come Chrome

2. Configurazione e requisiti

Configurazione dell'ambiente autonoma

1. Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai già un account Gmail o Google Workspace, devi crearne uno.

• Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
• Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da nessun altro dopo che lo hai selezionato. Sei l'unico utente di questo ID. Anche se un progetto viene eliminato, l'ID non può essere riutilizzato

Nota:se utilizzi un account Gmail, puoi lasciare la posizione predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una posizione adatta alla tua organizzazione.

2. Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono usufruire del programma prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:

Questa macchina virtuale è caricata con tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.

3. Prima di iniziare

Abilita l'API

Output:

Tieni presente che alcune risorse che attivi comportano dei costi se non utilizzi il livello promozionale. In circostanze normali, se tutte le risorse vengono distrutte al termine del lab, il costo di tutte le risorse non supera i 5 $. Ti consigliamo di controllare la fatturazione e assicurarti che l'esercizio sia accettabile per te.

In Cloud Shell, assicurati che l'ID progetto sia configurato:

Di solito, l'ID progetto viene mostrato tra parentesi nel prompt dei comandi in Cloud Shell, come mostrato nell'immagine:

gcloud config set project [YOUR-PROJECT-ID]

Poi imposta la variabile di ambiente PROJECT_ID sull'ID del tuo progetto Google Cloud:

PROJECT_ID=$(gcloud config get-value project)

Attiva tutti i servizi necessari:

gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       vpcaccess.googleapis.com \
                       aiplatform.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       run.googleapis.com \
                       iam.googleapis.com \
                       secretmanager.googleapis.com

Output previsto:

student@cloudshell:~ (gleb-test-short-004)$ gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       vpcaccess.googleapis.com \
                       aiplatform.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       run.googleapis.com \
                       iam.googleapis.com \
                       secretmanager.googleapis.com
Operation "operations/acf.p2-404051529011-664c71ad-cb2b-4ab4-86c1-1f3157d70ba1" finished successfully.

4. Esegui il deployment del cluster AlloyDB

Crea il cluster AlloyDB e l'istanza principale. La seguente procedura descrive come creare un cluster e un'istanza AlloyDB utilizzando Google Cloud SDK. Se preferisci l'approccio della console, puoi seguire la documentazione qui.

Prima di creare un cluster AlloyDB, abbiamo bisogno di un intervallo di indirizzi IP privati disponibile nel nostro VPC da utilizzare per la futura istanza AlloyDB. Se non lo abbiamo, dobbiamo crearlo, assegnarlo per l'utilizzo da parte dei servizi Google interni e solo dopo potremo creare il cluster e l'istanza.

Crea intervallo IP privato

Nota:questo passaggio è necessario solo se non hai già un intervallo IP privato inutilizzato assegnato per l'utilizzo con i servizi interni di Google.

Dobbiamo configurare l'accesso privato ai servizi nel nostro VPC per AlloyDB. Il presupposto è che nel progetto sia presente la rete VPC "predefinita" e che verrà utilizzata per tutte le azioni.

Crea l'intervallo IP privato:

gcloud compute addresses create psa-range \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --description="VPC private service access" \
    --network=default

Crea una connessione privata utilizzando l'intervallo IP allocato:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=psa-range \
    --network=default

Nota: l'esecuzione del secondo comando richiede un paio di minuti.

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ gcloud compute addresses create psa-range \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --description="VPC private service access" \
    --network=default
Created [https://www.googleapis.com/compute/v1/projects/test-project-402417/global/addresses/psa-range].

student@cloudshell:~ (test-project-402417)$ gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=psa-range \
    --network=default
Operation "operations/pssn.p24-4470404856-595e209f-19b7-4669-8a71-cbd45de8ba66" finished successfully.

student@cloudshell:~ (test-project-402417)$

Crea cluster AlloyDB

In questa sezione creiamo un cluster AlloyDB nella regione us-central1.

Definisci la password per l'utente postgres. Puoi definire una password personalizzata o utilizzare una funzione casuale per generarla.

export PGPASSWORD=`openssl rand -hex 12`

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ export PGPASSWORD=`openssl rand -hex 12`

Prendi nota della password PostgreSQL per utilizzarla in futuro.

echo $PGPASSWORD

Avrai bisogno di questa password in futuro per connetterti all'istanza come utente postgres. Ti consiglio di annotarlo o copiarlo da qualche parte per poterlo utilizzare in un secondo momento.

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ echo $PGPASSWORD
bbefbfde7601985b0dee5723

Creare un cluster di prova senza costi

Se non hai mai utilizzato AlloyDB, puoi creare un cluster di prova senza costi:

Definisci la regione e il nome del cluster AlloyDB. Utilizzeremo la regione us-central1 e alloydb-aip-01 come nome del cluster:

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01

Esegui il comando per creare il cluster:

gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION \
    --subscription-type=TRIAL

Output della console previsto:

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION \
    --subscription-type=TRIAL
Operation ID: operation-1697655441138-6080235852277-9e7f04f5-2012fce4
Creating cluster...done.                                                                                                                                                                                                                                                           

Crea un'istanza principale AlloyDB per il nostro cluster nella stessa sessione della shell Cloud. Se la connessione viene interrotta, dovrai definire nuovamente le variabili di ambiente del nome della regione e del cluster.

Nota:il completamento della creazione dell'istanza richiede in genere 6-10 minuti.

gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=8 \
    --region=$REGION \
    --cluster=$ADBCLUSTER

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=8 \
    --region=$REGION \
    --availability-type ZONAL \
    --cluster=$ADBCLUSTER
Operation ID: operation-1697659203545-6080315c6e8ee-391805db-25852721
Creating instance...done.                                                                                                                                                                                                                                                     

Crea un cluster AlloyDB Standard

Se non è il tuo primo cluster AlloyDB nel progetto, procedi con la creazione di un cluster standard.

Definisci la regione e il nome del cluster AlloyDB. Utilizzeremo la regione us-central1 e alloydb-aip-01 come nome del cluster:

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01

Esegui il comando per creare il cluster:

gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION

Output della console previsto:

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION 
Operation ID: operation-1697655441138-6080235852277-9e7f04f5-2012fce4
Creating cluster...done.                                                                                                                                                                                                                                                           

Crea un'istanza principale AlloyDB per il nostro cluster nella stessa sessione della shell Cloud. Se la connessione viene interrotta, dovrai definire nuovamente le variabili di ambiente del nome della regione e del cluster.

Nota:il completamento della creazione dell'istanza richiede in genere 6-10 minuti.

gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=2 \
    --region=$REGION \
    --cluster=$ADBCLUSTER

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=2 \
    --region=$REGION \
    --availability-type ZONAL \
    --cluster=$ADBCLUSTER
Operation ID: operation-1697659203545-6080315c6e8ee-391805db-25852721
Creating instance...done.                                                                                                                                                                                                                                                     

Concedi le autorizzazioni necessarie ad AlloyDB

Aggiungi le autorizzazioni Vertex AI al service agent AlloyDB.

Apri un'altra scheda di Cloud Shell utilizzando il segno "+" in alto.

Nella nuova scheda di Cloud Shell, esegui:

PROJECT_ID=$(gcloud config get-value project)
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

Output della console previsto:

student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-11039]
student@cloudshell:~ (test-project-001-402417)$ gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"
Updated IAM policy for project [test-project-001-402417].
bindings:
- members:
  - serviceAccount:[e-mail]
  role: roles/aiplatform.user
- members:
...
etag: BwYIEbe_Z3U=
version: 1
 

Chiudi la scheda con il comando di esecuzione "exit":

exit

5. Prepara la macchina virtuale GCE

Utilizzeremo una VM Google Compute Engine (GCE) come piattaforma per lavorare con il database e implementare diverse parti dell'applicazione di esempio. L'utilizzo di una VM ci offre maggiore flessibilità nei componenti installati e accesso diretto all'IP privato di AlloyDB per i passaggi di preparazione dei dati.

Crea service account

Poiché utilizzeremo la nostra VM per eseguire il deployment di MCP Toolbox come servizio e per eseguire il deployment o ospitare l'applicazione di esempio, il primo passaggio consiste nel creare un service account Google (GSA). L'account di servizio Google verrà utilizzato dalla VM GCE e dovremo concedergli i privilegi necessari per funzionare con altri servizi.

In Cloud Shell, esegui:

PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts create compute-aip --project $PROJECT_ID

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/cloudbuild.builds.editor"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/artifactregistry.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/storage.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/run.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/iam.serviceAccountUser"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/alloydb.viewer"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/alloydb.client"

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

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/serviceusage.serviceUsageConsumer"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/secretmanager.admin

Esegui il deployment della VM GCE

Crea una VM GCE nella stessa regione e nello stesso VPC del cluster AlloyDB.

In Cloud Shell, esegui:

ZONE=us-central1-a
PROJECT_ID=$(gcloud config get-value project)
gcloud compute instances create instance-1 \
    --zone=$ZONE \
    --create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --service-account=compute-aip@$PROJECT_ID.iam.gserviceaccount.com

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ ZONE=us-central1-a
PROJECT_ID=$(gcloud config get-value project)
gcloud compute instances create instance-1 \
    --zone=$ZONE \
    --create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --service-account=compute-aip@$PROJECT_ID.iam.gserviceaccount.com
Your active configuration is: [cloudshell-10282]
Created [https://www.googleapis.com/compute/v1/projects/gleb-test-short-002-470613/zones/us-central1-a/instances/instance-1].
NAME: instance-1
ZONE: us-central1-a
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE: 
INTERNAL_IP: 10.128.0.2
EXTERNAL_IP: 34.28.55.32
STATUS: RUNNING

Installare il client Postgres

Installa il software client PostgreSQL sulla VM di cui è stato eseguito il deployment

Connettiti alla VM:

Nota: la prima volta che la connessione SSH alla VM può richiedere più tempo, poiché il processo include la creazione della chiave RSA per la connessione sicura e la propagazione della parte pubblica della chiave al progetto

gcloud compute ssh instance-1 --zone=us-central1-a

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ gcloud compute ssh instance-1 --zone=us-central1-a
Updating project ssh metadata...working..Updated [https://www.googleapis.com/compute/v1/projects/test-project-402417].                                                                                                                                                         
Updating project ssh metadata...done.                                                                                                                                                                                                                                              
Waiting for SSH key to propagate.
Warning: Permanently added 'compute.5110295539541121102' (ECDSA) to the list of known hosts.
Linux instance-1 5.10.0-26-cloud-amd64 #1 SMP Debian 5.10.197-1 (2023-09-29) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
student@instance-1:~$ 

Installa il comando di esecuzione del software all'interno della VM:

sudo apt-get update
sudo apt-get install --yes postgresql-client

Output della console previsto:

student@instance-1:~$ sudo apt-get update
sudo apt-get install --yes postgresql-client
Get:1 file:/etc/apt/mirrors/debian.list Mirrorlist [30 B]
Get:4 file:/etc/apt/mirrors/debian-security.list Mirrorlist [39 B]
Hit:7 https://packages.cloud.google.com/apt google-compute-engine-bookworm-stable InRelease
Get:8 https://packages.cloud.google.com/apt cloud-sdk-bookworm InRelease [1652 B]
Get:2 https://deb.debian.org/debian bookworm InRelease [151 kB]
Get:3 https://deb.debian.org/debian bookworm-updates InRelease [55.4 kB]
...redacted...
update-alternatives: using /usr/share/postgresql/15/man/man1/psql.1.gz to provide /usr/share/man/man1/psql.1.gz (psql.1.gz) in auto mode
Setting up postgresql-client (15+248) ...
Processing triggers for man-db (2.11.2-2) ...
Processing triggers for libc-bin (2.36-9+deb12u7) ...

Connettiti all'istanza AlloyDB

Connettiti all'istanza primaria dalla VM utilizzando psql.

Continua con la sessione SSH aperta nella VM. Se la connessione si interrompe, connettiti di nuovo utilizzando lo stesso comando riportato sopra.

Utilizza $PGASSWORD annotato in precedenza e il nome del cluster per connetterti ad AlloyDB dalla VM GCE:

export PGPASSWORD=<Noted password>

PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"

Output della console previsto:

student@instance-1:~$ PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"
psql (15.13 (Debian 15.13-0+deb12u1), server 16.8)
WARNING: psql major version 15, server major version 16.
         Some psql features might not work.
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off)
Type "help" for help.

postgres=>

Esci dalla sessione psql mantenendo attiva la connessione SSH:

exit

Output della console previsto:

postgres=> exit
student@instance-1:~$ 

6. Inizializzare il database

Utilizzeremo la nostra VM client come piattaforma per popolare il database con i dati e ospitare la nostra applicazione. Il primo passaggio consiste nel creare un database e compilarlo con i dati.

Crea database

Crea un database con il nome "assistantdemo".

Nella sessione della VM GCE esegui:

Nota:se la sessione SSH è stata interrotta, devi reimpostare le variabili di ambiente, ad esempio:

export PGPASSWORD=<The noted AlloyDB password>

export REGION=us-central1

export ADBCLUSTER=alloydb-aip-01

export INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")

psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE assistantdemo"  

Output della console previsto:

student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE assistantdemo"
CREATE DATABASE
student@instance-1:~$  

Prepara l'ambiente Python

Per continuare, utilizzeremo gli script Python preparati dal repository GitHub, ma prima dobbiamo installare il software richiesto.

Nella VM GCE esegui:

sudo apt install -y python3.11-venv git
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip

Output della console previsto:

student@instance-1:~$ sudo apt install -y python3.11-venv git
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
  git-man liberror-perl patch python3-distutils python3-lib2to3 python3-pip-whl python3-setuptools-whl
Suggested packages:
  git-daemon-run | git-daemon-sysvinit git-doc git-email git-gui gitk gitweb git-cvs git-mediawiki git-svn ed diffutils-doc
The following NEW packages will be installed:
  git git-man liberror-perl patch python3-distutils python3-lib2to3 python3-pip-whl python3-setuptools-whl python3.11-venv
0 upgraded, 9 newly installed, 0 to remove and 2 not upgraded.
Need to get 12.4 MB of archives.
After this operation, 52.2 MB of additional disk space will be used.
Get:1 file:/etc/apt/mirrors/debian.list Mirrorlist [30 B]
...redacted...
Installing collected packages: pip
  Attempting uninstall: pip
    Found existing installation: pip 23.0.1
    Uninstalling pip-23.0.1:
      Successfully uninstalled pip-23.0.1
Successfully installed pip-24.0
(.venv) student@instance-1:~$

Verifica la versione di Python.

Nella VM GCE esegui:

python -V

Output della console previsto:

(.venv) student@instance-1:~$ python -V
Python 3.11.2
(.venv) student@instance-1:~$ 

Installare Strumenti MCP in locale

MCP Toolbox for Databases (in seguito nel testo MCP Toolbox o toolbox) è un server MCP open source che funziona con diverse origini dati. Ti aiuta a sviluppare strumenti più rapidamente fornendo un livello di astrazione per diverse origini dati e aggiungendo funzionalità come l'autenticazione e il raggruppamento delle connessioni. Puoi scoprire di più su tutte le funzionalità nella pagina ufficiale.

Utilizzeremo la toolbox MCP per inizializzare il nostro set di dati di esempio e in seguito come server MCP per gestire le richieste di origine dati dalla nostra applicazione durante il flusso di Retrieval-Augmented Generation (RAG).

Installiamo localmente MCP Toolbox per popolare il database assistantdemo.

Nella VM GCE esegui:

export VERSION=0.16.0
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox

Output della console previsto:

(.venv) student@instance-1:~$ export VERSION=0.16.0
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  133M  100  133M    0     0   158M      0 --:--:-- --:--:-- --:--:--  158M

Esegui Toolbox per l'inizializzazione dei dati

Nella VM GCE esegui:

Nota:se la sessione SSH è stata interrotta per inattività o per qualsiasi altro motivo, devi impostare le variabili di ambiente, ad esempio:

export PGPASSWORD=<Noted password>

REGION=us-central1

ADBCLUSTER=alloydb-aip-01

INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")

Esporta le variabili di ambiente per il popolamento del database:

export ALLOYDB_POSTGRES_PROJECT=$(gcloud config get-value project)
export ALLOYDB_POSTGRES_REGION="us-central1"
export ALLOYDB_POSTGRES_CLUSTER="alloydb-aip-01"
export ALLOYDB_POSTGRES_INSTANCE="alloydb-aip-01-pr"
export ALLOYDB_POSTGRES_DATABASE="assistantdemo"
export ALLOYDB_POSTGRES_USER="postgres"
export ALLOYDB_POSTGRES_PASSWORD=$PGPASSWORD
export ALLOYDB_POSTGRES_IP_TYPE="private"

Avvia la casella degli strumenti per l'inizializzazione del database. Avvierà il processo localmente, il che ti aiuterà a connetterti facilmente al database di destinazione su AlloyDB per riempirlo con dati di esempio.

./toolbox --prebuilt alloydb-postgres

Output previsto della console. Nell'ultima riga dell'output dovresti visualizzare il messaggio "Server ready to serve!":

student@instance-1:~$ cexport ALLOYDB_POSTGRES_PROJECT=$PROJECT_ID
export ALLOYDB_POSTGRES_REGION="us-central1"
export ALLOYDB_POSTGRES_CLUSTER="alloydb-aip-01"
export ALLOYDB_POSTGRES_INSTANCE="alloydb-aip-01-pr"
export ALLOYDB_POSTGRES_DATABASE="assistantdemo"
export ALLOYDB_POSTGRES_USER="postgres"
export ALLOYDB_POSTGRES_PASSWORD=$PGPASSWORD
export ALLOYDB_POSTGRES_IP_TYPE="private"
student@instance-1:~$ ./toolbox --prebuilt alloydb-postgres
2025-09-02T18:30:58.957655886Z INFO "Using prebuilt tool configuration for alloydb-postgres" 
2025-09-02T18:30:59.507306664Z INFO "Initialized 1 sources." 
2025-09-02T18:30:59.50748379Z INFO "Initialized 0 authServices." 
2025-09-02T18:30:59.507618807Z INFO "Initialized 2 tools." 
2025-09-02T18:30:59.507726704Z INFO "Initialized 2 toolsets." 
2025-09-02T18:30:59.508258894Z INFO "Server ready to serve!" 

Non uscire o chiudere questa scheda di Cloud Shell finché il popolamento dei dati non è completato.

Popola database

Apri un'altra scheda di Cloud Shell utilizzando il segno "+" in alto.

e connettiti alla VM instance-1:

gcloud compute ssh instance-1 --zone=us-central1-a

Output della console previsto:

student@cloudshell:~ (test-project-402417)$ gcloud compute ssh instance-1 --zone=us-central1-a
Linux instance-1 6.1.0-37-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Tue Sep  2 21:44:07 2025 from 35.229.111.9
student@instance-1:~$ 

Clona il repository GitHub con il codice per il servizio di recupero e l'applicazione di esempio.

Nella VM GCE esegui:

git clone  https://github.com/GoogleCloudPlatform/cymbal-air-toolbox-demo.git

Output della console previsto:

student@instance-1:~$ git clone  https://github.com/GoogleCloudPlatform/cymbal-air-toolbox-demo.git
Cloning into 'cymbal-air-toolbox-demo'...
remote: Enumerating objects: 3481, done.
remote: Counting objects: 100% (47/47), done.
remote: Compressing objects: 100% (41/41), done.
remote: Total 3481 (delta 16), reused 7 (delta 5), pack-reused 3434 (from 3)
Receiving objects: 100% (3481/3481), 57.96 MiB | 6.04 MiB/s, done.
Resolving deltas: 100% (2549/2549), done.
student@instance-1:~

Presta attenzione se riscontri errori.

Prepara l'ambiente Python e installa i pacchetti dei requisiti:

source .venv/bin/activate
cd cymbal-air-toolbox-demo
pip install -r requirements.txt

Imposta il percorso Python alla cartella principale del repository ed esegui lo script per compilare il database con il set di dati di esempio. Il primo comando aggiunge un percorso ai nostri moduli Python al nostro ambiente, mentre il secondo comando popola il nostro database con i dati.

export PYTHONPATH=$HOME/cymbal-air-toolbox-demo
python data/run_database_init.py

Output della console previsto(modificato). Alla fine dovrebbe essere visualizzato il messaggio "database init done":

student@instance-1:~$ source .venv/bin/activate
(.venv) student@instance-1:~$ 
(.venv) student@instance-1:~$ cd cymbal-air-toolbox-demo/
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ pip install -r requirements.txt
python run_database_init.py
Collecting fastapi==0.115.0 (from -r requirements.txt (line 1))
  Downloading fastapi-0.115.0-py3-none-any.whl.metadata (27 kB)
Collecting google-auth==2.40.3 (from -r requirements.txt (line 2))
  Downloading google_auth-2.40.3-py2.py3-none-any.whl.metadata (6.2 kB)
Collecting google-cloud-aiplatform==1.97.0 (from google-cloud-aiplatform[evaluation]==1.97.0->-r requirements.txt (line 3))
  Downloading google_cloud_aiplatform-1.97.0-py2.py3-none-any.whl.metadata (36 kB)
Collecting itsdangerous==2.2.0 (from -r requirements.txt (line 4))
  Downloading itsdangerous-2.2.0-py3-none-any.whl.metadata (1.9 kB)
Collecting jinja2==3.1.5 (from -r requirements.txt (line 5))
  Downloading jinja2-3.1.5-py3-none-any.whl.metadata (2.6 kB)
Collecting langchain-community==0.3.25 (from -r requirements.txt (line 6))
  Downloading langchain_community-0.3.25-py3-none-any.whl.metadata (2.9 kB)
Collecting langchain==0.3.25 (from -r requirements.txt (line 7))
...

(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ 
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ export PYTHONPATH=$HOME/cymbal-air-toolbox-demo
python data/run_database_init.py
Airports table initialized
Amenities table initialized
Flights table initialized
Tickets table initialized
Policies table initialized
database init done.
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ 

Ora puoi chiudere questa scheda.

Nella sessione VM esegui:

exit

Nella sessione di Cloud Shell, premi Ctrl+D o esegui :

exit

Nella prima scheda con MCP Toolbox in esecuzione, premi Ctrl+C per uscire dalla sessione di esecuzione della toolbox.

Il database è stato compilato con dati di esempio per l'applicazione.

Puoi verificarlo connettendoti al database e controllando il numero di righe nella tabella degli aeroporti. Puoi utilizzare l'utilità psql come abbiamo fatto in precedenza o AlloyDB Studio . Ecco come puoi controllarlo utilizzando psql

Nella sessione SSH della VM instance-1 esegui:

export PGPASSWORD=<Noted AlloyDB password>

REGION=us-central1
ADBCLUSTER=alloydb-aip-01
INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "SELECT COUNT(*) FROM airports"  

Output della console previsto:

student@instance-1:~$ REGION=us-central1
ADBCLUSTER=alloydb-aip-01
INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "SELECT COUNT(*) FROM airports"
 count 
-------
  7698
(1 row)

Il database è pronto e possiamo passare al deployment di MCP Toolbox.

7. Esegui il deployment di MCP Toolbox in Cloud Run

Ora possiamo eseguire il deployment di MCP Toolbox in Cloud Run. Esistono diversi modi per eseguire il deployment del toolkit MCP. Il modo più semplice è eseguirlo dalla riga di comando, ma se vogliamo che sia un servizio scalabile e affidabile, Cloud Run è una soluzione migliore.

Preparare l'ID client

Per utilizzare la funzionalità di prenotazione dell'applicazione, dobbiamo preparare l'ID client OAuth 2.0 utilizzando la console Cloud. Senza, non possiamo accedere all'applicazione con le nostre credenziali Google per effettuare una prenotazione e registrarla nel database.

Nella console Cloud, vai ad API e servizi e fai clic su "Schermata consenso OAuth". Ecco un link alla pagina. Si aprirà la pagina Panoramica di OAuth, in cui fare clic su Inizia.

Nella pagina successiva forniamo il nome dell'applicazione, l'email di assistenza utenti e facciamo clic su Avanti.

Nella schermata successiva scegliamo Interno per la nostra applicazione e facciamo di nuovo clic su Avanti.

Poi forniamo di nuovo l'email di contatto e facciamo clic su Avanti.

Poi accettiamo le norme dei servizi API di Google e premiamo il pulsante Crea.

Verrà visualizzata la pagina in cui possiamo creare un client OAuth.

Nella schermata scegliamo "Applicazione web" dal menu a discesa, inseriamo "Cymbal Air" come applicazione e premiamo il pulsante Aggiungi URI.

Gli URI rappresentano fonti attendibili per l'applicazione e dipendono da dove stai tentando di raggiungere l'applicazione. Abbiamo inserito "http://localhost:8081" come URI autorizzato e "http://localhost:8081/login/google" come URI di reindirizzamento. Questi valori funzionerebbero se inserissi "http://localhost:8081" come URI per la connessione nel browser. Ad esempio, quando ti connetti tramite un tunnel SSH dal tuo computer. Ti mostrerò come farlo più avanti.

Dopo aver premuto il pulsante "Crea", viene visualizzata una finestra popup con le credenziali dei clienti. Le credenziali verranno registrate nel sistema. Puoi sempre copiare l'ID client da utilizzare quando avvii l'applicazione.

Più avanti vedrai dove fornire l'ID client.

Crea service account

Abbiamo bisogno di un service account dedicato per il nostro servizio Cloud Run con tutti i privilegi richiesti. Per il nostro servizio, abbiamo bisogno dell'accesso ad AlloyDB e a Secret Manager di Google Cloud. Per quanto riguarda il nome del service account, utilizzeremo toolbox-identity.

Apri un'altra scheda di Cloud Shell utilizzando il segno "+" in alto.

Nella nuova scheda di Cloud Shell, esegui:

export PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts create toolbox-identity

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/alloydb.client"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/serviceusage.serviceUsageConsumer"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

Presta attenzione se riscontri errori. Il comando dovrebbe creare un service account per il servizio Cloud Run e concedere privilegi per lavorare con Secret Manager, database e Vertex AI.

Chiudi la scheda premendo Ctrl+D o eseguendo il comando "exit" nella scheda:

exit

Prepara la configurazione di MCP Toolbox

Prepara il file di configurazione per MCP Toolbox. Puoi leggere tutte le opzioni di configurazione nella documentazione, ma qui utilizzeremo il file di esempio tools.yaml e sostituiremo alcuni valori come il nome del cluster e dell'istanza, la password di AlloyDB e l'ID progetto con i nostri valori effettivi.

Esporta password AlloyDB:

export PGPASSWORD=<noted AlloyDB password>

Esporta l'ID client che abbiamo preparato nel passaggio precedente:

export CLIENT_ID=<noted OAuth 2.0 client ID for our application>

Prepara il file di configurazione.

PROJECT_ID=$(gcloud config get-value project)
ADBCLUSTER=alloydb-aip-01
sed -e "s/project: retrieval-app-testing/project: $(gcloud config get-value project)/g" \
-e "s/cluster: my-alloydb-cluster/cluster: $ADBCLUSTER/g" \
-e "s/instance: my-alloydb-instance/instance: $ADBCLUSTER-pr/g" \
-e "s/password: postgres/password: $PGPASSWORD\\n    ipType: private/g" \
-e "s/^ *clientId: .*/    clientId: $CLIENT_ID/g" \
cymbal-air-toolbox-demo/tools.yaml >~/tools.yaml

Se esamini la sezione del file che definisce l'origine dati di destinazione, vedrai che abbiamo aggiunto anche una riga per utilizzare l'IP privato per la connessione.

sources:
  my-pg-instance:
    kind: alloydb-postgres
    project: gleb-test-short-003-471020
    region: us-central1
    cluster: alloydb-aip-01
    instance: alloydb-aip-01-pr
    database: assistantdemo
    user: postgres
    password: L23F...
    ipType: private
authServices:
  my_google_service:
    kind: google
    clientId: 96828*******-***********.apps.googleusercontent.com

Crea un secret utilizzando la configurazione tools.yaml come origine.

Nella console SSH della VM, esegui:

gcloud secrets create tools --data-file=tools.yaml

Output della console previsto:

student@instance-1:~$ gcloud secrets create tools --data-file=tools.yaml
Created version [1] of the secret [tools].

Esegui il deployment di MCP Toolbox come servizio Cloud Run

Ora è tutto pronto per eseguire il deployment di MCP Toolbox come servizio su Cloud Run. Per i test locali puoi eseguire "./toolbox –tools-file=./tools.yaml", ma se vuoi che la tua applicazione venga eseguita nel cloud, il deployment in Cloud Run è molto più sensato.

Nella sessione SSH della VM, esegui:

export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest
gcloud run deploy toolbox \
    --image $IMAGE \
    --service-account toolbox-identity \
    --region us-central1 \
    --set-secrets "/app/tools.yaml=tools:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
    --network default \
    --subnet default \
    --no-allow-unauthenticated

Output della console previsto:

student@instance-1:~$ export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest
gcloud run deploy toolbox \
    --image $IMAGE \
    --service-account toolbox-identity \
    --region us-central1 \
    --set-secrets "/app/tools.yaml=tools:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
    --network default \
    --subnet default \
    --no-allow-unauthenticated
Deploying container to Cloud Run service [toolbox] in project [gleb-test-short-002-470613] region [us-central1]
✓ Deploying new service... Done.                                                                                                                                                                                                
  ✓ Creating Revision...                                                                                                                                                                                                        
  ✓ Routing traffic...                                                                                                                                                                                                          
Done.                                                                                                                                                                                                                           
Service [toolbox] revision [toolbox-00001-l9c] has been deployed and is serving 100 percent of traffic.
Service URL: https://toolbox-868691532292.us-central1.run.app

student@instance-1:~$

Verificare il servizio

Ora possiamo verificare se il servizio è attivo e se possiamo accedere all'endpoint. Utilizziamo l'utilità gcloud per ottenere l'endpoint del servizio di recupero e il token di autenticazione. In alternativa, puoi controllare l'URI del servizio nella console cloud.

Puoi copiare il valore e sostituire la parte "$(gcloud run services list –filter="(toolbox)" –format="value(URL)" nel comando curl .

Ecco come ottenere l'URL in modo dinamico dalla riga di comando:

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $(gcloud  run services list --filter="(toolbox)" --format="value(URL)")

Output della console previsto:

student@instance-1:~$ curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $(gcloud  run services list --filter="(toolbox)" --format="value(URL)")
🧰 Hello, World! 🧰student@instance-1:~$

Se visualizziamo il messaggio "Hello World", significa che il nostro servizio è attivo e gestisce le richieste.

8. Esegui il deployment dell'applicazione di esempio

Ora che il servizio di recupero è in esecuzione, possiamo eseguire il deployment di un'applicazione di esempio. L'applicazione rappresenta un assistente aeroportuale online in grado di fornire informazioni su voli e aeroporti e persino prenotare un volo in base ai dati su voli e aeroporti del nostro database.

L'applicazione può essere implementata localmente, su una VM nel cloud o su qualsiasi altro servizio come Cloud Run o Kubernetes. Qui ti mostreremo come eseguirne il deployment prima sulla VM.

Prepara l'ambiente

Continuiamo a lavorare sulla nostra VM utilizzando la stessa sessione SSH. Per eseguire la nostra applicazione abbiamo bisogno di alcuni moduli Python, che abbiamo già aggiunto quando abbiamo inizializzato il database in precedenza. Passiamo all'ambiente virtuale Python e modifichiamo la posizione nella directory dell'app.

Nella sessione SSH della VM, esegui:

source ~/.venv/bin/activate
cd cymbal-air-toolbox-demo

Output previsto (modificato):

student@instance-1:~$ source ~/.venv/bin/activate
cd cymbal-air-toolbox-demo
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$

Esegui l'applicazione dell'assistente

Prima di avviare l'applicazione, dobbiamo configurare alcune variabili di ambiente. La funzionalità di base dell'applicazione, come la ricerca di voli e servizi aeroportuali, richiede solo TOOLBOX_URL, che indirizza l'applicazione al servizio di recupero. Possiamo ottenerlo utilizzando il comando gcloud .

Nella sessione SSH della VM, esegui:

export TOOLBOX_URL=$(gcloud  run services list --filter="(toolbox)" --format="value(URL)")

Output previsto (modificato):

student@instance-1:~/cymbal-air-toolbox-demo$ export BASE_URL=$(gcloud  run services list --filter="(toolbox)" --format="value(URL)")

Per utilizzare le funzionalità più avanzate dell'applicazione, come la prenotazione e la modifica dei voli, dobbiamo accedere all'applicazione utilizzando il nostro Account Google e a questo scopo dobbiamo fornire la variabile di ambiente CLIENT_ID utilizzando l'ID client OAuth del capitolo Prepara l'ID client:

export CLIENT_ID=215....apps.googleusercontent.com

Output previsto (modificato):

student@instance-1:~/cymbal-air-toolbox-demo$ export CLIENT_ID=215....apps.googleusercontent.com

Ora possiamo eseguire la nostra applicazione:

python run_app.py

Output previsto:

student@instance-1:~/cymbal-air-toolbox-demo/llm_demo$ python run_app.py
INFO:     Started server process [2900]
INFO:     Waiting for application startup.
Loading application...
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8081 (Press CTRL+C to quit)

Connettersi all'applicazione

Esistono diversi modi per connettersi all'applicazione in esecuzione sulla VM. Ad esempio, puoi aprire la porta 8081 sulla VM utilizzando le regole firewall nel VPC o creare un bilanciatore del carico con IP pubblico. Qui utilizzeremo un tunnel SSH alla VM traducendo la porta locale 8080 nella porta VM 8081.

Connessione dalla macchina locale

Quando vogliamo connetterci da una macchina locale, dobbiamo eseguire un tunnel SSH. Puoi farlo utilizzando gcloud compute ssh:

gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8081:localhost:8081

Output previsto:

student-macbookpro:~ student$ gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081
Warning: Permanently added 'compute.7064281075337367021' (ED25519) to the list of known hosts.
Linux instance-1.us-central1-c.c.gleb-test-001.internal 6.1.0-21-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.90-1 (2024-05-03) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
student@instance-1:~$

Ora possiamo aprire il browser e utilizzare http://localhost:8081 per connetterci alla nostra applicazione. Dovremmo visualizzare la schermata dell'applicazione.

Connessione da Cloud Shell

In alternativa, possiamo utilizzare Google Cloud Shell per connetterci. Apri un'altra scheda di Cloud Shell utilizzando il segno "+" in alto.

Nella nuova scheda, recupera l'origine e l'URI di reindirizzamento per il client web che esegue il comando gcloud:

echo "origin:"; echo "https://8080-$WEB_HOST"; echo "redirect:"; echo "https://8080-$WEB_HOST/login/google"

Ecco l'output previsto:

student@cloudshell:~ echo "origin:"; echo "https://8080-$WEB_HOST"; echo "redirect:"; echo "https://8080-$WEB_HOST/login/google"
origin:
https://8080-cs-35704030349-default.cs-us-east1-rtep.cloudshell.dev
redirect:
https://8080-cs-35704030349-default.cs-us-east1-rtep.cloudshell.dev/login/google

Utilizza l'origine e il reindirizzamento degli URI come "Origini JavaScript autorizzate" e "URI di reindirizzamento autorizzati" per le nostre credenziali create nel capitolo "Prepara l'ID client", sostituendo o aggiungendo i valori http://localhost:8080 forniti originariamente.

Fai clic su "Cymbal Air" nella pagina ID client OAuth 2.0.

Inserisci gli URI di origine e di reindirizzamento per Cloud Shell e premi il pulsante Salva.

Nella nuova scheda di Cloud Shell, avvia il tunnel alla tua VM eseguendo il comando gcloud:

gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081

Se viene visualizzato l'errore "Impossibile assegnare l'indirizzo richiesto", ignoralo.

Ecco l'output previsto:

student@cloudshell:~ gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081
bind [::1]:8081: Cannot assign requested address
inux instance-1.us-central1-a.c.gleb-codelive-01.internal 6.1.0-21-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.90-1 (2024-05-03) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Sat May 25 19:15:46 2024 from 35.243.235.73
student@instance-1:~$

Apre la porta 8080 in Cloud Shell, che può essere utilizzata per l'"Anteprima web".

Fai clic sul pulsante "Anteprima web" in alto a destra di Cloud Shell e scegli "Anteprima sulla porta 8080" dal menu a discesa.

Si apre una nuova scheda nel browser web con l'interfaccia dell'applicazione. Dovresti visualizzare la pagina "Cymbal Air Customer Service Assistant".

Accedere all'applicazione

Una volta configurato tutto e aperta l'applicazione, possiamo utilizzare il pulsante "Accedi" in alto a destra della schermata dell'applicazione per fornire le nostre credenziali. È facoltativo e obbligatorio solo se vuoi provare la funzionalità di prenotazione dell'applicazione.

Si aprirà una finestra popup in cui possiamo scegliere le nostre credenziali.

Dopo aver eseguito l'accesso, l'applicazione è pronta e puoi iniziare a pubblicare le tue richieste nel campo nella parte inferiore della finestra.

Questa demo mostra l'assistente al servizio clienti Cymbal Air. Cymbal Air è una compagnia aerea passeggeri fittizia. L'assistente è un chatbot AI che aiuta i viaggiatori a gestire i voli e a cercare informazioni sull'hub di Cymbal Air presso l'aeroporto internazionale di San Francisco (SFO).

Senza accedere (senza CLIENT_ID), può aiutare a rispondere a domande degli utenti come:

Quando è il prossimo volo per Denver?

Ci sono negozi di lusso vicino al gate C28?

Dove posso prendere un caffè vicino al gate A6?

Dove posso acquistare un regalo?

Trova un volo da SFO a Denver in partenza oggi

Una volta eseguito l'accesso all'applicazione, puoi provare altre funzionalità, come prenotare voli o controllare se il posto assegnato è vicino al finestrino o al corridoio.

L'applicazione utilizza i modelli di base più recenti di Google per generare risposte e le integra con informazioni su voli e servizi del database operativo AlloyDB. Puoi leggere di più su questa applicazione demo nella pagina GitHub del progetto.

9. Pulire l'ambiente

Ora che tutte le attività sono completate, possiamo pulire l'ambiente

Elimina servizio Cloud Run

In Cloud Shell, esegui:

gcloud run services delete toolbox --region us-central1

Output della console previsto:

student@cloudshell:~ (gleb-test-short-004)$ gcloud run services delete retrieval-service --region us-central1
Service [retrieval-service] will be deleted.

Do you want to continue (Y/n)?  Y

Deleting [retrieval-service]...done.                                                                                                                                                                                                                 
Deleted service [retrieval-service].

Elimina il service account per il servizio Cloud Run

In Cloud Shell, esegui:

PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com --quiet

Output della console previsto:

student@cloudshell:~ (gleb-test-short-004)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-222]
student@cloudshell:~ (gleb-test-short-004)$ gcloud iam service-accounts delete retrieval-identity@$PROJECT_ID.iam.gserviceaccount.com --quiet
deleted service account [[e-mail]]
student@cloudshell:~ (gleb-test-short-004)$

Elimina le istanze e il cluster AlloyDB al termine del lab.

Elimina il cluster AlloyDB e tutte le istanze

Se hai utilizzato la versione di prova di AlloyDB. Non eliminare il cluster di prova se prevedi di testare altri lab e risorse utilizzando il cluster di prova. Non potrai creare un altro cluster di prova nello stesso progetto.

Il cluster viene eliminato con l'opzione force, che elimina anche tutte le istanze appartenenti al cluster.

In Cloud Shell definisci le variabili di progetto e di ambiente se la connessione è stata interrotta e tutte le impostazioni precedenti sono andate perse:

gcloud config set project <your project id>

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
export PROJECT_ID=$(gcloud config get-value project)

Elimina il cluster:

gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force

Nota: l'esecuzione del comando richiede 3-5 minuti.

Output della console previsto:

student@cloudshell:~ (test-project-001-402417)$ gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force
All of the cluster data will be lost when the cluster is deleted.

Do you want to continue (Y/n)?  Y

Operation ID: operation-1697820178429-6082890a0b570-4a72f7e4-4c5df36f
Deleting cluster...done.   

Elimina i backup di AlloyDB

Elimina tutti i backup AlloyDB per il cluster:

Nota:il comando distruggerà tutti i backup dei dati per il cluster con il nome specificato nella variabile di ambiente

for i in $(gcloud alloydb backups list --filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" --format="value(name)" --sort-by=~createTime) ; do gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done

Output della console previsto:

student@cloudshell:~ (test-project-001-402417)$ for i in $(gcloud alloydb backups list --filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" --format="value(name)" --sort-by=~createTime) ; do gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done
Operation ID: operation-1697826266108-60829fb7b5258-7f99dc0b-99f3c35f
Deleting backup...done.                                                                                                                                                                                                                                                            

Ora possiamo eliminare la nostra VM

Elimina VM GCE

In Cloud Shell, esegui:

export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet

Output della console previsto:

student@cloudshell:~ (test-project-001-402417)$ export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet
Deleted 

Elimina il service account per la VM GCE e il servizio di recupero

In Cloud Shell, esegui:

PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete compute-aip@$PROJECT_ID.iam.gserviceaccount.com --quiet

Output della console previsto:

student@cloudshell:~ (gleb-test-short-004)$ PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete compute-aip@$PROJECT_ID.iam.gserviceaccount.com --quiet
Your active configuration is: [cloudshell-222]
deleted service account [[e-mail]]
student@cloudshell:~ (gleb-test-short-004)$ 

10. Complimenti

Congratulazioni per aver completato il codelab.

Argomenti trattati

• Come eseguire il deployment del cluster AlloyDB
• Come connettersi ad AlloyDB
• Come configurare ed eseguire il deployment di MCP Toolbox Service
• Come eseguire il deployment di un'applicazione di esempio utilizzando il servizio di cui hai eseguito il deployment

11. Sondaggio

Output:

Come utilizzerai questo tutorial?

Solo leggere Leggere e completare gli esercizi