Inizia a utilizzare gli incorporamenti vettoriali con l'AI di AlloyDB

1. Introduzione

In questo codelab imparerai a utilizzare AlloyDB AI combinando la ricerca vettoriale con gli incorporamenti di Vertex AI. Questo lab fa parte di una raccolta dedicata alle funzionalità di AI di AlloyDB. Per saperne di più, consulta la pagina di AlloyDB AI nella documentazione.

Prerequisiti

• Una conoscenza di base di Google Cloud, console
• Competenze di base con l'interfaccia a riga di comando e Cloud Shell

Cosa imparerai a fare

• Come eseguire il deployment del cluster e dell'istanza principale di AlloyDB
• Come connettersi ad AlloyDB dalla VM Google Compute Engine
• Come creare un database e abilitare AlloyDB AI
• Come caricare i dati nel database
• Come utilizzare AlloyDB Studio
• Come utilizzare il modello di embedding di Gemini Enterprise Agent Platform in AlloyDB
• Come utilizzare Gemini Enterprise Agent Platform Studio
• Come arricchire il risultato utilizzando il modello generativo di Gemini Enterprise Agent Platform
• Come migliorare il rendimento utilizzando l'indice vettoriale

Che cosa ti serve

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

2. Configurazione e requisiti

Configurazione del progetto

1. Accedi alla console Google Cloud. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Utilizza un account personale anziché un account di lavoro o della scuola.

Attenzione:gli account di lavoro e scolastici potrebbero avere limitazioni che impediscono di attivare le API necessarie per questo lab o di accedere ad alcune risorse.

2. Crea un nuovo progetto o riutilizzane uno esistente. Per creare un nuovo progetto nella console Google Cloud, fai clic sul pulsante Seleziona un progetto nell'intestazione per aprire una finestra popup.

Nella finestra Seleziona un progetto, premi il pulsante Nuovo progetto per aprire una finestra di dialogo per il nuovo progetto.

Nella finestra di dialogo, inserisci il nome del progetto che preferisci e scegli la posizione.

• Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. Il nome del progetto non viene utilizzato dalle API di Google e può essere modificato in qualsiasi momento.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Google Cloud genera automaticamente un ID univoco, ma puoi personalizzarlo. Se l'ID generato non ti piace, puoi generarne un altro casuale o fornirne uno tuo per verificarne la disponibilità. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto, che in genere è identificato con il segnaposto PROJECT_ID.
• 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 altri 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 località predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una posizione adatta alla tua organizzazione.

Abilita fatturazione

Configurare un account di fatturazione personale

Se hai configurato la fatturazione utilizzando i crediti Google Cloud, puoi saltare questo passaggio.

Per configurare un account di fatturazione personale, vai qui per abilitare la fatturazione nella console Cloud.

Alcune note:

• Il completamento di questo lab dovrebbe costare meno di 3 $in risorse cloud.
• Per evitare ulteriori addebiti, puoi seguire i passaggi alla fine di questo lab per eliminare le risorse.
• I nuovi utenti hanno diritto alla 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:

In alternativa, puoi premere G e poi S. Questa sequenza attiverà Cloud Shell se ti trovi nella console Google Cloud o utilizza questo link.

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 per sviluppatori di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. 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:

L'attivazione di queste risorse può comportare costi. Se elimini l'istanza AlloyDB e il bucket di archiviazione dopo aver completato il lab, i costi totali non superano i 5 $. Verifica le impostazioni di fatturazione prima di procedere.

Per utilizzare AlloyDB, Compute Engine, Servizi di rete e Gemini Enterprise Agent Platform, devi abilitare le rispettive API nel tuo progetto Google Cloud.

Abilitazione delle API

All'interno di Cloud Shell nel terminale, assicurati che l'ID progetto sia configurato:

gcloud config set project [YOUR-PROJECT-ID]

Imposta la variabile di ambiente PROJECT_ID:

PROJECT_ID=$(gcloud config get-value project)

Abilita tutte le API necessarie:

gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       aiplatform.googleapis.com

Output previsto:

student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$ 
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       aiplatform.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.

Puoi leggere informazioni su ogni API abilitata nella documentazione.

4. Esegui il deployment di AlloyDB

Prima di creare un cluster AlloyDB, alloca un intervallo IP privato disponibile nella tua VPC da utilizzare per la futura istanza AlloyDB. Se non lo hai, devi crearlo, assegnarlo per l'utilizzo da parte dei servizi Google interni e, dopodiché, potrai 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.

Devi configurare la configurazione dell'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 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

Crea 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 16`

Output console previsto:

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

Prendi nota della password PostgreSQL per un utilizzo futuro:

echo $PGPASSWORD

In futuro ti servirà questa password per connetterti all'istanza come utente postgres. Salva questa password per utilizzarla nei passaggi successivi.

Output console previsto:

student@cloudshell:~ (test-project-402417)$ echo $PGPASSWORD
bbefbfde7601985b0dee5723 (Note: Yours will be different!)

Creare un cluster di prova senza costi

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

Imposta le variabili di ambiente per la regione e il 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 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 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:la 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 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. Se hai già creato un cluster di prova senza costi, salta questo passaggio.

Imposta le variabili di ambiente per la regione e il 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 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 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:la 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 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.                                                                                                                                                                                                                                                     

5. Connetterti ad AlloyDB

AlloyDB viene implementato utilizzando una connessione solo privata, quindi hai bisogno di una VM Compute Engine con il client PostgreSQL installato per lavorare con il database.

Esegui il deployment della VM GCE

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

In Cloud Shell, esegui:

export ZONE=us-central1-a
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-13 AND family!=debian-13-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform

Output console previsto:

student@cloudshell:~ (test-project-402417)$ export ZONE=us-central1-a
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-13 AND family!=debian-13-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform

Created [https://www.googleapis.com/compute/v1/projects/test-project-402417/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.71.192.233
STATUS: RUNNING

Installa 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 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 6.12.101+deb13-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.12.101-1 (2026-08-05) 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 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:2 file:/etc/apt/mirrors/debian-security.list Mirrorlist [39 B]                      
Hit:3 https://deb.debian.org/debian trixie InRelease                                    
Get:4 https://deb.debian.org/debian trixie-updates InRelease [47.3 kB]
Get:5 https://deb.debian.org/debian trixie-backports InRelease [54.0 kB]
Get:6 https://deb.debian.org/debian-security trixie-security InRelease [43.4 kB]
Hit:10 https://packages.cloud.google.com/apt google-compute-engine-trixie-stable InRelease
...redacted...
update-alternatives: using /usr/share/postgresql/17/man/man1/psql.1.gz to provide /usr/share/man/man1/psql.1.gz (psql.1.gz) in auto mode
Setting up postgresql-client (17+278) ...
Processing triggers for man-db (2.13.1-1) ...
Processing triggers for libc-bin (2.41-12+deb13u3) ...

Connettiti all'istanza

Connettiti all'istanza primaria dalla VM utilizzando psql.

Nella stessa scheda Cloud Shell con la sessione SSH aperta alla VM instance-1.

Utilizza il valore della password AlloyDB (PGPASSWORD) annotato e l'ID cluster AlloyDB per connetterti ad AlloyDB dalla VM GCE:

export PGPASSWORD=<Noted password>

export PROJECT_ID=$(gcloud config get-value project)
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 sslmode=require"

Output console previsto:

student@instance-1:~$ export PGPASSWORD=CQhOi5OygD4ps6ty
student@instance-1:~$ export PROJECT_ID=$(gcloud config get-value project)
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 sslmode=require"
psql (17.10 (Debian 17.10-0+deb13u1), server 17.9)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off, ALPN: postgresql)
Type "help" for help.

postgres=>

Chiudi la sessione psql:

exit

6. Prepara il database

Crea un database, abilita l'integrazione dell'AI di Agent Platform, crea oggetti di database e importa i dati.

Concedere le autorizzazioni necessarie ad AlloyDB

Aggiungi le autorizzazioni di Gemini Enterprise Agent Platform all'agente di servizio 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 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

Crea database

Guida rapida alla creazione di un database.

Nella sessione VM GCE esegui:

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

export PGPASSWORD=<Noted password>

export PROJECT_ID=$(gcloud config get-value project)

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)")

Crea database:

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

Output console previsto:

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

Abilita l'integrazione di Vertex AI

Abilita l'integrazione di Vertex AI e le estensioni pgvector nel database.

Nella VM GCE esegui:

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE"
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS vector"

Output console previsto:

student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE"
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS vector"
CREATE EXTENSION
CREATE EXTENSION
student@instance-1:~$ 

Importa dati

Scarica i dati preparati e importali nel nuovo database.

Nella VM GCE esegui:

gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_products from stdin csv header"
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_inventory from stdin csv header"
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_stores from stdin csv header"

Output console previsto:

student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
SET
SET
SET
SET
SET
 set_config 
------------
 
(1 row)
SET
SET
SET
SET
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE SEQUENCE
ALTER TABLE
ALTER SEQUENCE
ALTER TABLE
ALTER TABLE
ALTER TABLE
student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_products from stdin csv header"
COPY 941
student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_inventory from stdin csv header"
COPY 263861
student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_stores from stdin csv header"
COPY 4654
student@instance-1:~$

7. Calcolare gli incorporamenti

Dopo aver importato i dati, avrai i dati di prodotto nella tabella cymbal_products, l'inventario che mostra il numero di prodotti disponibili in ogni negozio nella tabella cymbal_inventory e l'elenco dei negozi nella tabella cymbal_stores. Devi calcolare i dati vettoriali in base alle descrizioni dei prodotti e puoi utilizzare funzioni come google_ml.embedding. Scopri di più sulla tecnologia utilizzata nella documentazione.

È facile generare incorporamenti per poche righe, ma come renderlo efficiente se ne abbiamo migliaia? Questa sezione spiega come generare e gestire gli incorporamenti per tabelle di grandi dimensioni. Scopri di più sulle diverse opzioni e tecniche nella guida.

Attiva la generazione rapida dell'incorporamento

Connettiti al database utilizzando psql dalla tua VM utilizzando l'IP dell'istanza AlloyDB e la password di postgres:

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"

Verifica la versione dell'estensione google_ml_integration.

SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

La versione deve essere 1.5.2 o successive. Ecco un esempio di output:

quickstart_db=> SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
 extversion 
------------
 1.6
(1 row)

La versione predefinita deve essere 1.6 o successive, ma se la tua istanza mostra una versione precedente, probabilmente deve essere aggiornata. Controlla se la manutenzione è stata disattivata per l'istanza.

Nota:la versione dell'estensione viene gestita automaticamente nel backend e non è necessario eseguire l'upgrade manualmente.

Tuttavia, puoi chiamare una procedura che attiva la versione di anteprima per il pacchetto (non utilizzare le versioni di anteprima in produzione).

CALL google_ml.upgrade_to_preview_version();

Verifica che il flag di database google_ml_integration.enable_faster_embedding_generation sia impostato su on. Nella stessa sessione psql, controlla il valore del flag:

show google_ml_integration.enable_faster_embedding_generation;

Se il flag si trova nella posizione corretta, l'output previsto è simile al seguente:

quickstart_db=> show google_ml_integration.enable_faster_embedding_generation;                          
 google_ml_integration.enable_faster_embedding_generation 
----------------------------------------------------------
 on
(1 row)

Se il valore del flag mostra "off", devi aggiornare l'istanza. Esegui questa operazione utilizzando la console web o il comando gcloud come descritto nella documentazione.

Esci dalla sessione psql:

exit;

Per aggiornare il flag utilizzando gcloud, esegui:

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
gcloud beta alloydb instances update $ADBCLUSTER-pr \
   --database-flags google_ml_integration.enable_faster_embedding_generation=on \
   --region=$REGION \
   --cluster=$ADBCLUSTER \
   --project=$PROJECT_ID \
   --update-mode=FORCE_APPLY

Potrebbero essere necessari alcuni minuti, ma alla fine il valore del flag dovrebbe essere impostato su "on". Dopodiché, puoi procedere con i passaggi successivi.

Creare una colonna di incorporamento

Connettiti al database utilizzando psql e crea una colonna virtuale con il tipo di dati vettoriali da utilizzare con la funzione di embedding nella tabella cymbal_products.

Nota:se la sessione SSH è stata terminata, reimposta le variabili di ambiente, ad esempio:

export PGPASSWORD=<Noted password>

export INSTANCE_IP=<AlloyDB Instance IP>

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"

Nella sessione psql, dopo aver eseguito la connessione al database, esegui:

ALTER TABLE cymbal_products ADD COLUMN embedding vector(768);

Il comando crea una colonna virtuale per i futuri incorporamenti.

Output console previsto:

quickstart_db=> ALTER TABLE cymbal_products ADD COLUMN embedding vector(768);
ALTER TABLE
quickstart_db=> 

Genera gli embedding in batch di 50 righe. Nella stessa sessione psql esegui:

Attiva la misurazione del tempo per calcolare la durata:

\timing

Esegui il comando:

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'cymbal_products',
    content_column => 'product_description',
    embedding_column => 'embedding',
    batch_size => 50
);

L'output della console mostra meno di 2 secondi per la generazione dell'incorporamento:

quickstart_db=> CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'cymbal_products',
    content_column => 'product_description',
    embedding_column => 'embedding',
    batch_size => 50
);
NOTICE:  Initialize embedding completed successfully for table cymbal_products
CALL
Time: 1458.704 ms (00:01.459)
quickstart_db=>

Puoi sperimentare diverse dimensioni dei batch e vedere se il tempo di esecuzione cambia.

Per impostazione predefinita, gli incorporamenti non vengono aggiornati se la colonna product_description corrispondente viene aggiornata o se viene inserita una riga completamente nuova. ma puoi farlo impostando il parametro incremental_refresh_mode.

Crea una colonna "product_embeddings" e rendila aggiornabile automaticamente:

ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768);
CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'cymbal_products',
    content_column => 'product_description',
    embedding_column => 'product_embedding',
    batch_size => 50,
    incremental_refresh_mode => 'transactional'
);

Inserisci una nuova riga nella tabella.

INSERT INTO "cymbal_products" ("uniq_id", "crawl_timestamp", "product_url", "product_name", "product_description", "list_price", "sale_price", "brand", "item_number", "gtin", "package_size", "category", "postal_code", "available", "product_embedding", "embedding") VALUES ('fd604542e04b470f9e6348e640cff794', NOW(), 'https://example.com/new_product', 'New Cymbal Product', 'This is a new cymbal product description.', 199.99, 149.99, 'Example Brand', 'EB123', '1234567890', 'Single', 'Cymbals', '12345', TRUE, NULL, NULL);

Esegui una query sulla tabella per confrontare due colonne di incorporamento:

SELECT uniq_id,embedding, (product_embedding::real[])[1:5] as product_embedding  FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';

L'output mostra che product_embedding viene compilato automaticamente, mentre embedding rimane vuoto:

quickstart_db=> SELECT uniq_id,embedding, (product_embedding::real[])[1:5] as product_embedding  FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';
             uniq_id              | embedding |                       product_embedding                       
----------------------------------+-----------+---------------------------------------------------------------
 fd604542e04b470f9e6348e640cff794 |           | {0.015003494,-0.005349732,-0.059790313,-0.0087091,-0.0271452}
(1 row)

Time: 3.295 ms

8. Esegui ricerca di somiglianze

Esegui una ricerca di somiglianza basata sugli embedding vettoriali generati utilizzando AlloyDB AI.

La query SQL può essere eseguita dalla stessa interfaccia a riga di comando psql o, in alternativa, da AlloyDB Studio. Qualsiasi output complesso e multiriga funziona meglio in AlloyDB Studio.

Connettersi ad AlloyDB Studio

Nota:nei capitoli seguenti, tutti i comandi SQL che richiedono la connessione al database possono essere eseguiti in alternativa in AlloyDB Studio.

Per aprire AlloyDB Studio:

1. Nella console Google Cloud, vai alla pagina Cluster per AlloyDB per PostgreSQL.
2. Seleziona l'istanza principale per aprire la relativa interfaccia web.

3. Quindi, fai clic su AlloyDB Studio a sinistra:

4. Seleziona il database quickstart_db, l'utente postgres, fornisci la password annotata e fai clic su Autentica.

Questa azione apre l'interfaccia di AlloyDB Studio.

5. Seleziona la scheda Query senza titolo per aprire l'editor SQL.

Si apre un editor in cui puoi eseguire comandi SQL, come mostrato nell'immagine seguente:

Se preferisci utilizzare psql da riga di comando, segui il percorso alternativo e connettiti al database dalla sessione SSH della VM come descritto nei capitoli precedenti.

Esegui ricerca di somiglianze

Esegui una query per ottenere un elenco dei prodotti disponibili più strettamente correlati alla richiesta di un cliente. La frase di ricerca passata al modello di embedding su Gemini Enterprise Agent Platform (lo stesso che abbiamo utilizzato per generare gli embedding per i nostri prodotti) per ottenere il valore del vettore per "Che tipo di alberi da frutto crescono bene qui?"

Esegui la query:

SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) as distance
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        distance ASC
LIMIT 10;

Ecco l'output previsto:

quickstart_db=> SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) as distance
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        distance ASC
LIMIT 10;
      product_name       |                                   description                                    | sale_price | zip_code |      distance       
-------------------------+----------------------------------------------------------------------------------+------------+----------+---------------------
 Cherry Tree             | This is a beautiful cherry tree that will produce delicious cherries. It is an d |      75.00 |    93230 | 0.43922018972266397
 Meyer Lemon Tree        | Meyer Lemon trees are California's favorite lemon tree! Grow your own lemons by  |         34 |    93230 |  0.4685112926118228
 Toyon                   | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e |      10.00 |    93230 |  0.4835677149651668
 California Lilac        | This is a beautiful lilac tree that can grow to be over 10 feet tall. It is an d |       5.00 |    93230 |  0.4947204525907498
 California Peppertree   | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e |      25.00 |    93230 |  0.5054166905547247
 California Black Walnut | This is a beautiful walnut tree that can grow to be over 80 feet tall. It is a d |     100.00 |    93230 |  0.5084219510932597
 California Sycamore     | This is a beautiful sycamore tree that can grow to be over 100 feet tall. It is  |     300.00 |    93230 |  0.5140519790508755
 Coast Live Oak          | This is a beautiful oak tree that can grow to be over 100 feet tall. It is an ev |     500.00 |    93230 |  0.5143126438081371
 Fremont Cottonwood      | This is a beautiful cottonwood tree that can grow to be over 100 feet tall. It i |     200.00 |    93230 |  0.5174774727252058
 Madrone                 | This is a beautiful madrona tree that can grow to be over 80 feet tall. It is an |      50.00 |    93230 |  0.5227400803389093

Ricevi 10 prodotti con descrizioni semanticamente vicine alla frase di ricerca, ordinati in base alla distanza, con il prodotto più simile in alto.

9. Migliora risposta

Puoi migliorare la risposta a un'applicazione client utilizzando il risultato della query e preparare un output significativo utilizzando i risultati della query forniti come parte del prompt per un modello linguistico generativo di base.

Per farlo, genera un file JSON con i risultati principali della ricerca vettoriale, quindi utilizza questo file JSON generato come aggiunta a un prompt per un modello di IA generativa in Agent Platform per creare un output significativo. Il primo passaggio genera il codice JSON, che viene poi testato in Agent Platform Studio. L'ultimo passaggio incorpora tutto in un'unica istruzione SQL che può essere utilizzata in un'applicazione.

Generare l'output in formato JSON

Modifica la query per generare l'output in formato JSON e restituire una sola riga da passare ad Agent Platform

Esegui la query:

WITH trees as (
SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id as product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;

Il JSON nell'output:

[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]

Esegui il prompt in Vertex AI Studio

Utilizza il JSON generato per fornirlo come parte del prompt al modello di AI generativa in Vertex AI Studio

Apri Gemini Enterprise Agent Platform Studio nella console Google Cloud.

Scrivi il tuo prompt nell'interfaccia:

Inserisci il seguente prompt:

You are a friendly advisor helping to find a product based on the customer's needs.

Based on the client request we have loaded a list of products closely related to search.

The list in JSON format with list of values like {"product_name":"name","description":"some description","sale_price":10,"zip_code": 10234, "produt_id": "02056727942aeb714dc9a2313654e1b0"}

Here is the list of products:

{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}

The customer asked "What tree is growing the best here?"

You should give information about the product, price and some supplemental information

Ecco il risultato quando eseguiamo il prompt :

La risposta include prezzo, descrizione e informazioni supplementari che il modello ottiene da fonti esterne in base alle informazioni sull'albero e sulla posizione.

Esegui il prompt in PSQL

Un risultato simile può essere ottenuto eseguendo Utilizza l'integrazione di AlloyDB AI con Gemini Enterprise Agent Platform per ottenere la stessa risposta da un modello generativo utilizzando SQL direttamente nel database. Prima di poter utilizzare il modello gemini-3.6-flash, devi registrarlo.

Registra il modello gemini-3.6-flash:

Prima di eseguire il comando riportato di seguito, sostituisci i valori del segnaposto PROJECT_ID con il tuo ID progetto.

Nell'esecuzione di AlloyDB Studio:

CALL google_ml.create_model(
model_id => 'gemini-3.6-flash',
model_request_url => 'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.6-flash:generateContent',
model_provider => 'google',
model_type => 'llm'
);

Puoi sempre verificare l'elenco dei modelli registrati selezionando le informazioni da google_ml.model_info_view.

SELECT model_id,model_type FROM google_ml.model_info_view WHERE model_id ILIKE '%flash%';

Ecco un output di esempio

quickstart_db=> SELECT model_id,model_type FROM google_ml.model_info_view WHERE model_id ILIKE '%flash%';
       model_id        | model_type 
-----------------------+------------
 gemini-3.6-flash      | llm
 gemini-2.0-flash      | llm
 gemini-2.5-flash      | llm
 gemini-2.0-flash-lite | llm
 gemini-2.5-flash-lite | llm
(5 rows)

Ora puoi utilizzare il JSON generato in una sottoquery come parte del prompt per il modello gemini-3.6-flash utilizzando SQL.

Nella sessione psql o AlloyDB Studio, esegui la seguente query:

WITH trees AS (
SELECT
        cp.product_name,
        cp.product_description AS description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id AS product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci ON
        ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON
        cs.store_id = ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005',
        'What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1),
prompt AS (
SELECT
        'You are a friendly advisor helping to find a product based on the customer''s needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","product_description":"some description","sale_price":10}
Here is the list of products:' || json_agg(trees) || 'The customer asked "What kind of fruit trees grow well here?"
You should give information about the product, price and some supplemental information' AS prompt_text
FROM
        trees),
response AS (
SELECT
        google_ml.predict_row( model_id =>'gemini-3.6-flash',
        request_body => json_build_object('contents',
        json_build_object('role',
        'user',
        'parts',
        json_build_object('text',
        prompt_text))))->'candidates'->0->'content'->'parts'->0->'text' AS resp
FROM
        prompt)
SELECT
REPLACE(resp::text, '\n', CHR(10))
FROM
        response;

Ecco l'output previsto. L'output potrebbe essere diverso a causa della natura non deterministica dei modelli di AI generativa:

"Hello there! I'd be delighted to help you pick out a wonderful fruit tree for your space. Based on our local selection, a fantastic option that grows very well is the **Cherry Tree**! Here are the details on this beautiful tree: * **Product:** Cherry Tree * **Price:** $75.00 ### Why it's a great choice: * **Delicious Harvest:** It produces tasty, fresh cherries right in your backyard. * **Size & Benefits:** It's a deciduous tree that grows to about 15 feet tall, making it ideal for providing both lovely shade and a bit of privacy. * **Year-Round Beauty:** It features lush, dark green leaves throughout the summer that transform into a stunning red in the autumn. * **Growing Requirements:** Cherry trees thrive best in cool, moist climates with sandy soil, and are perfectly suited for USDA hardiness zones 4 through 9. Please let me know if you have any questions about planting or if you'd like help adding this to your order!"

10. Crea indice vettoriale

Poiché questo set di dati è piccolo, i tempi di risposta dipendono principalmente dalle interazioni con i modelli sulla Gemini Enterprise Agent Platform. Tuttavia, quando esegui query su milioni di vettori, la ricerca vettoriale stessa può consumare una parte significativa del tempo di risposta e aumentare il carico sul database. Per migliorare le prestazioni di ricerca, puoi creare un indice vettoriale.

Crea indice ScaNN

Per creare un indice ScaNN, devi abilitare un'estensione aggiuntiva. L'estensione alloydb_scann fornisce un'interfaccia per lavorare con gli indici vettoriali Approximate Nearest Neighbor (ANN) utilizzando l'algoritmo Google ScaNN.

Esegui in AlloyDB Studio:

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

L'indice può essere creato in modalità MANUALE o AUTOMATICA. La modalità MANUALE è attivata per impostazione predefinita e puoi creare un indice e gestirlo come qualsiasi altro indice. Tuttavia, se attivi la modalità AUTO, puoi creare l'indice che non richiede alcuna manutenzione da parte tua. Puoi leggere in dettaglio tutte le opzioni nella documentazione. Non abbiamo righe sufficienti per creare l'indice in modalità AUTO, quindi lo creerai come MANUALE.

Esegui in AlloyDB Studio:

CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products
  USING scann (embedding cosine)
  WITH (num_leaves=10, max_num_levels = 1);

Per informazioni sulla regolazione dei parametri dell'indice, consulta la documentazione.

Output previsto:

quickstart_db=> CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products
  USING scann (embedding cosine)
  WITH (num_leaves=10, max_num_levels = 1);
CREATE INDEX
quickstart_db=>

Confronta risposta

Ripeti la query che abbiamo utilizzato per ottenere il valore più alto nella ricerca semantica:

WITH trees as (
SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id as product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;

Output previsto:

[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]

Lo stesso "Ciliegio" nell'output.

Verifica l'utilizzo dell'indice:

EXPLAIN (analyze) 
WITH trees as (
SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id as product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;

Output previsto (modificato per chiarezza):

...
 Aggregate  (cost=27.24..27.25 rows=1 width=32) (actual time=0.964..0.965 rows=1 loops=1)
   ->  Subquery Scan on trees  (cost=18.91..27.23 rows=1 width=142) (actual time=0.953..0.954 rows=1 loops=1)
         ->  Limit  (cost=18.91..27.22 rows=1 width=158) (actual time=0.948..0.949 rows=1 loops=1)
               ->  Nested Loop  (cost=18.91..7126.86 rows=855 width=158) (actual time=0.948..0.948 rows=1 loops=1)
                     ->  Nested Loop  (cost=18.63..7103.59 rows=855 width=907) (actual time=0.931..0.931 rows=1 loops=1)
                           ->  Index Scan using cymbal_products_embeddings_scann on cymbal_products cp  (cost=18.21..343.15 rows=942 width=903) (actual time=0.906..0.908 rows=2 loops=1)
                                 Order By: (embedding <=> '[-0.106554024,0.035774965,-0.027267234,-0.045653425,-0.03286045,0.02124319...

Dall'output puoi vedere che la query utilizzava "Index Scan using cymbal_products_embeddings_scann on cymbal_products".

La query restituisce lo stesso ciliegio che appariva in cima ai risultati di ricerca prima della creazione dell'indice. Poiché gli indici approssimativi del vicino più prossimo (ANN) sacrificano l'accuratezza assoluta a favore della velocità di ricerca, le query basate su indici potrebbero occasionalmente restituire risultati principali leggermente diversi rispetto a una ricerca esatta non indicizzata. Tuttavia, l'indice vettoriale offre un notevole aumento delle prestazioni mantenendo un'elevata precisione.

Per approfondire, puoi provare altri tipi di indice vettoriale o trovare altri lab ed esempi con l'integrazione di LangChain nella pagina della documentazione.

11. Liberare spazio

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

Se il terminale si è disconnesso, connettiti di nuovo e definisci le variabili di progetto e di ambiente in Cloud Shell:

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

12. Complimenti

Congratulazioni per aver completato il codelab.

Questo lab fa parte del percorso di apprendimento per l'AI pronta per la produzione con Google Cloud.

• Esplora il curriculum completo per colmare il divario tra prototipo e produzione.
• Condividi i tuoi progressi con l'hashtag #ProductionReadyAI.

Argomenti trattati

• Come eseguire il deployment del cluster e dell'istanza principale di AlloyDB
• Come connettersi ad AlloyDB dalla VM Google Compute Engine
• Come creare un database e abilitare AlloyDB AI
• Come caricare i dati nel database
• Come utilizzare AlloyDB Studio
• Come utilizzare il modello di embedding di Gemini Enterprise Agent Platform in AlloyDB
• Come utilizzare Gemini Enterprise Agent Platform Studio
• Come arricchire il risultato utilizzando il modello generativo di Gemini Enterprise Agent Platform
• Come migliorare il rendimento utilizzando l'indice vettoriale

13. Sondaggio

Output:

Come utilizzerai questo tutorial?

Solo lettura Lettura e completamento degli esercizi