Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

AlloyDB Omni y EmbeddingGemma con Gemma 4 en Kubernetes

1. Introducción

En este codelab, aprenderás a implementar AlloyDB Omni en Google Kubernetes Engine (GKE) y a usarlo con modelos abiertos, como EmbeddingGemma y Gemma 4, para generar embeddings y predicciones. Ejecutar la base de datos y los modelos en el mismo clúster reduce la latencia de red y evita las dependencias de servicios de terceros. También ayuda a satisfacer los requisitos de cumplimiento y residencia de datos, ya que tus datos nunca salen de tu entorno.

Diagrama de arquitectura de AlloyDB Omni y EmbeddingGemma en GKE

Requisitos previos

Conocimientos básicos de Google Cloud y la consola de Google Cloud
Conocimientos básicos de Kubernetes y GKE
Conocimiento de la interfaz de línea de comandos y de Google Cloud Shell

Qué aprenderás

Cómo implementar AlloyDB Omni en un clúster de GKE
Cómo conectarse a AlloyDB Omni
Cómo cargar datos en AlloyDB Omni
Cómo implementar modelos de IA (embedding y LLM) en GKE
Cómo registrar modelos de IA en AlloyDB Omni
Cómo generar incorporaciones para la búsqueda semántica
Cómo ejecutar consultas de búsqueda semántica en AlloyDB Omni
Cómo crear y usar índices de vectores en AlloyDB Omni

Requisitos

Una cuenta y un proyecto de Google Cloud
Un navegador web, como Chrome

2. Configuración y requisitos

Configura el proyecto

Accede a la consola de Google Cloud. Si aún no tienes una cuenta de Gmail o de Google Workspace, crea una. Usa una cuenta personal en lugar de una cuenta laboral o educativa.

Crea un proyecto nuevo o selecciona uno existente. En el encabezado de la consola de Google Cloud, haz clic en Seleccionar un proyecto y, luego, en Proyecto nuevo.

Cuadro de diálogo para seleccionar un proyecto en la consola de Google Cloud

En la ventana Selecciona un proyecto, haz clic en Proyecto nuevo para abrir el diálogo de creación de proyectos.

Diálogo de creación de proyecto nuevo

En el diálogo, ingresa un Nombre del proyecto y selecciona tu organización o ubicación.

Campos de entrada de detalles del proyecto

El Nombre del proyecto es el nombre visible de los participantes de este proyecto. El nombre del proyecto no se usa en las APIs de Google y puedes cambiarlo en cualquier momento.
El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Google Cloud genera automáticamente un ID único, pero también puedes proporcionar el tuyo. En este codelab, harás referencia al ID del proyecto con el marcador de posición .
El número de proyecto es un tercer identificador que usan algunas APIs. Para obtener más información, consulta la documentación de Resource Manager.

Habilita la facturación

Si configuraste la facturación con créditos de Google Cloud, puedes omitir este paso.

Para configurar una cuenta de facturación personal, habilita la facturación en la consola de Google Cloud.

Completar este lab cuesta menos de USD 5 en recursos de Google Cloud.
Sigue los pasos de limpieza al final de este lab para borrar los recursos y evitar cargos adicionales.
Los usuarios nuevos pueden acceder a la prueba gratuita de USD 300.

Inicie Cloud Shell

En este codelab, usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En la consola de Google Cloud, haz clic en el ícono de Activar Cloud Shell en la barra de herramientas de la parte superior derecha:

Botón Activar Cloud Shell

Como alternativa, presiona G y, luego, S, o bien abre Google Cloud Shell directamente.

Cuando se conecte, Cloud Shell mostrará el símbolo del sistema de la terminal:

Captura de pantalla de la terminal de Google Cloud Shell

Cloud Shell incluye almacenamiento persistente y herramientas de desarrollo. Puedes ejecutar todos los pasos de este codelab desde tu navegador.

3. Habilita las APIs

Para usar Google Kubernetes Engine (GKE) para las implementaciones de AlloyDB Omni y modelos, habilita las APIs de Compute Engine y GKE en tu proyecto de Google Cloud.

En Cloud Shell, verifica que tu ID del proyecto esté configurado:

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

Si no se definió el ID del proyecto, configúralo:

export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

Habilita las APIs necesarias:

gcloud services enable compute.googleapis.com
gcloud services enable container.googleapis.com

Resultado esperado:

student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=test-project-001-402417
student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable compute.googleapis.com
gcloud services enable container.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.

Puedes leer sobre cada API habilitada en la documentación.

4. Implementa AlloyDB Omni en GKE

Para implementar AlloyDB Omni en GKE, prepara un clúster de Kubernetes según los requisitos del operador de AlloyDB Omni.

Crea un clúster de GKE

Implementa un clúster de GKE estándar con capacidad para ejecutar AlloyDB Omni, el operador y los contenedores de supervisión. AlloyDB Omni requiere al menos dos CPU y 8 GB de RAM. En este instructivo, se usa el tipo de máquina n2-standard-4.

Configura las variables de entorno para tu implementación:

export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
export MACHINE_TYPE=n2-standard-4

Crea el clúster de GKE estándar:

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${LOCATION} \
  --workload-pool=${PROJECT_ID}.svc.id.goog \
  --release-channel=rapid \
  --machine-type=${MACHINE_TYPE} \
  --num-nodes=1

Resultado esperado en la consola:

student@cloudshell:~ (test-project-001-402417)$ export PROJECT_ID=$(gcloud config get project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
export MACHINE_TYPE=n2-standard-4
Your active configuration is: [test-project-001-402417]
student@cloudshell:~ (test-project-001-402417)$ gcloud container clusters create ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${LOCATION} \
  --workload-pool=${PROJECT_ID}.svc.id.goog \
  --release-channel=rapid \
  --machine-type=${MACHINE_TYPE} \
  --num-nodes=1
Note: Your Pod address range (`--cluster-ipv4-cidr`) can accommodate at most 1008 node(s).
Creating cluster alloydb-ai-gke in us-central1... Cluster is being health-checked (Kubernetes Control Plane is healthy)...done.                                                                                            
Created [https://container.googleapis.com/v1/projects/test-project-001-402417/zones/us-central1/clusters/alloydb-ai-gke].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1/alloydb-ai-gke?project=test-project-001-402417
kubeconfig entry generated for alloydb-ai-gke.
NAME: alloydb-ai-gke
LOCATION: us-central1
MASTER_VERSION: 1.36.3-gke.1640000
MASTER_IP: 34.121.243.65
MACHINE_TYPE: n2-standard-4
NODE_VERSION: 1.36.3-gke.1640000
NUM_NODES: 3
STATUS: RUNNING
STACK_TYPE: IPV4

Prepara el clúster

Instala los componentes necesarios, como cert-manager, el controlador de certificados nativo para Kubernetes. Para obtener más información, consulta la documentación de instalación de cert-manager.

Cloud Shell incluye la herramienta de línea de comandos de Kubernetes kubectl. Obtén credenciales del clúster con gcloud:

gcloud container clusters get-credentials ${CLUSTER_NAME} --region=${LOCATION}

Instala cert-manager mediante kubectl:

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.21.1/cert-manager.yaml

Resultado esperado en la consola (oculto):

student@cloudshell:~$ kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.21.1/cert-manager.yaml
namespace/cert-manager created
customresourcedefinition.apiextensions.k8s.io/certificaterequests.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/certificates.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/challenges.acme.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/clusterissuers.cert-manager.io created
...
validatingwebhookconfiguration.admissionregistration.k8s.io/cert-manager-webhook created

Instala el operador de AlloyDB Omni

Instala el operador de AlloyDB Omni con Helm.

Descarga e instala el gráfico del operador de AlloyDB Omni:

helm install alloydbomni-operator oci://gcr.io/alloydb-omni/alloydbomni-operator \
--version 1.8.1 \
--create-namespace \
--namespace alloydb-omni-system \
--atomic \
--timeout 5m

Resultado esperado en la consola (oculto):

student@cloudshell:~$ helm install alloydbomni-operator oci://gcr.io/alloydb-omni/alloydbomni-operator \
> --version 1.8.0 \
> --create-namespace \
> --namespace alloydb-omni-system \
> --atomic \
> --timeout 5m
Flag --atomic has been deprecated, use --rollback-on-failure instead
Pulled: gcr.io/alloydb-omni/alloydbomni-operator:1.8.0
Digest: sha256:f2d98fa7a3b08dfc1e83b811582718b94e5c017b81aade700c83e917c59f0395
NAME: alloydbomni-operator
LAST DEPLOYED: Thu Aug 27 17:57:30 2026
NAMESPACE: alloydb-omni-system
STATUS: deployed
REVISION: 1
DESCRIPTION: Install complete
TEST SUITE: None

Implementa el clúster de base de datos.

El siguiente manifiesto configura un clúster de base de datos con googleMLExtension habilitado y un balanceador de cargas interno:

cat << 'EOF' > my-omni.yaml
apiVersion: v1
kind: Secret
metadata:
  name: db-pw-my-omni
type: Opaque
data:
  my-omni: "VmVyeVN0cm9uZ1Bhc3N3b3Jk"
---
apiVersion: alloydbomni.dbadmin.goog/v1
kind: DBCluster
metadata:
  name: my-omni
spec:
  databaseVersion: "18.3.0"
  primarySpec:
    adminUser:
      passwordRef:
        name: db-pw-my-omni
    features:
      googleMLExtension:
        enabled: true
    resources:
      cpu: 1
      memory: 8Gi
      disks:
      - name: DataDisk
        size: 20Gi
        storageClass: standard
    dbLoadBalancerOptions:
      annotations:
        networking.gke.io/load-balancer-type: "internal"
  allowExternalIncomingTraffic: true
EOF

El valor secreto de la contraseña es la representación en Base64 de VeryStrongPassword. En los entornos de producción, usa Google Secret Manager para administrar las contraseñas. Para obtener más detalles, consulta la documentación de Secret Manager.

El manifiesto se guarda como my-omni.yaml. En Cloud Shell, haz clic en Abrir editor en la esquina superior derecha de la ventana de la terminal y lee el archivo.

Abre el editor en Cloud Shell

Después de leer el manifiesto de my-omni.yaml, haz clic en Abrir terminal para volver al símbolo del sistema.

Abre la terminal en Cloud Shell

Aplica el manifiesto my-omni.yaml:

kubectl apply -f my-omni.yaml

Resultado esperado en la consola:

secret/db-pw-my-omni created
dbcluster.alloydbomni.dbadmin.goog/my-omni created

Verifica el estado del clúster my-omni:

kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default

Durante la implementación, el clúster de base de datos pasa por fases de configuración hasta alcanzar el estado DBClusterReady.

Resultado esperado en la consola:

$ kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default
NAME      PRIMARYENDPOINT   PRIMARYPHASE   DBCLUSTERPHASE   HAREADYSTATUS   HAREADYREASON
my-omni   10.131.0.33        Ready          DBClusterReady

De manera opcional, puedes supervisar la implementación del clúster con el comando kubectl log:

kubectl logs -l alloydbomni.internal.dbadmin.goog/dbcluster=my-omni --all-containers -f

Conéctate a AlloyDB Omni

Cuando el clúster esté listo, conéctate al pod de la base de datos con el cliente de PostgreSQL (psql). La contraseña es VeryStrongPassword, como se define en my-omni.yaml:

DB_CLUSTER_NAME=my-omni
DB_CLUSTER_NAMESPACE=default
DBPOD=`kubectl get pod --selector=alloydbomni.internal.dbadmin.goog/dbcluster=$DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n $DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}'`
kubectl exec -ti $DBPOD -n $DB_CLUSTER_NAMESPACE -c database -- psql -h localhost -U postgres

Resultado de muestra de la consola:

DB_CLUSTER_NAME=my-omni
DB_CLUSTER_NAMESPACE=default
DBPOD=`kubectl get pod --selector=alloydbomni.internal.dbadmin.goog/dbcluster=$DB_CLUSTER_NAME,alloydbomni.internal.dbadmin.goog/task-type=database -n $DB_CLUSTER_NAMESPACE -o jsonpath='{.items[0].metadata.name}'`
kubectl exec -ti $DBPOD -n $DB_CLUSTER_NAMESPACE -c database -- psql -h localhost -U postgres
Password for user postgres:
psql (18.3)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_128_GCM_SHA256, compression: off, ALPN: postgresql)
Type "help" for help.

postgres=#

Para salir de la sesión de psql, escribe \q y presiona Intro:

postgres=# \q

5. Implementa el modelo EmbeddingGemma en GKE

Para probar la integración de la IA de AlloyDB Omni con modelos locales, implementa un modelo de embedding en el clúster de GKE. En este instructivo, se usa el modelo EmbeddingGemma de Google.

Crea un grupo de nodos para el modelo

Para ejecutar la inferencia del modelo, prepara un grupo de nodos dedicado. Puedes usar un grupo de nodos solo para CPU o un grupo de nodos acelerado por GPU (como g2-standard-8 con una GPU NVIDIA L4). En este instructivo, se usa un grupo de nodos basado en CPU con tipos de máquinas c3-standard-8.

Crea un grupo de nodos de CPU de un solo nodo:

export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
gcloud container node-pools create cpupool \
  --project=${PROJECT_ID} \
  --location=${LOCATION} \
  --node-locations=${LOCATION}-a \
  --cluster=${CLUSTER_NAME} \
  --machine-type=c3-standard-8 \
  --num-nodes=1

Resultado esperado:

student@cloudshell$ export PROJECT_ID=$(gcloud config get project)
Your active configuration is: [pant]
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
student@cloudshell$ gcloud container node-pools create cpupool \
>   --project=${PROJECT_ID} \
>   --location=${LOCATION} \
>   --node-locations=${LOCATION}-a \
>   --cluster=${CLUSTER_NAME} \
>   --machine-type=c3-standard-8 \
>   --num-nodes=1
Creating node pool cpupool...done.
Created [https://container.googleapis.com/v1/projects/gleb-test-short-003-483115/zones/us-central1/clusters/alloydb-ai-gke/nodePools/cpupool].
NAME     MACHINE_TYPE    DISK_SIZE_GB  NODE_VERSION
cpupool  c3-standard-8  100           1.34.1-gke.3355002

Obtén un token de Hugging Face

En este instructivo, se implementa el modelo EmbeddingGemma de Hugging Face. Para acceder a los pesos del modelo, genera un token de acceso de Hugging Face:

Accede a tu cuenta de Hugging Face o crea una.
Ve a Tu perfil > Tokens de acceso.
Haz clic en Crear token nuevo.
Ingresa un nombre para el token y selecciona el rol Lectura.
Haz clic en Crear token y copia el valor del token generado.
Acepta las condiciones del modelo en la página del modelo EmbeddingGemma si aún no lo hiciste.

Crea un Secret de Kubernetes que contenga tu token de Hugging Face en Cloud Shell (reemplaza el marcador de posición del token por tu token):

export HF_TOKEN=<YOUR_HUGGING_FACE_TOKEN>

kubectl create secret generic hf-secret \
  --from-literal=hf_api_token=$HF_TOKEN \
  --dry-run=client -o yaml | kubectl apply -f -

Prepara el manifiesto de implementación

Para implementar el modelo, usa el paquete de contenedor de inferencia de embeddings de texto (TEI) de Hugging Face. Para obtener más información, consulta la documentación de Hugging Face GKE TEI.

Clona el repositorio de implementación desde GitHub:

git clone https://github.com/huggingface/Google-Cloud-Containers

Inspecciona y modifica el manifiesto de configuración de la CPU:

edit Google-Cloud-Containers/examples/gke/tei-deployment/cpu-config/deployment.yaml

Manifiesto actualizado para la implementación de CPU:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tei-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: tei-server
  template:
    metadata:
      labels:
        app: tei-server
        hf.co/model: Google--embeddinggemma-300m
        hf.co/task: text-embeddings
    spec:
      containers:
        - name: tei-container
          image: ghcr.io/huggingface/text-embeddings-inference:cpu-latest
          resources:
            requests:
              cpu: "6"
              memory: "24Gi"
            limits:
              cpu: "6"
              memory: "24Gi"
          env:
            - name: MODEL_ID
              value: google/embeddinggemma-300m
            - name: NUM_SHARD
              value: "1"
            - name: PORT
              value: "8080"
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
          volumeMounts:
            - mountPath: /tmp
              name: tmp
      volumes:
        - name: tmp
          emptyDir: {}
      nodeSelector:
        cloud.google.com/machine-family: "c3"

Para guardar los cambios, presiona ctrl+s y vuelve a la terminal.

Implementa el modelo

Aplica el manifiesto para implementar el servidor de TEI:

kubectl apply -f Google-Cloud-Containers/examples/gke/tei-deployment/cpu-config

Supervisa la implementación hasta que esté en estado listo:

printf "Waiting for model to load..."; until kubectl logs -l app=tei-server --tail=50 2>/dev/null | grep -q "Ready"; do printf "."; sleep 3; done; printf '\n\033[1;32m========================================\n[SUCCESS] Model is loaded and ready!\nYou can now proceed to the next step.\n========================================\033[0m\n'

Verifica el servicio de Kubernetes tei-service:

kubectl get service tei-service

Resultado esperado:

student@cloudshell$ kubectl get service tei-service
NAME          TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
tei-service   ClusterIP   34.118.233.48   <none>        8080/TCP   10m

El servicio CLUSTER-IP procesa solicitudes de forma interna en http://34.118.233.48:8080/embed.

Prueba el extremo del modelo de forma local con kubectl port-forward:

kubectl port-forward service/tei-service 8080:8080

Haz clic en + en la parte superior de la terminal para abrir una segunda pestaña de Cloud Shell:

Agregar pestaña de Cloud Shell

En la pestaña nueva, prueba la generación de embeddings con curl:

curl http://localhost:8080/embed \
  -X POST \
  -d '{"inputs":"Test"}' \
  -H 'Content-Type: application/json'

Resultado esperado (matriz de vectores):

curl http://localhost:8080/embed \
>     -X POST \
>     -d '{"inputs":"Test"}' \
>     -H 'Content-Type: application/json'
[[-0.018975832,0.0071419072,0.06347208,0.022992613,0.014205903
...
-0.03677433,0.01636146,0.06731572]]

Presiona ctrl+c para detener el reenvío de puertos en la primera pestaña.

6. Registra el modelo de embedding en AlloyDB Omni

Para usar el modelo implementado desde AlloyDB Omni, crea una base de datos, define funciones de transformación y registra el extremo del modelo.

Crea una VM de cliente y una base de datos

Crea una instancia de VM de Compute Engine en la misma VPC para que actúe como host de salto del cliente:

Diagrama de arquitectura de red que muestra la VM del cliente y AlloyDB Omni

En Cloud Shell, crea la VM cliente:

export ZONE=us-central1-a
gcloud compute instances create instance-1 \
  --zone=$ZONE

Recupera la IP del extremo de AlloyDB Omni:

echo "INSTANCE_IP=$(kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default -o jsonpath='{.status.primary.endpoint}')"

Resultado esperado:

INSTANCE_IP=10.128.0.33

El valor de INSTANCE_IP es la IP del balanceador de cargas interno para el clúster de AlloyDB Omni. En este ejemplo, es 10.131.0.33.

Conéctate a la instancia de VM mediante SSH:

gcloud compute ssh instance-1 --zone=$ZONE

En la sesión SSH en instance-1, instala el cliente de PostgreSQL:

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

Exporta la IP del balanceador de cargas de AlloyDB Omni (reemplaza PRIMARYENDPOINT por tu IP):

export INSTANCE_IP=10.131.0.33

Conéctate a AlloyDB Omni con psql (la contraseña es VeryStrongPassword):

psql "host=$INSTANCE_IP user=postgres sslmode=require"

En la sesión psql, crea la base de datos demo:

CREATE DATABASE demo;

Cambia a la base de datos demo:

\c demo

Crea funciones de transformación

Los extremos de incorporación personalizados requieren funciones de transformación de entrada y salida para adaptar los formatos de datos entre AlloyDB Omni y la API del modelo.

Crea la función de transformación de entrada:

CREATE OR REPLACE FUNCTION tei_text_input_transform(model_id VARCHAR(100), input_text TEXT)
RETURNS JSON
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_input JSON;
BEGIN
  SELECT json_build_object('inputs', input_text, 'truncate', true)::JSON INTO transformed_input;
  RETURN transformed_input;
END;
$$;

Resultado esperado:

demo=# CREATE OR REPLACE FUNCTION tei_text_input_transform(model_id VARCHAR(100), input_text TEXT)
RETURNS JSON
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_input JSON;
BEGIN
  SELECT json_build_object('inputs', input_text, 'truncate', true)::JSON INTO transformed_input;
  RETURN transformed_input;
END;
$$;
CREATE FUNCTION
demo=#

Crea la función de transformación de salida para analizar la respuesta del array de vectores:

CREATE OR REPLACE FUNCTION tei_text_output_transform(model_id VARCHAR(100), response_json JSON)
RETURNS REAL[]
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_output REAL[];
BEGIN
  SELECT ARRAY(SELECT json_array_elements_text(response_json->0)) INTO transformed_output;
  RETURN transformed_output;
END;
$$;

Resultado esperado:

demo=# CREATE OR REPLACE FUNCTION tei_text_output_transform(model_id VARCHAR(100), response_json JSON)
RETURNS REAL[]
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_output REAL[];
BEGIN
  SELECT ARRAY(SELECT json_array_elements_text(response_json->0)) INTO transformed_output;
  RETURN transformed_output;
END;
$$;
CREATE FUNCTION
demo=#

Registra el modelo

Registra el modelo en AlloyDB Omni con el procedimiento google_ml.create_model. Especifica http://tei-service:8080/embed como el model_request_url para enrutar solicitudes al servicio del clúster de Kubernetes:

CALL
  google_ml.create_model(
    model_id => 'embeddinggemma',
    model_request_url => 'http://tei-service:8080/embed',
    model_provider => 'custom',
    model_type => 'text_embedding',
    model_in_transform_fn => 'tei_text_input_transform',
    model_out_transform_fn => 'tei_text_output_transform');

Resultado esperado:

demo=# CALL
  google_ml.create_model(
    model_id => 'embeddinggemma',
    model_request_url => 'http://tei-service:8080/embed',
    model_provider => 'custom',
    model_type => 'text_embedding',
    model_in_transform_fn => 'tei_text_input_transform',
    model_out_transform_fn => 'tei_text_output_transform');
CALL
demo=#

Prueba el modelo registrado con una consulta en SQL de muestra:

SELECT google_ml.embedding('embeddinggemma', 'What is AlloyDB Omni?');

La función devuelve la representación del array de números reales que genera el modelo EmbeddingGemma local que se ejecuta en GKE.

Presiona q para volver al mensaje de la sesión de psql.

Sal de la sesión de psql:

\q

7. Prueba el modelo con datos de muestra

Carga datos de muestra

En este instructivo, se usa el conjunto de datos de Cymbal Retail para demostrar la búsqueda de similitud de vectores. Usarás el SDK de Google Cloud y el cliente de PostgreSQL para importar datos a AlloyDB Omni.

En la sesión SSH de instance-1, conéctate a la base de datos de demostración y habilita la extensión vector:

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"

En la sesión de psql, haz lo siguiente:

CREATE EXTENSION IF NOT EXISTS vector;

Sal de la sesión de psql:

\q

Descarga y aplica el esquema para crear tablas en la base de datos demo:

gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=demo"

Resultado esperado:

student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=demo"
Password for user postgres:
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@cloudshell:~$

Verifica las tablas creadas:

psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\dt+"

Resultado esperado:

student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\dt+"
Password for user postgres: 
                                           List of relations
 Schema |       Name       | Type  |  Owner   | Persistence | Access method |    Size    | Description 
--------+------------------+-------+----------+-------------+---------------+------------+-------------
 public | cymbal_embedding | table | postgres | permanent   | heap          | 8192 bytes | 
 public | cymbal_inventory | table | postgres | permanent   | heap          | 8192 bytes | 
 public | cymbal_products  | table | postgres | permanent   | heap          | 8192 bytes | 
 public | cymbal_stores    | table | postgres | permanent   | heap          | 8192 bytes | 
(4 rows)

Carga datos en la tabla cymbal_products:

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

Resultado esperado:

student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_products from stdin csv header"
COPY 941
student@cloudshell:~$

A continuación, se muestra una muestra de algunas filas de la tabla cymbal_products.

psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT uniq_id,left(product_name,30),left(product_description,50),sale_price FROM cymbal_products limit 3"

Resultado esperado:

student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT uniq_id,left(product_name,30),left(product_description,50),sale_price FROM cymbal_products limit 3"
Password for user postgres: 
             uniq_id              |              left              |                        left                        | sale_price 
----------------------------------+--------------------------------+----------------------------------------------------+------------
 a73d5f754f225ecb9fdc64232a57bc37 | Laundry Tub Strainer Cup       |   Laundry tub strainer cup Chrome For 1-.50, drain |      11.74
 41b8993891aa7d39352f092ace8f3a86 | LED Starry Star Night Light La |  LED Starry Star Night Light Laser Projector 3D Oc |      46.97
 ed4a5c1b02990a1bebec908d416fe801 | Surya Horizon HRZ-1060 Area Ru |  The 100% polypropylene construction of the Surya  |       77.4
(3 rows)
student@cloudshell:~$

Carga datos en la tabla cymbal_inventory:

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

Resultado esperado:

student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_inventory from stdin csv header"
Password for user postgres: 
COPY 263861
student@cloudshell:~$

A continuación, se muestra una muestra de algunas filas de la tabla cymbal_inventory.

psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT * FROM cymbal_inventory LIMIT 3"

Resultado:

student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT * FROM cymbal_inventory LIMIT 3"
Password for user postgres: 
 store_id |             uniq_id              | inventory 
----------+----------------------------------+-----------
     1583 | adc4964a6138d1148b1d98c557546695 |         5
     1490 | adc4964a6138d1148b1d98c557546695 |         4
     1492 | adc4964a6138d1148b1d98c557546695 |         3
(3 rows)
student@cloudshell:~$

Carga datos en la tabla cymbal_stores:

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

Resultado esperado en la consola:

student@cloudshell:~$ gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "\copy cymbal_stores from stdin csv header"
Password for user postgres: 
COPY 4654
student@cloudshell:~$

A continuación, se muestra una muestra de algunas filas de la tabla cymbal_stores.

psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT store_id, name, zip_code FROM cymbal_stores limit 3"

Resultado:

student@cloudshell:~$ psql "host=$INSTANCE_IP user=postgres dbname=demo" -c "SELECT store_id, name, zip_code FROM cymbal_stores limit 3"
Password for user postgres: 
 store_id |       name        | zip_code 
----------+-------------------+----------
     1990 | Mayaguez Store    |      680
     2267 | Ware Supercenter  |     1082
     4359 | Ponce Supercenter |      780
(3 rows)
student@cloudshell:~$

Crea embeddings

Conéctate a la base de datos de demostración con psql y crea embeddings para los productos que se describen en la tabla cymbal_products en función de las descripciones de los productos.

Conéctate a la base de datos de demostración:

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"

Usa la columna embedding de tipo vector para almacenar los embeddings de texto generados para las descripciones de los productos.

Habilita la sincronización de consultas:

\timing

Genera embeddings para cada descripción del producto y almacénalos en la tabla cymbal_embedding:

INSERT INTO cymbal_embedding (uniq_id, embedding)
SELECT uniq_id, google_ml.embedding('embeddinggemma', product_description)::vector
FROM cymbal_products;

Resultado esperado:

demo=# INSERT INTO cymbal_embedding(uniq_id,embedding)  SELECT uniq_id, google_ml.embedding('embeddinggemma',product_description)::vector FROM cymbal_products;
INSERT 0 941
Time: 497878.136 ms (08:17.878)
demo=#

Ejecuta búsquedas semánticas

En la sesión de psql, busca los cinco productos principales que coincidan con la pregunta "What kind of fruit trees grow well here?" usando la distancia de coseno (<=>):

SELECT
    cp.product_name,
    left(cp.product_description, 80) AS description,
    cp.sale_price,
    cs.zip_code,
    (ce.embedding <=> google_ml.embedding('embeddinggemma', 'What kind of fruit trees grow well here?')::vector) AS distance
FROM
    cymbal_products cp
JOIN cymbal_embedding ce ON ce.uniq_id = cp.uniq_id
JOIN cymbal_inventory ci ON ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON cs.store_id = ci.store_id
WHERE
    ci.inventory > 0
    AND cs.store_id = 1583
ORDER BY
    distance ASC
LIMIT 5;

Resultado esperado:

demo=# SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        (ce.embedding <=> google_ml.embedding('embeddinggemma','What kind of fruit trees grow well here?')::vector) as distance
FROM
        cymbal_products cp
JOIN cymbal_embedding ce on ce.uniq_id=cp.uniq_id
JOIN cymbal_inventory ci on ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on cs.store_id=ci.store_id
WHERE
    ci.inventory > 0
    AND cs.store_id = 1583
ORDER BY
    distance ASC
LIMIT 5;
     product_name      |                                   description                                    | sale_price | zip_code |      distance
-----------------------+----------------------------------------------------------------------------------+------------+----------+--------------------
 Cherry Tree           | This is a beautiful cherry tree that will produce delicious cherries. It is an d |      75.00 |    93230 | 0.5210549378080666
 California Lilac      | This is a beautiful lilac tree that can grow to be over 10 feet tall. It is an d |       5.00 |    93230 | 0.5639421771781971
 Toyon                 | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e |      10.00 |    93230 | 0.5670010914504852
 Rose Bush             | This is a beautiful rose bush that will produce fragrant roses. It is a perennia |      50.00 |    93230 | 0.5731542622882957
 California Peppertree | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e |      25.00 |    93230 | 0.5750934653011995
(5 rows)

Time: 83.610 ms
demo=#

La consulta se ejecutó durante 83 ms y devolvió una lista de árboles de la tabla cymbal_products que coincidían con la solicitud y que tenían inventario disponible en la tienda con el número 1583.

Compila el índice de ANN

Con un conjunto de datos pequeño, es fácil usar la búsqueda exacta para analizar todos los embeddings, pero, cuando los datos aumentan, también lo hacen el tiempo de carga y el de respuesta. Para mejorar el rendimiento, puedes crear índices en tus datos de incorporación. A continuación, se incluye un ejemplo de cómo hacerlo con el índice ScaNN de Google para datos vectoriales.

Si perdiste la conexión a la base de datos de demostración, vuelve a conectarte:

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"

Habilita la extensión alloydb_scann:

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

Crea el índice de ScaNN en la columna embedding:

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

Vuelve a ejecutar la consulta de búsqueda semántica para comparar el rendimiento de la ejecución:

SELECT
    cp.product_name,
    left(cp.product_description, 80) AS description,
    cp.sale_price,
    cs.zip_code,
    (ce.embedding <=> google_ml.embedding('embeddinggemma', 'What kind of fruit trees grow well here?')::vector) AS distance
FROM
    cymbal_products cp
JOIN cymbal_embedding ce ON ce.uniq_id = cp.uniq_id
JOIN cymbal_inventory ci ON ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON cs.store_id = ci.store_id
WHERE
    ci.inventory > 0
    AND cs.store_id = 1583
ORDER BY
    distance ASC
LIMIT 5;

Resultado esperado:

demo=# SELECT
    cp.product_name,
    left(cp.product_description,80) as description,
    cp.sale_price,
    cs.zip_code,
    (ce.embedding <=> google_ml.embedding('embeddinggemma', 'What kind of fruit trees grow well here?')::vector) AS distance
FROM
    cymbal_products cp
JOIN cymbal_embedding ce ON ce.uniq_id = cp.uniq_id
JOIN cymbal_inventory ci ON ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON cs.store_id = ci.store_id
WHERE
    ci.inventory > 0
    AND cs.store_id = 1583
ORDER BY
    distance ASC
LIMIT 5;
     product_name      |                                   description                                    | sale_price | zip_code |      distance
-----------------------+----------------------------------------------------------------------------------+------------+----------+--------------------
 Cherry Tree           | This is a beautiful cherry tree that will produce delicious cherries. It is an d |      75.00 |    93230 | 0.5210549378080666
 California Lilac      | This is a beautiful lilac tree that can grow to be over 10 feet tall. It is an d |       5.00 |    93230 | 0.5639421771781971
 Toyon                 | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e |      10.00 |    93230 | 0.5670010914504852
 Rose Bush             | This is a beautiful rose bush that will produce fragrant roses. It is a perennia |      50.00 |    93230 | 0.5731542622882957
 California Peppertree | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e |      25.00 |    93230 | 0.5750934653011995
(5 rows)

Time: 64.783 ms

El tiempo de ejecución de la consulta se redujo ligeramente, y la mejora será más notable con conjuntos de datos más grandes. Los datos devueltos deben ser iguales o muy similares a los que obtuvimos sin el índice.

Prueba otras búsquedas y obtén más información para optimizar el índice de vectores en la documentación.

Sal de la sesión de psql:

\q

Para volver a Google Cloud Shell, desconéctate de la sesión de instance-1 SSH presionando CTRL+D o escribiendo exit.

8. Implementa Gemma con vLLM

Agrega un grupo de nodos para Gemma

Primero, verifica qué tipos de nodos están disponibles en tu región:

export LOCATION=us-central1-a
gcloud compute accelerator-types list --filter="zone:${LOCATION}"

Deberías ver una lista de los tipos de aceleradores disponibles, incluido el acelerador nvidia-l4. Ahora crea un grupo de nodos con el tipo de acelerador nvidia-l4:

export PROJECT_ID=$(gcloud config get project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
gcloud container node-pools create gpupool \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
    --project=${PROJECT_ID} \
    --location=${LOCATION} \
    --node-locations=${LOCATION}-a \
    --cluster=${CLUSTER_NAME} \
    --machine-type=g2-standard-8 \
    --num-nodes=1

Crea un manifiesto de implementación para el modelo Google Gemini 4 12B con vLLM:

cat << 'EOF' > gemma-12b-gpu-vllm-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gemma-12b-gpu-vllm-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-12b-gpu-vllm
  template:
    metadata:
      labels:
        app: gemma-12b-gpu-vllm
        ai.gke.io/model: gemma-4-12b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:latest
        resources:
          requests:
            cpu: "4"
            memory: "16Gi"
            ephemeral-storage: "30Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "8"
            memory: "24Gi"
            ephemeral-storage: "30Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
          - --quantization=fp8
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-12b-it
        - name: HF_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: gemma-12b-gpu-vllm-service
spec:
  selector:
    app: gemma-12b-gpu-vllm
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000
EOF

Aplica la implementación gemma-12b-gpu-vllm-deployment.yaml guardada:

kubectl apply -f gemma-12b-gpu-vllm-deployment.yaml

Resultado esperado:

$ kubectl apply -f gemma-12b-gpu-vllm-deployment.yaml
deployment.apps/gemma-12b-gpu-vllm-deployment created
service/gemma-12b-gpu-vllm-service created

Espera hasta que se complete la implementación y se cargue el modelo. Este proceso podría tardar varios minutos.

printf "Waiting for model to load..."; until kubectl logs -l app=gemma-12b-gpu-vllm --tail=50 2>/dev/null | grep -q "Application startup complete"; do printf "."; sleep 3; done; printf '\n\033[1;32m========================================\n[SUCCESS] Model is loaded and ready!\nYou can now proceed to the next step.\n========================================\033[0m\n'

Resultado esperado:

Waiting for model to load...
========================================
[SUCCESS] Model is loaded and ready!
You can now proceed to the next step.
========================================

Probar el modelo Habilita la redirección de puertos para acceder al modelo:

kubectl port-forward svc/gemma-12b-gpu-vllm-service 8090:8000

En otra ventana de la terminal, usa curl para enviar una instrucción al modelo:

curl http://localhost:8090/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "system", "content": "You are a helpful assistant running on GKE."},
      {"role": "user", "content": "What is AlloyDB Omni."}
    ],
    "temperature": 0.7
  }' | jq -r '.choices[0].message.content'

Resultado esperado:

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  3957  100  3761  100   196     85      4  0:00:49  0:00:43  0:00:06   830
**AlloyDB Omni** is a fully managed, PostgreSQL-compatible database engine from Google Cloud that can be run **on-premises, in other clouds, or in your own data centers.**

To understand it simply: It allows you to run the high-performance, enterprise-grade capabilities of Google's **AlloyDB** (a cloud-native database) on your own infrastructure.

Here is a breakdown of what makes it significant:

### 1. The "Best of Both Worlds" Architecture
Normally, you have to choose between:
*   **Managed Cloud Databases:** Easy to scale and manage, but you are locked into the cloud provider's infrastructure.
*   **Self-Managed Databases:** You have full control over the hardware/location, but you are responsible for scaling, patching, and high availability.

**AlloyDB Omni** bridges this gap. It provides the advanced features of a cloud-native database (like intelligent indexing, high availability, and massive scalability) while allowing you to run it anywhere.

Presiona Ctrl+C para detener el reenvío de puertos en la primera terminal (si aún se está ejecutando).

9. Registra el modelo Gemma 4 en AlloyDB Omni

Registra el modelo Gemma 12B en AlloyDB Omni con el procedimiento google_ml.create_model. Especifica http://gemma-12b-gpu-vllm-service:8000/v1/chat/completions como el model_request_url para enrutar solicitudes al servicio del clúster de Kubernetes:

Recupera la IP del extremo de AlloyDB Omni:

echo "INSTANCE_IP=$(kubectl get dbclusters.alloydbomni.dbadmin.goog my-omni -n default -o jsonpath='{.status.primary.endpoint}')"

Conéctate a la instancia de VM mediante SSH:

export ZONE=us-central1-a
gcloud compute ssh instance-1 --zone=$ZONE

Después de conectarte a la VM, exporta la variable INSTANCE_IP del paso anterior (el valor 10.128.0.33 se proporciona como ejemplo; reemplázalo por tu IP):

export INSTANCE_IP=10.128.0.33

Contraseña de exportación de AlloyDB:

export PGPASSWORD=VeryStrongPassword

Conéctate a la base de datos demo:

psql "host=$INSTANCE_IP user=postgres sslmode=require dbname=demo"

En la sesión de psql, registra el modelo:

CALL
  google_ml.create_model(
    model_id => 'gemma-12b-gpu',
    model_request_url => 'http://gemma-12b-gpu-vllm-service:8000/v1/chat/completions',
    model_provider => 'custom',
    model_type => 'llm');

Prueba el modelo con una consulta en SQL de muestra:

SELECT google_ml.predict_row(
  model_id => 'gemma-12b-gpu',
  request_body => json_build_object(
    'messages', json_build_array(
      json_build_object('role', 'user', 'content', 'What is AlloyDB Omni?'))))->'choices'->0->'message'->'content';

Presiona q para salir de la ventana de resultados y volver a la instrucción psql.

Combina la búsqueda de vectores con RAG de LLM en AlloyDB Omni

Usa la búsqueda de vectores con la solicitud del LLM para demostrar la RAG (generación mejorada por recuperación) con el LLM.

Ejecuta la consulta en SQL en PL/SQL:

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

Resultado esperado:

----------------------------------------------------------------------------------------------------------------------------------------------
 "Hello there! I'd be happy to help you find the perfect tree for your garden.                                                               +
                                                                                                                                             +
 Based on your location, we have a wonderful option that would grow beautifully in your area:                                                +
                                                                                                                                             +
 **Cherry Tree**                                                                                                                             +
 *   **Price:** $75.00                                                                                                                       +
 *   **Description:** This is a stunning deciduous tree that not only provides a beautiful landscape but also produces delicious cherries.   +
 *   **Supplemental Information:**                                                                                                           +
     *   **Growth:** It grows to about 15 feet tall.                                                                                         +
     *   **Appearance:** You can look forward to dark green leaves in the summer that transform into a vibrant red in the fall.              +
     *   **Benefits:** It's a great choice if you're looking for both fruit and extra shade or privacy in your yard.                         +
     *   **Care Tips:** It performs best in a cool, moist climate with sandy soil. Since you are in a suitable zone, it should thrive nicely!+
                                                                                                                                             +
 Would you like more details on how to plant this, or would you like to proceed with an order?"
(1 row)

La búsqueda complementa la instrucción al LLM con los resultados de la búsqueda de vectores.

Prueba otras búsquedas y experimenta con los patrones de RAG. El beneficio de la arquitectura presentada es su autosuficiencia total. Los datos no se envían fuera de tu clúster y se pueden ejecutar en entornos completamente aislados.

Sal de la sesión de psql:

\q

Desconéctate de la sesión SSH en la VM:

exit

No olvides que AlloyDB Omni tiene más funciones y labs.

Acelera las consultas analíticas con el motor de columnas en AlloyDB Omni

10. Limpia el entorno

Para evitar que se apliquen cargos a tu cuenta de Google Cloud, borra los recursos que creaste en este codelab.

Borra el clúster de GKE

En Cloud Shell, borra el clúster de GKE:

export PROJECT_ID=$(gcloud config get-value project)
export LOCATION=us-central1
export CLUSTER_NAME=alloydb-ai-gke
gcloud container clusters delete ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${LOCATION}

Resultado esperado:

student@cloudshell:~$ gcloud container clusters delete ${CLUSTER_NAME} \
>   --project=${PROJECT_ID} \
>   --region=${LOCATION}
The following clusters will be deleted.
 - [alloydb-ai-gke] in [us-central1]

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

Deleting cluster alloydb-ai-gke...done.
Deleted

Borra la VM cliente

En Cloud Shell, borra la instancia de Compute Engine:

export PROJECT_ID=$(gcloud config get-value project)
export ZONE=us-central1-a
gcloud compute instances delete instance-1 \
  --project=${PROJECT_ID} \
  --zone=${ZONE}

Resultado esperado:

student@cloudshell:~$ export PROJECT_ID=$(gcloud config get project)
export ZONE=us-central1-a
gcloud compute instances delete instance-1 \
  --project=${PROJECT_ID} \
  --zone=${ZONE}
Your active configuration is: [cloudshell-5399]
The following instances will be deleted. Any attached disks configured to be auto-deleted will be deleted unless they are attached to any other instances or the `--keep-disks` flag is given and specifies them for keeping. Deleting a disk 
is irreversible and any data on the disk will be lost.
 - [instance-1] in [us-central1-a]

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

Deleted

Si creaste un proyecto nuevo para este codelab, puedes borrar todo el proyecto en el Administrador de recursos de Google Cloud.

11. Felicitaciones

¡Felicitaciones por completar el codelab!

Temas que se abordaron

Cómo implementar AlloyDB Omni en un clúster de GKE
Cómo conectarse a AlloyDB Omni
Cómo cargar datos en AlloyDB Omni
Cómo implementar modelos de IA (embedding y LLM) en GKE
Cómo registrar modelos de IA en AlloyDB Omni
Cómo generar incorporaciones para la búsqueda semántica
Cómo ejecutar consultas de búsqueda semántica en AlloyDB Omni
Cómo crear y usar índices de vectores en AlloyDB Omni

Puedes obtener más información para trabajar con la IA en AlloyDB Omni en la documentación.

Encuesta

Resultado:

¿Cómo usarás este instructivo?

Solo lo leeré

Lo leeré y completaré los ejercicios