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 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
  • Familiaridad con la interfaz de línea de comandos y 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 (embeddings y LLM) en GKE
  • Cómo registrar modelos de IA en AlloyDB Omni
  • Cómo generar embeddings 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 de Google Cloud y un proyecto de Google Cloud
  • Un navegador web, como Chrome

2. Configuración y requisitos

Configura el proyecto

  1. 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 laboral o educativa.
  1. 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 Selecciona 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 proyectos nuevos

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

Campos de entrada de los detalles del proyecto

  • El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Las APIs de Google no usan el nombre del proyecto, 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, o puedes proporcionar uno propio. 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 configuras 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 que se indican al final de este lab para borrar los recursos y evitar cargos adicionales.
  • Los usuarios nuevos son aptos para participar en 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 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 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 para desarrolladores. Puedes ejecutar todos los pasos de este codelab desde tu navegador.

3. Habilita las APIs

Para usar Google Kubernetes Engine (GKE) para AlloyDB Omni y las implementaciones de 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 de la siguiente manera:

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 obtener más información 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

Implementar un clúster de GKE de Autopilot para ejecutar AlloyDB Omni, el operador y los contenedores de supervisión Con Autopilot, simplificamos la implementación: todos los recursos para el operador de AlloyDB Omni, el clúster y otros componentes se asignarán automáticamente.

Elige la región en la que implementas tus recursos. Elige una región geográficamente cercana a tu ubicación:

export LOCATION=<your region>

Establece las variables de entorno para tu implementación:

export PROJECT_ID=$(gcloud config get-value project)
export CLUSTER_NAME=alloydb-ai-gke

Crea el clúster de GKE Autopilot:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${LOCATION}

Resultado esperado en la consola:

student@cloudshell:~ (test-project-001-402417)$ export PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME=alloydb-ai-gke
Your active configuration is: [test-project-001-402417]
student@cloudshell:~ (test-project-001-402417)$ gcloud container clusters create-auto ${CLUSTER_NAME} \
>   --project=${PROJECT_ID} \
>   --region=${LOCATION}
Creating cluster alloydb-ai-gke in us-east4... Cluster is being health-checked.
..⠹
Creating cluster alloydb-ai-gke in us-east4... Cluster is being health-checked
(Kubernetes Control Plane is healthy)...done.
Created [https://container.googleapis.com/v1/projects/gleb-genai-002/zones/us-east4/clusters/alloydb-ai-gke].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-east4/alloydb-ai-gke?project=gleb-genai-002
kubeconfig entry generated for alloydb-ai-gke.
NAME            LOCATION  MASTER_VERSION      MASTER_IP      MACHINE_TYPE   NODE_VERSION        NUM_NODES  STATUS   STACK_TYPE
alloydb-ai-gke  us-east4  1.36.4-gke.1391002  34.145.214.51  ek-standard-8  1.36.4-gke.1391002  3          RUNNING  IPV4

Prepara el clúster

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

Cloud Shell incluye las herramientas de línea de comandos de Kubernetes kubectl y helm. Obtén las credenciales del clúster con gcloud:

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

Instala cert-manager mediante helm:

helm install \
  cert-manager oci://quay.io/jetstack/charts/cert-manager \
  --version v1.21.2 \
  --namespace cert-manager \
  --create-namespace \
  --set featureGates="ServerSideApply=true" \
  --set global.leaderElection.namespace=cert-manager \
  --set "extraArgs={--certificate-request-minimum-backoff-duration=15s,--certificate-request-maximum-backoff-duration=5m}" \
  --set crds.enabled=true

Resultado esperado de la consola (oculto):

student@cloudshell:~$ elm install \
>   cert-manager oci://quay.io/jetstack/charts/cert-manager \
>   --version v1.21.2 \
>   --namespace cert-manager \
>   --create-namespace \
>  --set featureGates="ServerSideApply=true" \
>  --set global.leaderElection.namespace=cert-manager \
>  --set "extraArgs={--certificate-request-minimum-backoff-duration=15s,--certificate-request-maximum-backoff-duration=5m}" \
>   --set crds.enabled=true
Pulled: quay.io/jetstack/charts/cert-manager:v1.21.2
Digest: sha256:634dce9c13b56677a2c05e2ab76c312d0be2664022d5dd05815da67e1fd5f610
I1016 12:25:06.128464   30644 warnings.go:107] "Warning: autopilot-default-resources-mutator:Autopilot updated Deployment cert-manager/cert-manager-cainjector: defaulted unspecified 'cpu' resource for containers [cert-manager-cainjector] (see http://g.co/gke/autopilot-defaults)."
I1016 12:25:06.129972   30644 warnings.go:107] "Warning: autopilot-default-resources-mutator:Autopilot updated Deployment cert-manager/cert-manager: defaulted unspecified 'cpu' resource for containers [cert-manager-controller] (see http://g.co/gke/autopilot-defaults)."
I1016 12:25:06.134580   30644 warnings.go:107] "Warning: autopilot-default-resources-mutator:Autopilot updated Deployment cert-manager/cert-manager-webhook: defaulted unspecified 'cpu' resource for containers [cert-manager-webhook] (see http://g.co/gke/autopilot-defaults)."
I1016 12:25:06.250590   30644 warnings.go:107] "Warning: AdmissionWebhookController: mutated namespaceselector of the webhooks to enforce GKE Autopilot policies."
I1016 12:25:09.758249   30644 warnings.go:107] "Warning: autopilot-default-resources-mutator:Autopilot updated Job cert-manager/cert-manager-startupapicheck: defaulted unspecified 'cpu' resource for containers [cert-manager-startupapicheck] (see http://g.co/gke/autopilot-defaults)."
NAME: cert-manager
LAST DEPLOYED: Fri Oct 16 12:24:57 2026
NAMESPACE: cert-manager
STATUS: deployed
REVISION: 1
DESCRIPTION: Install complete
TEST SUITE: None
NOTES:
cert-manager v1.21.2 has been deployed successfully!

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.9.0 \
--create-namespace \
--namespace alloydb-omni-system \
$(helm install --help | grep -q -- '--rollback-on-failure' && echo '--rollback-on-failure' || echo '--atomic') \
--timeout 5m

Resultado esperado de la consola (oculto):

student@cloudshell:~$ helm install alloydbomni-operator oci://gcr.io/alloydb-omni/alloydbomni-operator \
> --version 1.9.0 \
> --create-namespace \
> --namespace alloydb-omni-system \
> $(helm install --help | grep -q -- '--rollback-on-failure' && echo '--rollback-on-failure' || echo '--atomic') \
> --timeout 5m

Pulled: gcr.io/alloydb-omni/alloydbomni-operator:1.9.0
Digest: sha256:4f6cc3f0c1fbe003ab7d0119afee516e5c67ec950cd2909b418e5a3f6f09d1f6
I1016 12:28:50.088533   30982 warnings.go:107] "Warning: autopilot-default-resources-mutator:Autopilot updated Deployment alloydb-omni-system/fleet-controller-manager: adjusted 'cpu' resource to meet requirements for containers [fleet-manager] (see http://g.co/gke/autopilot-defaults)."
I1016 12:28:50.092917   30982 warnings.go:107] "Warning: autopilot-default-resources-mutator:Autopilot updated Deployment alloydb-omni-system/local-controller-manager: adjusted 'cpu' resource to meet requirements for containers [local-manager] (see http://g.co/gke/autopilot-defaults)."
I1016 12:28:50.229717   30982 warnings.go:107] "Warning: AdmissionWebhookController: mutated namespaceselector of the webhooks to enforce GKE Autopilot policies."
I1016 12:28:50.238578   30982 warnings.go:107] "Warning: AdmissionWebhookController: mutated namespaceselector of the webhooks to enforce GKE Autopilot policies."
NAME: alloydbomni-operator
LAST DEPLOYED: Fri Oct 16 12:28:45 2026
NAMESPACE: alloydb-omni-system
STATUS: deployed
REVISION: 1
DESCRIPTION: Install complete
TEST SUITE: None

Implementa el clúster de base de datos.

En el siguiente manifiesto, se configura un clúster de base de datos con el 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.4.0"
  primarySpec:
    adminUser:
      passwordRef:
        name: db-pw-my-omni
    features:
      googleMLExtension:
        enabled: true
    resources:
      cpu: 1
      memory: 8Gi
      disks:
      - name: DataDisk
        size: 20Gi
    dbLoadBalancerOptions:
      annotations:
        networking.gke.io/load-balancer-type: "internal"
  allowExternalIncomingTraffic: true
EOF

El valor del Secret de la contraseña es la representación en Base64 de VeryStrongPassword. En 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 terminal y lee el archivo.

Abre el editor en Cloud Shell

Después de leer el manifiesto 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 la 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.4)
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 embeddings en el clúster de GKE. En este instructivo, se usa el modelo EmbeddingGemma de Google.

Obtén un token de Hugging Face

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

  1. Accede a una cuenta o crea una en Hugging Face.
  2. Navega a Tu perfil > Tokens de acceso.
  3. Haz clic en Crear token nuevo.
  4. Ingresa un nombre para el token y selecciona el rol Lectura.
  5. Haz clic en Crear token y copia el valor del token generado.
  6. 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 contenedores de inferencia de embeddings de texto (TEI) de Hugging Face. Para obtener más información, consulta la documentación de TEI de GKE de Hugging Face.

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

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

Guarda los cambios presionando 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 Service 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 entrega 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

Para abrir una segunda pestaña de Cloud Shell, haz clic en + en la parte superior de la terminal:

Agrega una 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 (array 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 embeddings 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 de cliente y AlloyDB Omni

En Cloud Shell, crea la VM del cliente:

export ZONE=${LOCATION}-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 de 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 (reemplázala por tu IP de PRIMARYENDPOINT):

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 de 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 embeddings 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 model_request_url para enrutar las 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 local de EmbeddingGemma 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 de SSH en 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:~$ 

Aquí hay 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:~$ 

Aquí hay 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:~$

Aquí hay 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:~$ 

Compila embeddings

Conéctate a la base de datos de demostración con psql y crea embeddings para los productos descritos en la tabla cymbal_products según 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 del tipo vector para almacenar los embeddings de texto generados para las descripciones de los productos.

Habilita el tiempo de consulta:

\timing

Genera embeddings para cada descripción de 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 consultas de búsqueda semántica

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ó en 83 ms y devolvió una lista de árboles de la tabla cymbal_products que coinciden con la solicitud y con 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 crecen, el tiempo de carga y respuesta también aumenta. Para mejorar el rendimiento, puedes crear índices en tus datos de embeddings. Este es un ejemplo de cómo hacerlo con el índice de ScaNN de Google para datos vectoriales.

Vuelve a conectarte a la base de datos de demostración si perdiste la conexión:

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 un poco, y la mejora será más notable con conjuntos de datos más grandes. Los datos que se devuelven deben ser los mismos o muy similares a los que obtuvimos sin el índice.

Prueba otras consultas 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 SSH de instance-1 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:

gcloud compute accelerator-types list --filter="zone:${LOCATION}"

Deberías ver una lista de los tipos de aceleradores disponibles, incluido el acelerador nvidia-l4.

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

Detén la redirección de puertos en la primera terminal (si aún se está ejecutando) presionando Ctrl+C.

9. Registra el modelo de 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 model_request_url para enrutar las 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:

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

Exporta la contraseña 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 al mensaje de psql

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

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

Ejecuta la consulta en SQL en plsql:

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 consulta complementa la instrucción para el LLM con los resultados de la búsqueda de vectores.

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

Sal de la sesión de psql:

\q

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

exit

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

10. Limpia el entorno

Para evitar que se apliquen cargos continuos 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 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-east4]

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

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

Borra la VM de cliente

En Cloud Shell, borra la instancia de Compute Engine:

export PROJECT_ID=$(gcloud config get-value project)
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-east4-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-east4-a]

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

Deleted

Si creaste un proyecto nuevo para este codelab, puedes borrar todo el proyecto en Google Cloud Resource Manager.

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 (embeddings y LLM) en GKE
  • Cómo registrar modelos de IA en AlloyDB Omni
  • Cómo generar embeddings 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 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