1. Introduzione
In questo codelab imparerai a eseguire la ricerca ibrida in AlloyDB utilizzando l'estensione RUM (Ranking Update Method) e l'indice ScaNN (Scalable Nearest Neighbor). 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 nell'interfaccia a riga di comando e in Google Shell
Cosa imparerai a fare
- Come eseguire il deployment del cluster e dell'istanza principale di AlloyDB
- Come connettersi ad AlloyDB da una VM Google Compute Engine
- Come creare un database e abilitare AlloyDB AI
- Come caricare i dati nel database
- Come utilizzare AlloyDB Studio
- Genera incorporamenti con Vertex AI
- Come creare un indice vettoriale ScaNN per migliorare la ricerca vettoriale
- Come creare un wrapper di dati esterni (FDW) per Elasticsearch
- Esegui la ricerca ibrida combinando la ricerca semantica in AlloyDB con la ricerca full-text in Elastic.
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
Accedi a Google Cloud Console. 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.
Crea un progetto Google Cloud
- Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.
- Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.
Abilita fatturazione
Per attivare la fatturazione, hai due opzioni. Puoi utilizzare il tuo account di fatturazione personale o riscattare i crediti seguendo questi passaggi.
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.
Cloud Shell è un ambiente a riga di comando in esecuzione in Google Cloud che viene precaricato con gli strumenti necessari.
- Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud.
- Una volta connesso a Cloud Shell, verifica l'autenticazione:
gcloud auth list - Verifica che il progetto sia configurato:
gcloud config get project - Se il progetto non è impostato come previsto, impostalo:
export PROJECT_ID=<YOUR_PROJECT_ID> gcloud config set project $PROJECT_ID
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:
Per utilizzare AlloyDB, Compute Engine, Servizi di rete e Vertex AI, 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 \
secretmanager.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 \
secretmanager.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.
Presentazione delle API
- L'API AlloyDB (
alloydb.googleapis.com) consente di creare, gestire e scalare i cluster AlloyDB per PostgreSQL. Fornisce un servizio di database completamente gestito e compatibile con PostgreSQL progettato per carichi di lavoro transazionali e analitici aziendali impegnativi. - L'API Compute Engine (
compute.googleapis.com) consente di creare e gestire macchine virtuali (VM), dischi permanenti e impostazioni di rete. Fornisce le basi di Infrastructure as a Service (IaaS) necessarie per eseguire i carichi di lavoro e ospitare l'infrastruttura sottostante per molti servizi gestiti. - L'API Cloud Resource Manager (
cloudresourcemanager.googleapis.com) ti consente di gestire in modo programmatico i metadati e la configurazione del tuo progetto Google Cloud. Consente di organizzare le risorse, gestire i criteri IAM (Identity and Access Management) e convalidare le autorizzazioni nella gerarchia dei progetti. - L'API Service Networking (
servicenetworking.googleapis.com) ti consente di automatizzare la configurazione della connettività privata tra la tua rete Virtual Private Cloud (VPC) e i servizi gestiti di Google. È necessario in particolare per stabilire l'accesso IP privato per servizi come AlloyDB, in modo che possano comunicare in modo sicuro con le altre risorse. - L'API Vertex AI (
aiplatform.googleapis.com) consente alle tue applicazioni di creare, eseguire il deployment e scalare modelli di machine learning. Fornisce l'interfaccia unificata per tutti i servizi di AI di Google Cloud, incluso l'accesso ai modelli di AI generativa (come Gemini) e l'addestramento di modelli personalizzati. - L'API Secret Manager (
secretmanager.googleapis.com) è un servizio di gestione di secret e credenziali che consente di archiviare e gestire dati sensibili come chiavi API, nomi utente, password, certificati e altro ancora.
Se vuoi, puoi configurare la regione predefinita per utilizzare i modelli di incorporamento di Vertex AI. Scopri di più sulle località disponibili per Vertex AI. Nell'esempio utilizziamo la regione us-central1.
gcloud config set compute/region us-central1
4. Esegui il deployment di AlloyDB
Prima di creare un cluster AlloyDB, abbiamo bisogno di un intervallo di IP privati disponibile nella nostra 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
Dobbiamo configurare la configurazione dell'accesso privato ai servizi nel nostro VPC per AlloyDB. Il presupposto è che nel progetto sia presente la rete VPC "default" 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 \
--export-custom-routes
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
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 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 copiarla in una posizione sicura (ad es. un gestore delle password).
Output console previsto:
student@cloudshell:~ (test-project-402417)$ echo $PGPASSWORD <generated password>
Crea cluster AlloyDB
Definisci la regione e il nome del cluster AlloyDB. Utilizzeremo la regione us-central1 e alloydb-hybrid-search come nome del cluster:
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
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-hybrid-search
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.
gcloud alloydb instances create $ADBCLUSTER-pr \
--instance-type=PRIMARY \
--cpu-count=2 \
--region=$REGION \
--cluster=$ADBCLUSTER
Output console previsto:
student@cloudshell:~ (alloydb-hybrid-search)$ 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 abbiamo bisogno di una VM con il client PostgreSQL installato per lavorare con il database. Utilizzeremo questa VM anche per eseguire un'istanza Elasticsearch.
Esegui il deployment della VM GCE
Crea una VM GCE nella stessa regione e nello stesso VPC del cluster AlloyDB, assicurati che il disco di avvio sia abbastanza grande per eseguire Elasticsearch. Qui specifichiamo un disco di avvio da 20 GB nel flag --create-disk.
In Cloud Shell, esegui:
export ZONE=us-central1-a
gcloud compute instances create instance-1 \
--zone=$ZONE \
--create-disk=auto-delete=yes,boot=yes,size=20,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
Output console previsto:
student@cloudshell:~ (alloydb-hybrid-search)$ export ZONE=us-central1-a
student@cloudshell:~ (talloydb-hybrid-search)$ 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-12 AND family!=debian-12-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
Installare il client Postgres
Installa il software client PostgreSQL sulla VM di cui è stato eseguito il deployment
Connettiti alla VM:
gcloud compute ssh instance-1 --zone=us-central1-a
Output console previsto:
student@cloudshell:~ (alloydb-hybrid-search)$ gcloud compute ssh instance-1 --zone=us-central1-a Updating project ssh metadata...working..Updated [https://www.googleapis.com/compute/v1/projects/alloydb-hybrid-search]. 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.us-central1-a.c.gleb-test-short-001-418811.internal 6.1.0-18-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.76-1 (2024-02-01) 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 https://packages.cloud.google.com/apt google-compute-engine-bullseye-stable InRelease [5146 B] Get:2 https://packages.cloud.google.com/apt cloud-sdk-bullseye InRelease [6406 B] Hit:3 https://deb.debian.org/debian bullseye InRelease Get:4 https://deb.debian.org/debian-security bullseye-security InRelease [48.4 kB] Get:5 https://packages.cloud.google.com/apt google-compute-engine-bullseye-stable/main amd64 Packages [1930 B] Get:6 https://deb.debian.org/debian bullseye-updates InRelease [44.1 kB] Get:7 https://deb.debian.org/debian bullseye-backports InRelease [49.0 kB] ...redacted... update-alternatives: using /usr/share/postgresql/13/man/man1/psql.1.gz to provide /usr/share/man/man1/psql.1.gz (psql.1.gz) in auto mode Setting up postgresql-client (13+225) ... Processing triggers for man-db (2.9.4-2) ... Processing triggers for libc-bin (2.31-13+deb11u7) ...
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-hybrid-search
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=<noted password> student@instance-1:~$ ADBCLUSTER=alloydb-aip-01 student@instance-1:~$ REGION=us-central1 student@instance-1:~$ INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)") gleb@instance-1:~$ psql "host=$INSTANCE_IP user=postgres sslmode=require" psql (15.6 (Debian 15.6-0+deb12u1), server 15.5) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off) Type "help" for help. postgres=>
Chiudi la sessione psql:
exit
6. Prepara il database
Dobbiamo creare un database, abilitare l'integrazione di Vertex AI, creare oggetti di database e importare i dati.
Concedere 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 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:service-4470404856@gcp-sa-alloydb.iam.gserviceaccount.com role: roles/aiplatform.user - members: ... etag: BwYIEbe_Z3U= version: 1
Chiudi la scheda facendo clic su "X" o eseguendo il comando:
exit
Crea database
Crea un database denominato quickstart.
Nella sessione della VM GCE esegui:
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:~$
Abilitare 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 i 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:~$ gcloud storage 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:~$ 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" COPY 941 student@instance-1:~$ 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" COPY 263861 student@instance-1:~$ 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" COPY 4654 student@instance-1:~$
Successivamente, impostiamo i flag di database necessari. Puoi utilizzare la console web e gestire i flag nell'istanza principale oppure utilizzare il comando gcloud nel seguente modo:
export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
gcloud beta alloydb instances update $ADBCLUSTER-pr \
--database-flags google_ml_integration.enable_faster_embedding_generation=on,scann.enable_preview_features=on,google_ml_integration.enable_preview_ai_functions=on,google_ml_integration.enable_ai_query_engine=on \
--region=$REGION \
--cluster=$ADBCLUSTER \
--project=$PROJECT_ID \
--update-mode=FORCE_APPLY
Output della console previsto
export PROJECT_ID=$(gcloud config get-value project) export REGION=us-central1 export ADBCLUSTER=alloydb-hybrid-search gcloud beta alloydb instances update $ADBCLUSTER-pr \ --database-flags google_ml_integration.enable_faster_embedding_generation=on,scann.enable_preview_features=on,google_ml_integration.enable_preview_ai_functions=on,google_ml_integration.enable_ai_query_engine=on \ --region=$REGION \ --cluster=$ADBCLUSTER \ --project=$PROJECT_ID \ --update-mode=FORCE_APPLY Your active configuration is: [cloudshell-724] Operation ID: operation-1775159889986-64e7f9ea9858a-b031e866-4c7c36df
L'abilitazione dei flag di database richiede il riavvio dell'istanza e richiederà alcuni minuti. Una volta completata, lo stato dell'istanza AlloyDB sarà "Pronta".
7. Genera vector embedding
Dopo aver importato i dati, abbiamo le seguenti tabelle: cymbal_products che memorizza le informazioni sui prodotti, cymbal_inventory che tiene traccia delle scorte di articoli in ogni negozio e cymbal_stores che è un elenco di negozi. Per eseguire la ricerca semantica sui nostri prodotti, dobbiamo generare incorporamenti vettoriali delle descrizioni dei prodotti con la funzione initialize_embeddings. Utilizzeremo l'integrazione di Vertex AI per calcolare i dati vettoriali in base alle descrizioni dei prodotti e aggiungerli alla tabella. Per saperne di più sulla tecnologia utilizzata, consulta la documentazione.
Per utilizzare l'integrazione, connettiti al database con AlloyDB Studio o utilizzando psql dalla tua VM utilizzando l'IP dell'istanza AlloyDB e la password di PostgreSQL:
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.5.2 (1 row)
La versione predefinita deve essere 1.5.2 o successiva, ma se la tua istanza mostra una versione precedente, probabilmente deve essere aggiornata. Controlla se la manutenzione è stata disattivata per l'istanza.
Installa l'estensione vettoriale e crea una nuova colonna per archiviare gli embedding in cymbal_products
CREATE EXTENSION IF NOT EXISTS vector;
ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768);
Output console previsto:
quickstart_db=> ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768); ALTER TABLE quickstart_db=>
Utilizzeremo la generazione di incorporamenti batch per migliorare l'efficienza. Puoi scoprire di più sulle diverse opzioni e tecniche di generazione degli incorporamenti nella guida. In precedenza abbiamo attivato il flag goole_ml_integration.enable_faster_embedding_generation, che ci consente di generare incorporamenti in batch.
Infine, vogliamo che anche gli incorporamenti vengano aggiornati quando i valori delle colonne vengono modificati includendo l'argomento incremental_refresh_mode nella chiamata di funzione. Ciò introduce un overhead nel nostro database, ma è un compromesso che facciamo per mantenere automaticamente gli incorporamenti sincronizzati con i contenuti. Se vuoi aggiornare manualmente gli incorporamenti, puoi trovare le istruzioni nella documentazione.
Ora, mettendo tutto insieme e generando gli embedding, utilizziamo la funzione initialize_embeddings e passiamo batch_size di 50 come suggerimento per il batch e impostiamo incremental_refresh_mode su transactional
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'
);
Se ora inseriamo una nuova riga nella tabella con il valore NULL per la colonna product_embedding
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") 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);
Ora, quando eseguiamo una query sulla riga appena inserita, vedremo che la colonna product_embedding viene aggiornata automaticamente.
SELECT uniq_id, (product_embedding::real[])[1:5] as product_embedding FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';
L'output dovrebbe essere simile al seguente:
quickstart_db=> SELECT uniq_id,(product_embedding::real[])[1:5] as product_embedding FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';
uniq_id | product_embedding
----------------------------------+---------------------------------------------------------------
fd604542e04b470f9e6348e640cff794 | {0.015003494,-0.005349732,-0.059790313,-0.0087091,-0.0271452}
(1 row)
Time: 3.295 ms
8. Crea un indice vettoriale
Per migliorare il rendimento della ricerca vettoriale, aggiungeremo un indice ScaNN.
Crea indice ScaNN
Per creare l'indice SCANN, dobbiamo abilitare un'altra estensione. L'estensione alloydb_scann fornisce un'interfaccia per lavorare con l'indice vettoriale di tipo ANN utilizzando l'algoritmo ScaNN di Google.
CREATE EXTENSION IF NOT EXISTS alloydb_scann;
Output previsto:
quickstart_db=> CREATE EXTENSION IF NOT EXISTS alloydb_scann; CREATE EXTENSION Time: 27.468 ms quickstart_db=>
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. Nel nostro caso non abbiamo righe sufficienti per creare l'indice in modalità AUTO, quindi lo creeremo come MANUALE e includeremo i parametri di ottimizzazione. Per informazioni sulla regolazione dei parametri di indice, consulta la documentazione.
CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products
USING scann (product_embedding cosine)
WITH (mode='MANUAL', num_leaves=31, max_num_levels = 2);
Output previsto:
quickstart_db=> CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products USING scann (product_embedding cosine) WITH (num_leaves=31, max_num_levels = 2); CREATE INDEX quickstart_db=>
Controllare l'utilizzo dell'indice
Ora possiamo eseguire la query di ricerca vettoriale in modalità EXPLAIN e verificare se l'indice viene utilizzato.
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.product_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=16.59..16.60 rows=1 width=32) (actual time=2.875..2.877 rows=1 loops=1) -> Subquery Scan on trees (cost=8.42..16.59 rows=1 width=142) (actual time=2.860..2.862 rows=1 loops=1) -> Limit (cost=8.42..16.58 rows=1 width=158) (actual time=2.855..2.856 rows=1 loops=1) -> Nested Loop (cost=8.42..6489.19 rows=794 width=158) (actual time=2.854..2.855 rows=1 loops=1) -> Nested Loop (cost=8.13..6466.99 rows=794 width=938) (actual time=2.742..2.743 rows=1 loops=1) -> Index Scan using cymbal_products_embeddings_scann on cymbal_products cp (cost=7.71..111.99 rows=876 width=934) (actual time=2.724..2.724 rows=1 loops=1) Order By: (embedding <=> '[0.008864171,0.03693164,-0.024245683,-0.00355923,0.0055611245,0.015985578,...<redacted>...5685,-0.03914233,-0.018452475,0.00826032,-0.07372604]'::vector) ...
Dall'output possiamo vedere chiaramente che la query utilizzava "Index Scan using cymbal_products_embeddings_scann on cymbal_products".
9. Creazione di un'istanza elastica
Elasticsearch è un marchio di Elastic NV e non è affiliato a Google LLC. Utilizzeremo Elasticsearch per la parte di ricerca a testo intero della ricerca ibrida. Se hai un'istanza Elasticsearch, puoi saltare i passaggi seguenti e creare una chiave API personale/utente di sola lettura che AlloyDB può utilizzare per accedere al tuo cluster Elasticsearch. In caso contrario, puoi avviare un'istanza Elasticsearch nella VM che hai creato in precedenza.
Accedi alla VM tramite SSH e installa Docker
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
"deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
"$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Ora puoi modificare il comando Docker da eseguire dall'utente
sudo usermod -aG docker $USER
newgrp docker
Nel terminale della VM, esegui questo comando per creare il container elastico:
curl -fsSL https://elastic.co/start-local | sh
Output previsto (modificato)
🎉 Congrats, Elasticsearch and Kibana are installed and running in Docker! 🌐 Open your browser at http://localhost:5601 Username: elastic Password: [password_value] 🔌 Elasticsearch API endpoint: http://localhost:9200 🔑 API key: [API Key] Learn more at https://github.com/elastic/start-local
Copia l'output e incollalo nel seguente file
nano elastic-last-run.txt
Ctrl + O, Invio, Ctrl + X per salvare ed uscire.
Per impostazione predefinita, il container docker è in ascolto su http://localhost:9200 e potrebbe avere difficoltà a ricevere la richiesta esterna da AlloyDB. Dobbiamo configurare docker-compose.yml in modo che ascolti su 9200:9200
Dopo aver eseguito lo script, dovrebbe essere creata una nuova directory elastic-start-local. Vai a questa directory e modifica il Dockerfile
cd elastic-start-local/
nano docker-compose.yml
Verso l'alto troverai
elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:${ES_LOCAL_VERSION}
container_name: ${ES_LOCAL_CONTAINER_NAME}
volumes:
- dev-elasticsearch:/usr/share/elasticsearch/data
ports:
- localhost:9200
Modifica il campo ports in modo che sia
ports:
- 9200:9200
Salva ed esci utilizzando Ctrl + O, Invio, Ctrl + X. Ora riavvia lo stack.
docker compose up -d
Ora, popoleremo l'istanza Elastic con le descrizioni e i nomi dei prodotti. Copia il file CSV dei prodotti da Cloud Storage alla VM.
gcloud storage cp gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv .
Output previsto:
gcloud storage cp gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv . Copying gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv to file://./cymbal_products.csv Completed files 1/1 | 1.4MiB/1.4MiB Average throughput: 147.9MiB/s
Ora crea uno script Python per estrarre il file CSV e formattare i dati in NDJSON per il caricamento collettivo.
nano convert.py
Nel file incolla quanto segue:
import csv
import json
# Configuration
input_file = 'cymbal_products.csv'
output_file = 'products.json'
index_name = 'elasticindexdemo'
def convert():
try:
with open(input_file, mode='r', encoding='utf-8') as f_in, \
open(output_file, mode='w', encoding='utf-8') as f_out:
reader = csv.DictReader(f_in)
count = 0
for row in reader:
metadata = {
"index": {
"_index": index_name,
"_id": row['uniq_id'].strip()
}
}
# 2. Data/Source line
document = {
"uniq_id": row['uniq_id'].strip(),
"product_name": row['product_name'].strip(),
"product_description": row['product_description'].strip()
}
# Write to file
f_out.write(json.dumps(metadata) + '\n')
f_out.write(json.dumps(document) + '\n')
count += 1
print(f"Success: Processed {count} products.")
print(f"Output saved to: {output_file}")
except Exception as e:
print(f"An error occurred: {e}")
if __name__ == "__main__":
convert()
Salva il file ed eseguilo.
python3 convert.py
Output previsto:
~$ python3 convert.py Success: Processed 941 products. Output saved to: products.json
Per il caricamento collettivo dei dati, dobbiamo recuperare la chiave API dal file di esecuzione precedente e utilizzarla per autorizzare l'accesso all'istanza. Viene quindi passato il file JSON creato in precedenza. Per gli scenari di produzione, è consigliabile definire l'indice e i tipi di dati in Elasticsearch. Poiché il set di dati in questo codelab è piccolo, lasciamo che Elasticsearch gestisca i dati. Innanzitutto, recupera la chiave API dal file e salvala in una variabile.
AUTH_HDR=$(grep "API key" elastic-last-run.txt | sed -e "s/^.*API key:[[:space:]]*/ApiKey /g")
Utilizzando la variabile che abbiamo salvato, esegui il seguente comando curl che carica i dati dal file JSON.
curl -s -X POST "localhost:9200/elasticindexdemo/_bulk?pretty" \
-H "Content-Type: application/x-ndjson" \
-H "Authorization: $AUTH_HDR" \
--data-binary "@products.json"
Output previsto:
~$ curl -s -X POST "localhost:9200/elasticindexdemo/_bulk?pretty" \
-H "Content-Type: application/x-ndjson" \
-H "Authorization: $AUTH_HDR" \
--data-binary "@products.json"
{
"errors" : false,
"took" : 1003,
"items" : [
{
"index" : {
"_index" : "elasticindexdemo",
"_id" : "a73d5f754f225ecb9fdc64232a57bc37",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1,
"status" : 201
}
},
...]
}
Done
Infine, dobbiamo recuperare la chiave API per l'istanza Elasticsearch in modo da poterla salvare per l'utilizzo da parte di AlloyDB. Esegui il comando seguente e copia il valore della chiave API
cat elastic-last-run.txt
Con la chiave API, dobbiamo creare un secret in Secret Manager. In Cloud Shell esegui il seguente comando con la tua chiave API
echo -n "[YOUR_API_KEY_VALUE]" | \
gcloud secrets create elasticsearch \
--replication-policy="automatic" \
--data-file=-
10. Creazione di un wrapper di dati esterni in AlloyDB
Durata 20:00
Per eseguire query sui dati archiviati in Elasticsearch da AlloyDB, dobbiamo creare un Foreign Data Wrapper (FDW) per Elastic e una tabella esterna. In precedenza, la chiave API Elastic veniva archiviata in Secret Manager. Per consentire ad AlloyDB di accedere al secret, concedi al service account l'autorizzazione richiesta.
In Cloud Shell, concedi al service account l'accesso al secret elasticsearch
gcloud secrets add-iam-policy-binding elasticsearch \
--member="serviceAccount:service-$(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/secretmanager.secretAccessor"
Output previsto:
gcloud secrets add-iam-policy-binding elasticsearch \
--member="serviceAccount:service-$(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/secretmanager.secretAccessor"
Updated IAM policy for secret [elasticsearch].
bindings:
- members:
- serviceAccount:service-257907437930@gcp-sa-alloydb.iam.gserviceaccount.com
role: roles/secretmanager.secretAccessor
etag: BwZOghJiP5U=
version: 1
Vai al cluster AlloyDB e apri AlloyDB Studio (puoi anche utilizzare psql per connetterti dalla VM). Accedi a quickstart_db come utente postgres.
Abilita l'estensione FDW
CREATE EXTENSION external_search_fdw;
Output previsto:
Statement executed successfully
Per raggiungere Elasticsearch, crea un server di dati esterno. L'indirizzo IP interno della VM si trova in Compute Engine > Istanze VM. Per il percorso del secret, vai a Secret Manager e seleziona il secret. Il percorso dovrebbe trovarsi in alto. Assicurati di includere /versions/latest per ottenere la versione più recente del segreto.
CREATE SERVER elastic_demo_server
FOREIGN DATA WRAPPER external_search_fdw
OPTIONS(
server 'http://[VM INTERNAL IP ADDRESS]:9200',
search_provider 'elastic',
auth_method 'ApiKey',
secret_path '[SECRET PATH]/versions/latest'
);
Poi definisci la tabella esterna. Dopo i metadati, fornisci la definizione dello schema dei campi Elasticsearch in modo che corrisponda ai dati caricati in precedenza. Nella tabella remota specifica il nome dell'indice Elastic.
CREATE FOREIGN TABLE elasticindexdemo (
metadata external_search_fdw_schema.OpaqueMetadata,
uniq_id TEXT,
product_name TEXT,
product_description TEXT
)
SERVER elastic_demo_server
OPTIONS(
remote_table_name 'elasticindexdemo'
);
Crea una mappatura utente per il server
CREATE USER MAPPING FOR CURRENT_USER SERVER elastic_demo_server;
Ora puoi testare la tabella esterna.
SELECT uniq_id, product_name
FROM elasticindexdemo
ORDER BY metadata <@> 'product_description:lamp' DESC
limit 10;
Output previsto:
"uniq_id","product_name" "59c05332f09426c23d8d005528e3c12e","CVL Mini Vintage Metal Lamp Shade: Black Metal with Punched Pattern" "c24dd78c0d570105256e1bf1cb2fea9d","Better Homes & Gardens Tapered Drum Shade, White Box Pleat" "7ba20db2bcfab28f88fc714d73af1eb8","4 Pack E27 Wireless Remote Control Light Lamp Bulb Holder Cap Socket Switch 30m" "0fad1469ea9dfa80b35cfe5266b8bfe7","Star Projector Lamp, 360 Degree Star Night Light Romantic Room Rotating Cosmos Star Projuctor With USB Cable, Light Lamp Starry Moon Sky Night Projector Kid Bedroom Lamp" "70b37e483ef3678078236d36954525ce","Lucille 10.5\""h Duck Egg Blue Empire Stitched Lamp Shade 7x10x8" "b7a4b9151598f4cae7707cbedabe3c1b","10x12x8\"" SLIP UNO FITTER Hardback Shallow Drum Lamp Shade Textured Slate" "5962cf47b88186eed76d14f6376882df","E27 To E14 Lampshade Lamp Light Shades Socket Reducing Ring Adapter Washer" "7c54fdebfe0b1dd3f649741b8928a95b","iMounTEK LED Projector Lamp Kids Night Light Star Moon Projection Night Lamp 360\u00b0 Rotation Timer for Children Bedroom" "4531201095c2653530747e215fcc1435","Home Concept Inc 11 Classics Brass Empire Lamp Shade" "350527adb4299a015bcce74dee97805e","6 Colors LED Star Projector Lamp 360 Degree Romantic Rotating Night Cosmos Star Sky Moon Projector Kids Sleep Night Light For Children Gift Bedroom Decor"
11. Utilizzare la ricerca ibrida
Durata 15:00
Ora che tutto è configurato, possiamo utilizzare la funzione ai.hybrid_search() per combinare la ricerca vettoriale e la ricerca full-text. Per saperne di più sulla ricerca ibrida, consulta la documentazione. Quando utilizzi la ricerca ibrida, per impostazione predefinita i risultati della query utilizzano l'algoritmo Reciprocal Rank Fusion per ordinare i risultati di ranking di più query. Innanzitutto, proviamo la ricerca vettoriale e la ricerca ibrida in modo indipendente per analizzare le loro differenze.
La seguente query esegue la ricerca vettoriale per trovare prodotti simili a ciliegia. L'array fornisce un elenco di ricerche da eseguire. In questo caso utilizziamo solo la ricerca vettoriale, ma in seguito forniremo sia la ricerca vettoriale che la ricerca full-text.
SELECT id, score, cymbal_products.product_name, cymbal_products.product_description
FROM ai.hybrid_search(
ARRAY[
'{
"data_type": "vector",
"table_name": "cymbal_products",
"key_column": "uniq_id",
"vec_column": "product_embedding",
"distance_operator": "public.<=>",
"limit": 3,
"query_vector": "ai.embedding(''text-embedding-005'', ''cherry'')::vector"
}'::JSONB
]
) JOIN cymbal_products ON id = cymbal_products.uniq_id;
Nell'output, il ciliegio è il primo risultato, ma nota che anche i due successivi sono alberi da frutto. Questo perché quando utilizziamo la ricerca vettoriale nella colonna product_description, troviamo corrispondenze semantiche alla nostra condizione di ricerca.
"id","score","product_name","product_description" "d536e9e823296a2eba198e52dd23e712","0.01639344262295082","Cherry Tree","This is a beautiful cherry tree that will produce delicious cherries. It is an deciduous tree that grows to be about 15 feet tall. The leaves are dark green in the summer and turn a beautiful red in the fall. Cherry trees are known for their beauty and their ability to provide shade and privacy. Cherry trees prefer a cool, moist climate and sandy soil. They are best suited for USDA zones 4-9." "b70c44b1a38c0a2329fa583c9109a80f","0.016129032258064516","Peach Tree","This is a beautiful peach tree that will produce delicious peaches. It is an evergreen tree that grows to be about 20 feet tall. The leaves are dark green in the summer and turn a beautiful yellow in the fall. Peach trees are known for their beauty and their ability to provide shade and privacy. Peach trees prefer a cool, moist climate and sandy soil. They are best suited for USDA zones 2-9." "23e41a71d63d8bbc9bdfa1d118cfddc5","0.015873015873015872","Apple Tree","This is a beautiful apple tree that will produce delicious apples. It is a deciduous tree that grows to be about 30 feet tall. The leaves are dark green in the summer and turn a beautiful red, orange, and yellow in the fall. Apple trees are known for their strength and durability. They are also a popular choice for shade trees. Apple trees prefer a cool, moist climate and loamy soil. They are best suited for USDA zones 4-8."
Per eseguire la ricerca full-text, esegui la seguente query
SELECT id, score, cymbal_products.product_name, cymbal_products.product_description
FROM ai.hybrid_search(
ARRAY[
'{
"limit": 3,
"data_type": "external_search_fdw",
"table_name": "elasticindexdemo",
"key_column": "uniq_id",
"query_text_input": "product_description:(cherry)"
}'::JSONB
]
) JOIN cymbal_products ON id = cymbal_products.uniq_id;
Nota nei risultati: poiché la ricerca a testo intero utilizza la corrispondenza esatta, i risultati restituiscono qualsiasi elemento che contenga la parola "ciliegia" nella descrizione del prodotto.
"id","score","product_name","product_description" "d536e9e823296a2eba198e52dd23e712","0.01639344262295082","Cherry Tree","This is a beautiful cherry tree that will produce delicious cherries. It is an deciduous tree that grows to be about 15 feet tall. The leaves are dark green in the summer and turn a beautiful red in the fall. Cherry trees are known for their beauty and their ability to provide shade and privacy. Cherry trees prefer a cool, moist climate and sandy soil. They are best suited for USDA zones 4-9." "390cf08feac229e7b752709fd1f943b3","0.016129032258064516","Woven Round Placemat, Set of Twelve, Grass","...These placemats are great for special occasions and holidays, but are also perfect to accessorize your everyday place settings.|Measurements. 15-inch round diameter is the perfect size for most table sizes and shapes.|Pop Colors. Choose from 7 pop woven color placemats including: Black, Cherry, Grass, Taupe, Navy, Sun and Graphite." "2c9aa7ac98c30abf78dd9c62a68a34e6","0.015873015873015872","48 Scented Wax Melts Wax Cubes: Jelly Belly Jelly Beans Candy Bulk Soy Wax Melts For Candle Warmer, Wax Warmers, Wax Melt Warmers In 8 Pack Set","...From These Flavors: Lemon Drop, Mixed Berry Smoothie, Sizzling Cinnamon, Crushed Pineapple, Juicy Pear, Cotton Candy, Toasted Marshmallow, French Vanilla, Watermelon, Red Apple, Very Cherry, Buttered Popcorn..."
Ora puoi combinare la ricerca semantica e la ricerca full-text per ottenere risultati più significativi. Supponiamo di voler cercare un albero che possa crescere più alto di una casa e che provenga dalla California. Abbiamo suddiviso la query per sfruttare l'intento semantico rispetto alla corrispondenza letterale. La ricerca vettoriale gestisce la parte descrittiva: "albero che può crescere più alto di una casa" perché comprende il concetto di altezza e scala senza bisogno di parole chiave esatte. Nel frattempo, la ricerca nel testo completo gestisce "California" come filtro rigoroso per garantire una corrispondenza geografica esatta anziché qualcosa di concettualmente simile.
SELECT id, score, cymbal_products.product_name, cymbal_products.product_description
FROM ai.hybrid_search(
ARRAY[
'{
"data_type": "vector",
"table_name": "cymbal_products",
"key_column": "uniq_id",
"vec_column": "product_embedding",
"distance_operator": "public.<=>",
"limit": 3,
"query_vector": "ai.embedding(''text-embedding-005'', ''tree that can grow taller than a house'')::vector"
}'::JSONB,
'{
"limit": 3,
"data_type": "external_search_fdw",
"table_name": "elasticindexdemo",
"key_column": "uniq_id",
"query_text_input": "product_description:(California)"
}'::JSONB
]
) JOIN cymbal_products ON id = cymbal_products.uniq_id;
Risultati previsti:
"id","score","product_name","product_description" "a589fd36a8a20fd9472d2403d6ed692a","0.00819672631147241","California Redwood","This is a beautiful redwood tree that can grow to be over 300 feet tall. It is an evergreen tree that grows in the coastal forests of California. Redwoods are known for their beauty and their strength. They are best suited for USDA zones 7-10." "ef9432802da24041594c2cf368dfb4d2","0.008064521129029258","Madrone","This is a beautiful madrona tree that can grow to be over 80 feet tall. It is an evergreen tree that grows in the coastal forests of California. Madronas are known for their beauty and their bark. They are best suited for USDA zones 7-10." "1360d8642bc218e4ea28e9c32b2e1721","0.007936512936504936","California Sycamore","This is a beautiful sycamore tree that can grow to be over 100 feet tall. It is an deciduous tree that grows in the valleys and foothills of California. California sycamores are known for their beauty and their shade. They are best suited for USDA zones 7-10."
12. 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 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-hybrid-search
export PROJECT_ID=$(gcloud config get-value project)
Elimina il cluster:
gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force
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:
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
13. Complimenti
Congratulazioni per aver completato il codelab.
Argomenti trattati
- Come eseguire il deployment del cluster e dell'istanza principale di AlloyDB
- Come connettersi ad AlloyDB da una VM Google Compute Engine
- Come creare un database e abilitare AlloyDB AI
- Come caricare i dati nel database
- Come utilizzare AlloyDB Studio
- Genera incorporamenti con Vertex AI
- Come creare un indice vettoriale ScaNN per migliorare la ricerca vettoriale
- Come creare un wrapper di dati esterni (FDW) per Elasticsearch
- Esegui la ricerca ibrida combinando la ricerca semantica in AlloyDB con la ricerca full-text in Elastic.
Passaggi successivi
Puoi esplorare altri codelab di AlloyDB sul sito ufficiale dei codelab.