1. Introducción
En este codelab, aprenderás a realizar búsquedas híbridas en AlloyDB con pgvector y un índice de vecino más cercano escalable (ScaNN), combinados con la capacidad de búsqueda de texto completo de Apache Solr a través de un wrapper de datos externos (FDW). Este lab forma parte de una colección de labs dedicados a las funciones de AlloyDB AI. Puedes obtener más información en la página de AlloyDB AI en la documentación.
Apache Solr es una plataforma de búsqueda empresarial de código abierto creada en Apache Lucene y diseñada para ofrecer una capacidad de búsqueda de texto completo rápida, escalable y de alta disponibilidad. La integración de Solr con AlloyDB a través de un wrapper de datos externos (FDW) permite a los usuarios consultar los índices de Solr directamente desde PostgreSQL junto con las tablas de bases de datos estructuradas. Para obtener más información, consulta la documentación de Apache Solr.
Requisitos previos
- Conocimientos básicos de Google Cloud Console
- Habilidades básicas de la interfaz de línea de comandos y de Google Shell
Qué aprenderás
- Cómo implementar un clúster y una instancia principal de AlloyDB
- Cómo conectarse a AlloyDB desde una VM de Google Compute Engine
- Cómo crear una base de datos y habilitar AlloyDB AI
- Cómo cargar datos en la base de datos
- Cómo usar AlloyDB Studio
- Genera incorporaciones con Vertex AI
- Cómo crear un índice de vectores de ScaNN para mejorar la búsqueda de vectores
- Cómo crear un wrapper de datos externos (FDW) para Apache Solr
- Realiza una búsqueda híbrida combinando la búsqueda semántica en AlloyDB con la búsqueda de texto completo en Solr.
Requisitos
- Una cuenta de Google Cloud y un proyecto de Google Cloud
- Un navegador web, como Chrome
2. Configuración y requisitos
Configuración del proyecto
Accede a la consola de Google Cloud. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
Usa una cuenta personal en lugar de una cuenta laboral o educativa.
- En la consola de Google Cloud, en la página del selector de proyectos, selecciona o crea un proyecto de Google Cloud.
- Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información para verificar si la facturación está habilitada en un proyecto.
Habilitar facturación
Para habilitar la facturación, tienes dos opciones. Puedes usar tu cuenta de facturación personal o canjear créditos siguiendo los pasos que se indican a continuación.
Configura una cuenta de facturación personal
Si configuraste la facturación con créditos de Google Cloud, puedes omitir este paso.
Para configurar una cuenta de facturación personal, ve aquí para habilitar la facturación en la consola de Cloud.
Algunas notas:
- Completar este lab debería costar menos de USD 3 en recursos de Cloud.
- Puedes seguir los pasos al final de este lab para borrar recursos y evitar cargos adicionales.
- Los usuarios nuevos pueden acceder a la prueba gratuita de USD 300.
Inicia Cloud Shell
Si bien Google Cloud se puede operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.
Cloud Shell es un entorno de línea de comandos que se ejecuta en Google Cloud y que viene precargado con las herramientas necesarias.
- Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.
- Una vez que te conectes a Cloud Shell, verifica tu autenticación:
gcloud auth list - Confirma que tu proyecto esté configurado:
gcloud config get project - Si tu proyecto no está configurado como se esperaba, configúralo:
export PROJECT_ID=<YOUR_PROJECT_ID> gcloud config set project $PROJECT_ID
Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.
3. Antes de comenzar
Habilita la API
Resultado:
Para usar AlloyDB, Compute Engine, servicios de redes y Vertex AI, debes habilitar sus respectivas APIs en tu proyecto de Google Cloud.
Habilita las API
En Cloud Shell, en la terminal, asegúrate de que tu ID del proyecto esté configurado:
gcloud config set project [YOUR-PROJECT-ID]
Configura la variable de entorno PROJECT_ID:
PROJECT_ID=$(gcloud config get-value project)
Habilita todas las APIs necesarias:
gcloud services enable alloydb.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com \
secretmanager.googleapis.com
Resultado esperado
student@cloudshell:~ (alloydb-hybrid-search)$ gcloud config set project alloydb-hybrid-search
[environment: untagged] Read more to tag: g.co/cloud/project-env-tag.
Updated property [core/project].
student@cloudshell:~ (alloydb-hybrid-search)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-32544]
student@cloudshell:~ (alloydb-hybrid-search)$ 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-350113473377-5ffc2f22-caa9-4857-b2f4-018657d8bf6e" finished successfully.
Presentamos las APIs
- La API de AlloyDB (
alloydb.googleapis.com) te permite crear, administrar y escalar clústeres de AlloyDB para PostgreSQL. Proporciona un servicio de base de datos completamente administrado y compatible con PostgreSQL diseñado para cargas de trabajo empresariales transaccionales y analíticas exigentes. - La API de Compute Engine (
compute.googleapis.com) te permite crear y administrar máquinas virtuales (VM), discos persistentes y parámetros de configuración de red. Proporciona la base de infraestructura como servicio (IaaS) principal necesaria para ejecutar tus cargas de trabajo y alojar la infraestructura subyacente de muchos servicios administrados. - La API de Cloud Resource Manager (
cloudresourcemanager.googleapis.com) te permite administrar de forma programática los metadatos y la configuración de tu proyecto de Google Cloud. Te permite organizar recursos, controlar políticas de Identity and Access Management (IAM) y validar permisos en toda la jerarquía del proyecto. - La API de Service Networking (
servicenetworking.googleapis.com) te permite automatizar la configuración de la conectividad privada entre tu red de nube privada virtual (VPC) y los servicios administrados de Google. Se requiere específicamente para establecer el acceso a la IP privada para servicios como AlloyDB, de modo que puedan comunicarse de forma segura con tus otros recursos. - La API de Vertex AI (
aiplatform.googleapis.com) permite que tus aplicaciones compilen, implementen y escalen modelos de aprendizaje automático. Proporciona la interfaz unificada para todos los servicios de IA de Google Cloud, incluido el acceso a modelos de IA generativa (como Gemini) y el entrenamiento de modelos personalizados. - La API de Secret Manager (
secretmanager.googleapis.com) es un servicio de administración de Secrets y credenciales que te permite almacenar y administrar datos sensibles, como claves de API, nombres de usuario, contraseñas, certificados y mucho más.
Opcionalmente, puedes configurar tu región predeterminada para usar los modelos de incorporación de Vertex AI. Obtén más información sobre las ubicaciones disponibles para Vertex AI. En el ejemplo, usamos la región us-central1.
gcloud config set compute/region us-central1
4. Implementa AlloyDB
Antes de crear un clúster de AlloyDB, necesitamos un rango de IP privada disponible en nuestra VPC para que lo utilice la instancia futura de AlloyDB. Si no lo tenemos, debemos crearlo, asignarlo para que lo usen los servicios internos de Google y, después de eso, podremos crear el clúster y la instancia.
Crea un rango de IP privada
Debemos establecer la configuración del acceso privado a servicios en nuestra VPC para AlloyDB. Aquí, suponemos que tenemos la red de VPC “predeterminada” en el proyecto y que se utilizará para todas las acciones.
Crea el rango de IP privada:
gcloud compute addresses create psa-range \
--global \
--purpose=VPC_PEERING \
--prefix-length=24 \
--description="VPC private service access" \
--network=default
Crea una conexión privada con el rango de IP asignado:
gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=psa-range \
--network=default
Una vez que se conecten, actualiza el intercambio de tráfico para exportar rutas personalizadas:
gcloud compute networks peerings update servicenetworking-googleapis-com \
--network=default \
--export-custom-routes
Resultado esperado en la consola:
student@cloudshell:~ (alloydb-hybrid-search)$ 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/alloydb-hybrid-search/global/addresses/psa-range].
student@cloudshell:~ (alloydb-hybrid-search)$ gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=psa-range \
--network=default
Operation "operations/pssn.p24-350113473377-fadad49e-7e14-472a-8888-26951e40a1f7" finished successfully.
student@cloudshell:~ (alloydb-hybrid-search)$ gcloud compute networks peerings update servicenetworking-googleapis-com \
--network=default \
--export-custom-routes
Updated [https://www.googleapis.com/compute/v1/projects/alloydb-hybrid-search/global/networks/default].
Crea un clúster de AlloyDB
En esta sección, crearemos un clúster de AlloyDB en la región us-central1.
Define la contraseña para el usuario de postgres. Puedes definir tu propia contraseña o usar una función aleatoria para generar una.
export PGPASSWORD=`openssl rand -hex 12`
Resultado esperado en la consola:
student@cloudshell:~ (alloydb-hybrid-search)$ export PGPASSWORD=`openssl rand -hex 12`
Toma nota de la contraseña de PostgreSQL para utilizarla más adelante.
echo $PGPASSWORD
Necesitarás esa contraseña en el futuro para conectarte a la instancia como usuario de postgres. Te sugiero que la copies en una ubicación segura (es decir, un administrador de contraseñas).
Resultado esperado en la consola:
student@cloudshell:~ (alloydb-hybrid-search)$ echo $PGPASSWORD <generated password>
Crea un clúster de AlloyDB
Define la región y el nombre del clúster de AlloyDB. Usaremos la región us-central1 y alloydb-hybrid-search como nombre del clúster:
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
Ejecuta el comando para crear el clúster:
gcloud alloydb clusters create $ADBCLUSTER \
--password=$PGPASSWORD \
--network=default \
--region=$REGION \
--database-version=POSTGRES_17
Resultado esperado en la consola:
student@cloudshell:~ (alloydb-hybrid-search)$ export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
student@cloudshell:~ (alloydb-hybrid-search)$ gcloud alloydb clusters create $ADBCLUSTER \
--password=$PGPASSWORD \
--network=default \
--region=$REGION \
--database-version=POSTGRES_17
Creating cluster...done.
Crea una instancia principal de AlloyDB para nuestro clúster en la misma sesión de Cloud Shell. Si te desconectas, deberás volver a definir las variables de entorno de la región y el nombre del clúster.
gcloud alloydb instances create $ADBCLUSTER-pr \
--instance-type=PRIMARY \
--cpu-count=2 \
--region=$REGION \
--cluster=$ADBCLUSTER
Resultado esperado en la consola:
admin_@cloudshell:~ (my-project-93954-gke)$ gcloud alloydb instances create $ADBCLUSTER-pr \
--instance-type=PRIMARY \
--cpu-count=2 \
--region=$REGION \
--availability-type ZONAL \
--cluster=$ADBCLUSTER
Operation ID: operation-1784244706986-656c2d7f3c8f2-59a9e52a-1e7b1b01
Creating instance...done.
5. Conectarte a AlloyDB
AlloyDB se implementa con una conexión solo privada, por lo que necesitamos una VM con el cliente de PostgreSQL instalado para trabajar con la base de datos. También usaremos esta VM para ejecutar una instancia de Apache Solr.
Implementa la VM de GCE
Crea una VM de GCE en la misma región y VPC que el clúster de AlloyDB. Asegúrate de que el disco de arranque sea lo suficientemente grande como para ejecutar Solr. Aquí especificamos un disco de arranque de 20 GB en la marca --create-disk.
En Cloud Shell, ejecuta el siguiente comando:
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
Resultado esperado en la consola:
student@cloudshell:~ (alloydb-hybrid-search)$ export ZONE=us-central1-a
gcloud compute instances create instance-1 \
--zone=$ZONE \
--network=default \
--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: X.X.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING
Instala el cliente de Postgres
Instala el software del cliente de PostgreSQL en la VM implementada
Conéctate a la VM:
gcloud compute ssh instance-1 --zone=us-central1-a
Resultado esperado en la consola:
admin_@cloudshell:~ (my-project-93954-gke)$ 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.
Instala el comando de ejecución de software dentro de la VM:
sudo apt-get update
sudo apt-get install --yes postgresql-client
Resultado esperado en la consola:
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... Setting up postgresql-client (15+248+deb12u1) ... Processing triggers for man-db (2.11.2-2) ... Processing triggers for libc-bin (2.36-9+deb12u14) ...
Conéctate a la instancia
Conéctate a la instancia principal desde la VM usando psql.
En la misma pestaña de Cloud Shell con la sesión de SSH abierta en tu VM instance-1
Usa el valor de la contraseña de AlloyDB (PGPASSWORD) que se indicó y el ID del clúster de AlloyDB para conectarte a AlloyDB desde la VM de 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"
Resultado esperado en la consola:
student@instance-1:~$ 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"
psql (15.18 (Debian 15.18-0+deb12u1), server 17.9)
WARNING: psql major version 15, server major version 17.
Some psql features might not work.
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off)
Type "help" for help.
postgres=>
Cierra la sesión de psql:
exit
6. Prepara la base de datos
Debemos crear una base de datos, habilitar la integración de Vertex AI, crear objetos de base de datos y, luego, importar los datos.
Otorga los permisos necesarios a AlloyDB
Agrega permisos de Vertex AI al agente de servicio de AlloyDB.
Abre otra pestaña de Cloud Shell con el signo "+" en la parte superior.
En la nueva pestaña de Cloud Shell, ejecuta lo siguiente:
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"
Resultado esperado en la consola:
admin_@cloudshell:~ (my-project-93954-gke)$ 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" Your active configuration is: [cloudshell-30137] Updated IAM policy for project [my-project-93954-gke]. bindings: - members: <redacted> version: 1
Cierra la pestaña haciendo clic en “X” o ejecutando el comando:
exit
Crea la base de datos
Crea una base de datos llamada quickstart.
En la sesión de la VM de GCE, ejecuta lo siguiente:
Crea la base de datos:
psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db"
Resultado esperado en la consola:
student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db" CREATE DATABASE
Habilita la integración de Vertex AI
Habilita la integración en Vertex AI y las extensiones pgvector en la base de datos.
En la VM de GCE, ejecuta lo siguiente:
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"
Resultado esperado en la consola:
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" NOTICE: extension "google_ml_integration" already exists, skipping CREATE EXTENSION CREATE EXTENSION
Importar datos
Descarga los datos preparados y, luego, impórtalos a la nueva base de datos.
En la VM de GCE, ejecuta lo siguiente:
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"
Resultado esperado en la consola:
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" 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" 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 COPY 941 COPY 263861 COPY 4654
A continuación, estableceremos las marcas de base de datos necesarias. Puedes usar la consola web y administrar marcas en la instancia principal, o bien usar el comando de gcloud de la siguiente manera:
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
Resultado esperado en la consola
student@cloudshell:~ (alloydb-hybrid-search)$ 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-30137] Operation ID: operation-1784245853151-656c31c44e12b-6084eb8b-d6611419
Habilitar las marcas de base de datos requiere que se reinicie la instancia y tardará unos minutos. Una vez que se complete, el estado de la instancia de AlloyDB indicará “Lista”.
7. Genera embeddings de vectores
Después de importar los datos, tenemos las siguientes tablas: cymbal_products, que almacena información sobre los productos; cymbal_inventory, que hace un seguimiento del stock de artículos en cada tienda; y cymbal_stores, que es una lista de tiendas. Para realizar una búsqueda semántica en nuestros productos, debemos generar embeddings de vectores de las descripciones de los productos con la función initialize_embeddings. Usaremos la integración de Vertex AI para calcular los datos de vectores según las descripciones de nuestros productos y agregarlos a la tabla. Puedes obtener más información sobre la tecnología utilizada en la documentación.
Para usar la integración, conéctate a la base de datos con AlloyDB Studio o con psql desde tu VM usando la IP de la instancia de AlloyDB y la contraseña de postgres:
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
Verifica la versión de la extensión google_ml_integration.
SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
La versión debe ser 1.5.2 o superior. Este es un ejemplo del resultado:
quickstart_db=> SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration'; extversion ------------ 1.5.9 (1 row)
La versión predeterminada debe ser la 1.5.2 o una posterior, pero, si tu instancia muestra una versión anterior, es probable que deba actualizarse. Verifica si se inhabilitó el mantenimiento para la instancia.
Instala la extensión de vectores y crea una columna nueva para almacenar embeddings en cymbal_products
CREATE EXTENSION IF NOT EXISTS vector;
ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768);
Resultado esperado en la consola:
quickstart_db=> CREATE EXTENSION IF NOT EXISTS vector; ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768); NOTICE: extension "vector" already exists, skipping CREATE EXTENSION ALTER TABLE
Usaremos la generación de incorporaciones por lotes para mejorar la eficiencia. Puedes obtener más información sobre las diferentes opciones y técnicas de generación de incorporaciones en la guía. Anteriormente, habilitamos la marca google_ml_integration.enable_faster_embedding_generation, que nos permite generar incorporaciones por lotes.
Por último, también queremos que los embeddings se actualicen a medida que se modifican los valores de las columnas, por lo que incluimos el argumento incremental_refresh_mode en la llamada a la función. Esto genera una sobrecarga en nuestra base de datos, pero es una compensación que hacemos para mantener automáticamente las incorporaciones sincronizadas con el contenido. Si deseas actualizar manualmente las incorporaciones, puedes encontrar las instrucciones en la documentación.
Ahora, para unir todo y generar embeddings, usamos la función initialize_embeddings y pasamos batch_size de 50 como sugerencia de lote y establecemos incremental_refresh_mode en 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'
);
Ahora, si insertamos una fila nueva en la tabla con el valor NULL para la columna 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);
Ahora, cuando consultemos la fila que acabamos de insertar, veremos que la columna product_embedding se actualiza automáticamente.
SELECT uniq_id, (product_embedding::real[])[1:5] as product_embedding FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';
El resultado debe verse de la siguiente manera:
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)
8. Crea un índice vectorial
Para mejorar el rendimiento de la búsqueda de vectores, agregaremos un índice ScaNN.
Crea un índice de ScaNN
Para compilar el índice de SCANN, debemos habilitar una extensión más. La extensión alloydb_scann proporciona una interfaz para trabajar con el índice de vectores de tipo ANN usando el algoritmo ScaNN de Google.
CREATE EXTENSION IF NOT EXISTS alloydb_scann;
Resultado esperado:
quickstart_db=> CREATE EXTENSION IF NOT EXISTS alloydb_scann; CREATE EXTENSION
El índice se puede crear en modo MANUAL o AUTO. El modo MANUAL está habilitado de forma predeterminada y puedes crear un índice y mantenerlo como cualquier otro índice. Sin embargo, si habilitas el modo AUTO, podrás crear el índice que no requiere mantenimiento de tu parte. Puedes leer en detalle sobre todas las opciones en la documentación. En nuestro caso, no tenemos suficientes filas para crear el índice en el modo AUTO, por lo que lo crearemos como MANUAL y, luego, incluiremos parámetros de ajuste. Puedes obtener información sobre el ajuste de los parámetros del índice en la documentación.
CREATE INDEX cymbal_products_embeddings_scann ON cymbal_products
USING scann (product_embedding cosine)
WITH (mode='MANUAL', num_leaves=31, max_num_levels = 2);
Resultado esperado:
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=>
Cómo inspeccionar el uso del índice
Ahora podemos ejecutar la consulta de búsqueda vectorial en el modo EXPLAIN y verificar si se está usando el índice.
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;
Resultado esperado (oculto para mayor claridad):
... 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) ...
En el resultado, se puede ver claramente que la consulta usó "Index Scan using cymbal_products_embeddings_scann on cymbal_products".
9. Crea una instancia de Solr
Usaremos Apache Solr para la parte de búsqueda en el texto completo (FTS) de la búsqueda híbrida. En este paso, implementarás una instancia de Solr independiente en la VM que creaste anteriormente.
Para proteger el acceso a Solr, habilitaremos la autenticación básica. Para ello, proporcionaremos un archivo de configuración security.json, lo activaremos y, luego, iniciaremos el contenedor de Docker de Solr.
Establece una conexión SSH a la VM e instala 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
Ahora puedes modificar el comando de Docker para que lo ejecute tu usuario:
sudo usermod -aG docker $USER
newgrp docker
Ahora, crea el archivo security.json para habilitar la autenticación básica con el nombre de usuario solr y la contraseña SolrRocks.
nano security.json
Pega el siguiente código JSON en el archivo:
{
"authentication": {
"blockUnknown": true,
"class": "solr.BasicAuthPlugin",
"credentials": {
"solr": "IV0EHq1OnNrj6gvRCwvFwTrZ1+z1oBbnQdiVC3otuq0= Ndd7LKvVBAaZIF0QAVi1ekCfAJXr1GGfLtRUXhgrF8c="
}
},
"authorization": {
"class": "solr.RuleBasedAuthorizationPlugin",
"permissions": [
{ "name": "security-edit", "role": "admin" }
],
"user-role": { "solr": "admin" }
}
}
Guarda y sal de nano (Ctrl + O, Intro, Ctrl + X).
Inicia el contenedor de Docker de Solr con docker run y activa el archivo security.json en el contenedor:
docker run -d -p 8983:8983 --name solr --user root -v "$(pwd)/security.json:/var/solr/data/security.json" solr:9 -c -force
Sigue estos pasos para verificar que el contenedor se esté ejecutando:
docker ps
Resultado esperado:
student@instance-1:~$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 90db3c73835e solr:9 "docker-entrypoint.s..." 7 seconds ago Up 3 seconds 0.0.0.0:8983->8983/tcp, [::]:8983->8983/tcp solr
Espera unos segundos para que se inicialice Solr y, luego, crea una colección nueva llamada solrindexdemo llamando a la API de Solr con tus credenciales de autenticación básica:
curl --user solr:SolrRocks -X POST "http://localhost:8983/solr/admin/collections?action=CREATE&name=solrindexdemo&numShards=1&replicationFactor=1"
Resultado esperado:
student@instance-1:~$ curl --user solr:SolrRocks -X POST "http://localhost:8983/solr/admin/collections?action=CREATE&name=solrindexdemo&numShards=1&replicationFactor=1"
{
"responseHeader":{
"status":0,
"QTime":3586
},
"success":{
"172.17.0.2:8983_solr":{
"responseHeader":{
"status":0,
"QTime":2405
},
"core":"solrindexdemo_shard1_replica_n1"
}
},
"warning":"Using _default configset. Data driven schema functionality is enabled by default, which is NOT RECOMMENDED for production use. To turn it off: curl http://{host:port}/solr/solrindexdemo/config -d '{\"set-user-property\": {\"update.autoCreateFields\":\"false\"}}'"
Ahora, completaremos la instancia de Solr con descripciones y nombres de productos. Copia el CSV de productos de Cloud Storage a la VM.
gcloud storage cp gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv .
Ahora, crea una secuencia de comandos de Python para extraer el archivo CSV y darle formato a los datos en una lista JSON para actualizar en forma masiva.
nano convert.py
Pega lo siguiente en el archivo:
import csv
import json
# Configuration
input_file = 'cymbal_products.csv'
output_file = 'products.json'
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)
products = []
for row in reader:
products.append({
"id": row['uniq_id'].strip(),
"product_name": row['product_name'].strip(),
"product_description": row['product_description'].strip()
})
json.dump(products, f_out, indent=2)
print(f"Success: Processed {len(products)} products.")
print(f"Output saved to: {output_file}")
except Exception as e:
print(f"An error occurred: {e}")
if __name__ == "__main__":
convert()
Guarda el archivo y ejecútalo:
python3 convert.py
Resultado esperado:
admin_gopalbhutada_altostrat_com@instance-1:~$ python3 convert.py Success: Processed 941 products. Output saved to: products.json
Ahora envía los datos JSON a Apache Solr con el controlador de actualización:
curl --user solr:SolrRocks -X POST -H 'Content-Type: application/json' \
'http://localhost:8983/solr/solrindexdemo/update?commit=true' \
--data-binary "@products.json"
Resultado esperado:
admin_gopalbhutada_altostrat_com@instance-1:~$ curl --user solr:SolrRocks -X POST -H 'Content-Type: application/json' \
'http://localhost:8983/solr/solrindexdemo/update?commit=true' \
--data-binary "@products.json"
{
"responseHeader":{
"rf":1,
"status":0,
"QTime":3220
}
}
Ahora, debemos crear un secreto en Secret Manager que almacene nuestras credenciales de Solr. Dado que AlloyDB se vincula a FDW de búsqueda externa con valores username:password codificados en base64 para la autenticación básica, primero obtendremos la cadena codificada en base64 para solr:SolrRocks:
echo -n "solr:SolrRocks" | base64
Resultado:
admin_gopalbhutada_altostrat_com@instance-1:~$ echo -n "solr:SolrRocks" | base64 c29scjpTb2xyUm9ja3M=
Crea un secreto en Google Secret Manager con esta credencial codificada en Base64. En Cloud Shell, ejecuta lo siguiente:
echo -n "c29scjpTb2xyUm9ja3M=" | \
gcloud secrets create solr-credentials \
--replication-policy="automatic" \
--data-file=-
10. Cómo crear un wrapper de datos externos en AlloyDB
Duración: 10:00
Para consultar los datos almacenados en Apache Solr desde AlloyDB, debemos crear un wrapper de datos externos (FDW) para Solr y una tabla externa. Anteriormente, almacenaste las credenciales de Solr en Secret Manager. Para que AlloyDB acceda al secreto, otorga a la cuenta de servicio el permiso requerido.
En Cloud Shell, otorga acceso a la cuenta de servicio al secreto solr-credentials:
gcloud secrets add-iam-policy-binding solr-credentials \
--member="serviceAccount:service-$(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/secretmanager.secretAccessor"
Resultado esperado:
admin_@cloudshell:~ (my-project-93954-gke)$ gcloud secrets add-iam-policy-binding solr-credentials \
--member="serviceAccount:service-$(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/secretmanager.secretAccessor"
Your active configuration is: [cloudshell-13031]
Updated IAM policy for secret [solr-credentials].
bindings:
- members:
- serviceAccount:service-350113473377@gcp-sa-alloydb.iam.gserviceaccount.com
role: roles/secretmanager.secretAccessor
etag: BwZWyKlkx6Q=
version: 1
Conéctate a la base de datos con AlloyDB Studio (o usa psql para conectarte desde la VM). Accede a quickstart_db como el usuario postgres.
Habilita la extensión FDW:
CREATE EXTENSION IF NOT EXISTS external_search_fdw;
Resultado esperado:
CREATE EXTENSION
Get Connection Parameters
Antes de configurar el servidor de datos externos en AlloyDB, necesitas la dirección IP interna de la VM (en la que se ejecuta Solr) y la ruta secreta.
Para imprimir la IP interna de la VM, ejecuta el siguiente comando en Cloud Shell:
gcloud compute instances describe instance-1 \
--zone=us-central1-a \
--format="value(networkInterfaces[0].networkIP)"
Resultado esperado:
10.X.X.X
Para imprimir la ruta de acceso al recurso secreto en Secret Manager, ejecuta el siguiente comando:
gcloud secrets describe solr-credentials --format="value(name)"
Resultado esperado:
projects/<project_id>/secrets/solr-credentials
Para acceder a Apache Solr, crea un servidor de datos externo. Reemplaza /versions/latest a la ruta de acceso secreta para obtener la versión más reciente del secreto:
CREATE SERVER solr_demo_server
FOREIGN DATA WRAPPER external_search_fdw
OPTIONS(
server 'http://<VM_INTERNAL_IP_ADDRESS>:8983',
search_provider 'solr',
auth_mode 'secret_manager',
auth_method 'Basic',
secret_path '<SECRET_PATH>/versions/latest'
);
Resultado esperado:
CREATE SERVER
A continuación, define la tabla externa. Después de los metadatos, proporciona la definición del esquema de campo de Solr para que coincida con los datos cargados anteriormente. En la tabla remota, especifica el nombre de la colección de Solr.
CREATE FOREIGN TABLE solrindexdemo (
metadata external_search_fdw_schema.OpaqueMetadata,
id TEXT,
product_name TEXT,
product_description TEXT
)
SERVER solr_demo_server
OPTIONS(
remote_table_name 'solrindexdemo'
);
Crea una asignación de usuarios para el servidor:
CREATE USER MAPPING FOR CURRENT_USER SERVER solr_demo_server;
Ahora puedes probar la tabla externa:
SELECT id, product_name
FROM solrindexdemo
ORDER BY metadata <@> 'product_description:cherry' DESC
limit 10;
Resultado esperado:
"id","product_name" "d536e9e823296a2eba198e52dd23e712","Cherry Tree" "390cf08feac229e7b752709fd1f943b3","Woven Round Placemat, Set of Twelve, Grass" "2c9aa7ac98c30abf78dd9c62a68a34e6","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"
11. Cómo usar la búsqueda híbrida
Duración: 10:00
Ahora que todo está configurado, podemos usar la función ai.hybrid_search() para combinar la búsqueda de vectores y la búsqueda de texto completo. Puedes obtener más información sobre la búsqueda híbrida en la documentación. Cuando se usa la búsqueda híbrida, de forma predeterminada, los resultados de la búsqueda utilizan el algoritmo de fusión de clasificación recíproca para ordenar los resultados de clasificación de varias búsquedas. Primero, probemos la búsqueda vectorial y la búsqueda híbrida de forma independiente para analizar sus diferencias.
La siguiente consulta realiza una búsqueda de vectores para encontrar productos similares a la cereza. El array proporciona una lista de búsquedas que se deben realizar. En este caso, solo usamos la búsqueda vectorial, pero, más adelante, proporcionaremos la búsqueda vectorial y la FTS.
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;
En el resultado, el cerezo es el primer resultado, pero observa que los dos siguientes también son árboles frutales. Esto se debe a que, cuando usamos la búsqueda de vectores en la columna product_description, encontramos coincidencias semánticas con nuestra condición de búsqueda.
"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."
Para realizar una búsqueda en el texto completo con el FDW de Apache Solr, ejecuta la siguiente consulta:
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": "solrindexdemo",
"key_column": "id",
"query_text_input": "product_description:cherry"
}'::JSONB
]
) JOIN cymbal_products ON id = cymbal_products.uniq_id;
Observa en los resultados que, como la búsqueda de texto completo usa la coincidencia de tokens, los resultados muestran todo lo que contiene la palabra "cereza" en la descripción del producto.
"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..."
Ahora puedes combinar la búsqueda semántica y la FTS para obtener resultados más significativos. Supongamos que queremos buscar un árbol que pueda crecer más que una casa y que sea de California. Dividimos la búsqueda para aprovechar la intención semántica en lugar de la coincidencia literal. La búsqueda vectorial se encarga de la parte descriptiva: "árbol que puede crecer más que una casa", ya que comprende el concepto de escala sin necesidad de palabras clave exactas. Mientras tanto, la búsqueda de texto completo maneja "California" como un filtro estricto para garantizar que obtengamos una concordancia geográfica exacta en lugar de solo algo conceptualmente similar.
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": "solrindexdemo",
"key_column": "id",
"query_text_input": "product_description:California"
}'::JSONB
]
) JOIN cymbal_products ON id = cymbal_products.uniq_id;
Resultados esperados:
"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. Limpia el entorno
Cuando termines el lab, destruye las instancias y el clúster de AlloyDB.
Borra el clúster de AlloyDB y todas las instancias
Si usaste la versión de prueba de AlloyDB No borres el clúster de prueba si planeas probar otros labs y recursos con él. No podrás crear otro clúster de prueba en el mismo proyecto.
El clúster se destruye con la opción force que también borra todas las instancias que pertenecen al clúster.
En Cloud Shell, define el proyecto y las variables de entorno si te desconectaste y se perdieron todos los parámetros de configuración anteriores:
gcloud config set project <your project id>
export REGION=us-central1
export ADBCLUSTER=alloydb-hybrid-search
export PROJECT_ID=$(gcloud config get-value project)
Borra el clúster:
gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force
Resultado esperado en la consola:
admin_@cloudshell:~ (my-project-93954-gke)$ 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-1784270790060-656c8ea9fea06-1b93001f-846543e0 Deleting cluster...done.
Borra las copias de seguridad de AlloyDB
Borra todas las copias de seguridad de AlloyDB del clúster:
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
Resultado esperado en la consola:
admin_@cloudshell:~ (my-project-93954-gke)$ 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-1784271231983-656c904f71e05-1389a145-f101ceee Deleting backup...done.
Ahora podemos destruir nuestra VM
Borra la VM de GCE
En Cloud Shell, ejecuta el siguiente comando:
export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
--zone=$ZONE \
--quiet
Resultado esperado en la consola:
admin_@cloudshell:~ (my-project-93954-gke)$ export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
--zone=$ZONE \
--quiet
Deleted
13. Felicitaciones
¡Felicitaciones por completar el codelab!
Temas abordados
- Cómo implementar un clúster y una instancia principal de AlloyDB
- Cómo conectarse a AlloyDB desde una VM de Google Compute Engine
- Cómo crear una base de datos y habilitar AlloyDB AI
- Cómo cargar datos en la base de datos
- Cómo usar AlloyDB Studio
- Genera incorporaciones con Vertex AI
- Cómo crear un índice de vectores de ScaNN para mejorar la búsqueda de vectores
- Cómo crear un wrapper de datos externos (FDW) para Apache Solr
- Realiza una búsqueda híbrida combinando la búsqueda semántica en AlloyDB con la búsqueda de texto completo en Solr.
Próximos pasos
Puedes explorar más codelabs de AlloyDB en el sitio oficial de codelabs.postgresql).