Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

AlloyDB Omni et EmbeddingGemma avec Gemma 4 sur Kubernetes

1. Introduction

Dans cet atelier de programmation, vous allez apprendre à déployer AlloyDB Omni sur Google Kubernetes Engine (GKE) et à l'utiliser avec des modèles ouverts tels que EmbeddingGemma et Gemma 4 pour les embeddings et les prédictions. L'exécution de la base de données et des modèles dans le même cluster réduit la latence du réseau et évite les dépendances aux services tiers. Il vous aide également à répondre aux exigences de conformité et de résidence des données, car vos données ne quittent jamais votre environnement.

Diagramme de l'architecture d'AlloyDB Omni et EmbeddingGemma sur GKE

Prérequis

Connaissances de base de Google Cloud et de la console Google Cloud
Connaissances de base de Kubernetes et de GKE
Bonne connaissance de l'interface de ligne de commande et de Google Cloud Shell

Points abordés

Déployer AlloyDB Omni sur un cluster GKE
Se connecter à AlloyDB Omni
Charger des données dans AlloyDB Omni
Déployer des modèles d'IA (embedding et LLM) sur GKE
Enregistrer des modèles d'IA dans AlloyDB Omni
Générer des embeddings pour la recherche sémantique
Exécuter des requêtes de recherche sémantique dans AlloyDB Omni
Créer et utiliser des index vectoriels dans AlloyDB Omni

Prérequis

Un compte Google Cloud et un projet Google Cloud
Un navigateur Web (par exemple, Chrome)

2. Prérequis

Configuration du projet

Connectez-vous à la console Google Cloud. Si vous n'avez pas encore de compte Gmail ou Google Workspace, créez-en un. Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire.

Créez un projet ou sélectionnez-en un existant. Dans l'en-tête de la console Google Cloud, cliquez sur Sélectionner un projet, puis sur Nouveau projet.

Boîte de dialogue "Sélectionner un projet" dans la console Google Cloud

Dans la fenêtre Sélectionner un projet, cliquez sur Nouveau projet pour ouvrir la boîte de dialogue de création de projet.

Boîte de dialogue de création de projet

Dans la boîte de dialogue, saisissez un nom de projet, puis sélectionnez votre organisation ou votre emplacement.

Champs de saisie des détails du projet

Le nom du projet est le nom à afficher pour les participants au projet. Le nom du projet n'est pas utilisé par les API Google et vous pouvez le modifier à tout moment.
L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Google Cloud génère automatiquement un ID unique, mais vous pouvez également fournir le vôtre. Dans cet atelier de programmation, vous référencerez l'ID de votre projet avec l'espace réservé .
Le numéro de projet est un troisième identifiant utilisé par certaines API. Pour en savoir plus, consultez la documentation Resource Manager.

Activer la facturation

Si vous configurez la facturation à l'aide de crédits Google Cloud, vous pouvez ignorer cette étape.

Pour configurer un compte de facturation personnel, activez la facturation dans la console Google Cloud.

Cet atelier nécessite moins de 5 $ de ressources Google Cloud.
Suivez les étapes de nettoyage à la fin de cet atelier pour supprimer les ressources et éviter des frais supplémentaires.
Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais pour un crédit de 300 $.

Démarrer Cloud Shell

Dans cet atelier de programmation, vous allez utiliser Google Cloud Shell, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Activer Cloud Shell dans la barre d'outils en haut à droite :

Activer le bouton Cloud Shell

Vous pouvez également appuyer sur G, puis sur S, ou ouvrir directement Google Cloud Shell.

Une fois connecté, Cloud Shell affiche l'invite de terminal :

Capture d'écran du terminal Google Cloud Shell

Cloud Shell inclut un stockage persistant et des outils de développement. Vous pouvez exécuter toutes les étapes de cet atelier de programmation depuis votre navigateur.

3. Activer les API

Pour utiliser Google Kubernetes Engine (GKE) pour AlloyDB Omni et les déploiements de modèles, activez les API Compute Engine et GKE dans votre projet Google Cloud.

Dans Cloud Shell, vérifiez que l'ID de votre projet est configuré :

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

Si votre ID de projet n'est pas défini, configurez-le :

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

Activez les API requises :

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

Résultat attendu :

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.

Pour en savoir plus sur chaque API activée, consultez la documentation.

4. Déployer AlloyDB Omni sur GKE

Pour déployer AlloyDB Omni sur GKE, préparez un cluster Kubernetes en suivant les exigences de l'opérateur AlloyDB Omni.

Créer un cluster GKE

Déployez un cluster GKE standard avec la capacité d'exécuter AlloyDB Omni, l'opérateur et les conteneurs de surveillance. AlloyDB Omni nécessite au moins deux processeurs et 8 Go de RAM. Ce tutoriel utilise le type de machine n2-standard-4.

Définissez les variables d'environnement pour votre déploiement :

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

Créez le cluster GKE standard :

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

Résultat attendu sur la console :

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

Préparer le cluster

Installez les composants requis, tels que cert-manager, le contrôleur de certificats natif pour Kubernetes. Pour en savoir plus, consultez la documentation sur l'installation de cert-manager.

Cloud Shell inclut l'outil de ligne de commande Kubernetes kubectl. Obtenez les identifiants du cluster à l'aide de gcloud :

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

Installez cert-manager à l'aide de kubectl :

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

Résultat attendu sur la console (masqué) :

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

Installer l'opérateur AlloyDB Omni

Installez l'opérateur AlloyDB Omni à l'aide de Helm.

Téléchargez et installez le chart de l'opérateur 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

Résultat attendu sur la console (masqué) :

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

Déployez le cluster de bases de données.

Le fichier manifeste suivant configure un cluster de bases de données avec googleMLExtension activé et un équilibreur de charge interne :

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

La valeur secrète du mot de passe est la représentation Base64 de VeryStrongPassword. Dans les environnements de production, utilisez Google Secret Manager pour gérer les mots de passe. Pour en savoir plus, consultez la documentation Secret Manager.

Le fichier manifeste est enregistré sous le nom my-omni.yaml. Dans Cloud Shell, cliquez sur Ouvrir l'éditeur en haut à droite de la fenêtre du terminal, puis lisez le fichier.

Ouvrir l'éditeur dans Cloud Shell

Après avoir lu le fichier manifeste my-omni.yaml, cliquez sur Ouvrir le terminal pour revenir à l'invite de commande.

Ouvrir le terminal dans Cloud Shell

Appliquez le fichier manifeste my-omni.yaml :

kubectl apply -f my-omni.yaml

Résultat attendu sur la console :

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

Vérifiez l'état du cluster my-omni :

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

Lors du déploiement, le cluster de bases de données passe par des phases de configuration jusqu'à atteindre l'état DBClusterReady.

Résultat attendu sur la console :

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

Vous pouvez également surveiller le déploiement du cluster à l'aide de la commande kubectl log :

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

Se connecter à AlloyDB Omni

Lorsque le cluster est prêt, connectez-vous au pod de base de données à l'aide du client PostgreSQL (psql). Le mot de passe est VeryStrongPassword, comme défini dans 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

Exemple de résultat de la console :

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

Quittez la session psql en saisissant \q et en appuyant sur Entrée :

postgres=# \q

5. Déployer le modèle EmbeddingGemma sur GKE

Pour tester l'intégration de l'IA AlloyDB Omni avec des modèles locaux, déployez un modèle d'embedding sur le cluster GKE. Ce tutoriel utilise le modèle EmbeddingGemma de Google.

Créer un pool de nœuds pour le modèle

Pour exécuter l'inférence du modèle, préparez un pool de nœuds dédié. Vous pouvez utiliser un pool de nœuds reposant uniquement sur le processeur ou un pool de nœuds accéléré par GPU (tel que g2-standard-8 avec un GPU NVIDIA L4). Ce tutoriel utilise un pool de nœuds basé sur le processeur avec des types de machines c3-standard-8.

Créez un pool de nœuds CPU à nœud unique :

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

Résultat attendu :

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

Obtenir un jeton Hugging Face

Ce tutoriel déploie le modèle EmbeddingGemma de Hugging Face. Pour accéder aux pondérations du modèle, générez un jeton d'accès Hugging Face :

Connectez-vous à Hugging Face ou créez un compte.
Accédez à Votre profil > Jetons d'accès.
Cliquez sur Créer un jeton.
Saisissez un nom pour le jeton et sélectionnez le rôle Lecture.
Cliquez sur Créer un jeton et copiez la valeur du jeton généré.
Acceptez les conditions d'utilisation du modèle sur la page du modèle EmbeddingGemma si vous ne l'avez pas déjà fait.

Créez un secret Kubernetes contenant votre jeton Hugging Face dans Cloud Shell (remplacez l'espace réservé du jeton par votre jeton) :

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 -

Préparer le fichier manifeste de déploiement

Pour déployer le modèle, utilisez le package de conteneur TEI (Text Embeddings Inference) de Hugging Face. Pour en savoir plus, consultez la documentation Hugging Face GKE TEI.

Clonez le dépôt de déploiement depuis GitHub :

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

Inspectez et modifiez le fichier manifeste de configuration du processeur :

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

Fichier manifeste mis à jour pour le déploiement du processeur :

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"

Enregistrez les modifications en appuyant sur ctrl+s, puis revenez au terminal.

Déployer le modèle

Appliquez le fichier manifeste pour déployer le serveur TEI :

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

Surveillez le déploiement jusqu'à ce qu'il soit prêt :

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'

Vérifiez le service Kubernetes tei-service :

kubectl get service tei-service

Résultat attendu :

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

Le service CLUSTER-IP traite les requêtes en interne à l'adresse http://34.118.233.48:8080/embed.

Testez le point de terminaison du modèle en local à l'aide de kubectl port-forward :

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

Ouvrez un deuxième onglet Cloud Shell en cliquant sur + en haut du terminal :

Ajouter un onglet Cloud Shell

Dans le nouvel onglet, testez la génération d'embeddings avec curl :

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

Résultat attendu (tableau de vecteurs) :

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

Arrêtez le transfert de port dans le premier onglet en appuyant sur ctrl+c.

6. Enregistrer le modèle d'embedding dans AlloyDB Omni

Pour utiliser le modèle déployé depuis AlloyDB Omni, créez une base de données, définissez des fonctions de transformation et enregistrez le point de terminaison du modèle.

Créer une VM cliente et une base de données

Créez une instance de VM Compute Engine dans le même VPC pour qu'elle serve d'hôte intermédiaire client :

Diagramme de l'architecture réseau montrant la VM cliente et AlloyDB Omni

Dans Cloud Shell, créez la VM cliente :

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

Récupérez l'adresse IP du point de terminaison AlloyDB Omni :

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

Résultat attendu :

INSTANCE_IP=10.128.0.33

La valeur INSTANCE_IP correspond à l'adresse IP de l'équilibreur de charge interne pour le cluster AlloyDB Omni. Dans cet exemple, il s'agit de 10.131.0.33.

Connectez-vous à l'instance de VM via SSH :

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

Dans la session SSH sur instance-1, installez le client PostgreSQL :

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

Exportez l'adresse IP de l'équilibreur de charge AlloyDB Omni (remplacez PRIMARYENDPOINT par votre adresse IP) :

export INSTANCE_IP=10.131.0.33

Connectez-vous à AlloyDB Omni à l'aide de psql (le mot de passe est VeryStrongPassword) :

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

Dans la session psql, créez la base de données demo :

CREATE DATABASE demo;

Passez à la base de données demo :

\c demo

Créer des fonctions de transformation

Les points de terminaison d'embedding personnalisés nécessitent des fonctions de transformation d'entrée et de sortie pour adapter les formats de données entre AlloyDB Omni et l'API du modèle.

Créez la fonction de transformation d'entrée :

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

Résultat attendu :

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

Créez la fonction de transformation de sortie pour analyser la réponse du tableau de vecteurs :

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

Résultat attendu :

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

Enregistrer le modèle

Enregistrez le modèle dans AlloyDB Omni à l'aide de la procédure google_ml.create_model. Spécifiez http://tei-service:8080/embed comme model_request_url pour acheminer les requêtes vers le service de cluster 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');

Résultat attendu :

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

Testez le modèle enregistré avec un exemple de requête SQL :

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

La fonction renvoie la représentation du tableau de nombres réels générée par le modèle EmbeddingGemma local exécuté sur GKE.

Appuyez sur q pour revenir à l'invite de session psql.

Quittez la session psql :

\q

7. Tester le modèle avec des exemples de données

Charger des exemples de données

Ce tutoriel utilise l'ensemble de données Cymbal Retail pour illustrer la recherche de similarité vectorielle. Vous allez utiliser le client Google Cloud SDK et PostgreSQL pour importer des données dans AlloyDB Omni.

Dans la session SSH sur instance-1, connectez-vous à la base de données de démonstration et activez l'extension vector :

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

Dans la session psql :

CREATE EXTENSION IF NOT EXISTS vector;

Quittez la session psql :

\q

Téléchargez et appliquez le schéma pour créer des tables dans la base de données demo :

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

Résultat attendu :

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:~$

Vérifiez les tables créées :

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

Résultat attendu :

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)

Chargez les données dans la table 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"

Résultat attendu :

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:~$

Voici un exemple de quelques lignes du tableau 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"

Résultat attendu :

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:~$

Chargez les données dans la table 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"

Résultat attendu :

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:~$

Voici un exemple de quelques lignes du tableau cymbal_inventory.

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

Résultat :

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:~$

Chargez les données dans la table 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"

Résultat attendu sur la console :

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:~$

Voici un exemple de quelques lignes du tableau cymbal_stores.

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

Résultat :

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:~$

Créer des embeddings

Connectez-vous à la base de données de démonstration à l'aide de psql et créez des embeddings pour les produits décrits dans la table cymbal_products en fonction des descriptions de produits.

Connectez-vous à la base de données de démonstration :

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

Utilisez la colonne embedding de type vector pour stocker les embeddings textuels générés pour les descriptions de produits.

Activer le timing des requêtes :

\timing

Générez des embeddings pour chaque description de produit et stockez-les dans la table cymbal_embedding :

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

Résultat attendu :

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

Exécuter des requêtes de recherche sémantique

Dans la session psql, trouvez les cinq principaux produits correspondant à la question "What kind of fruit trees grow well here?" à l'aide de la distance de cosinus (<=>) :

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;

Résultat attendu :

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 requête s'est exécutée en 83 ms et a renvoyé une liste d'arbres de la table cymbal_products correspondant à la requête et avec un inventaire disponible dans le magasin numéro 1583.

Créer un index ANN

Avec un petit ensemble de données, il est facile d'utiliser la recherche exacte en analysant tous les embeddings, mais lorsque les données augmentent, le temps de chargement et de réponse augmente également. Pour améliorer les performances, vous pouvez créer des index sur vos données d'embedding. Voici un exemple d'utilisation de l'index ScaNN de Google pour les données vectorielles.

Si vous avez perdu la connexion à la base de données de démonstration, reconnectez-vous :

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

Activez l'extension alloydb_scann :

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

Créez l'index ScaNN sur la colonne embedding :

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

Exécutez à nouveau la requête de recherche sémantique pour comparer les performances d'exécution :

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;

Résultat attendu :

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

Le temps d'exécution des requêtes a légèrement diminué. Le gain sera plus visible avec des ensembles de données plus volumineux. Les données renvoyées doivent être identiques ou très similaires à celles obtenues sans index.

Essayez d'autres requêtes et découvrez comment optimiser l'index vectoriel dans la documentation.

Quittez la session psql :

\q

Revenez à Google Cloud Shell en vous déconnectant de la session SSH instance-1 en appuyant sur CTRL+D ou en saisissant exit.

8. Déployer Gemma avec vLLM

Ajouter un pool de nœuds pour Gemma

Tout d'abord, vérifiez les types de nœuds disponibles dans votre région :

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

Une liste des types d'accélérateurs disponibles, y compris l'accélérateur nvidia-l4, doit s'afficher. Créez maintenant un pool de nœuds avec le type d'accélérateur 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

Créez un fichier manifeste de déploiement pour le modèle Google Gemini 4 12B à l'aide de 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

Appliquez le déploiement gemma-12b-gpu-vllm-deployment.yaml enregistré :

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

Résultat attendu :

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

Attendez la fin du déploiement et le chargement du modèle. Cette opération peut prendre plusieurs minutes.

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'

Résultat attendu :

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

tester le modèle. Activez le transfert de port pour accéder au modèle :

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

Dans une autre fenêtre de terminal, utilisez curl pour envoyer une requête au modèle :

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'

Résultat attendu :

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

Arrêtez la redirection de port dans le premier terminal (si elle est toujours en cours d'exécution) en appuyant sur Ctrl+C.

9. Enregistrer le modèle Gemma 4 dans AlloyDB Omni

Enregistrez le modèle Gemma 12B dans AlloyDB Omni à l'aide de la procédure google_ml.create_model. Spécifiez http://gemma-12b-gpu-vllm-service:8000/v1/chat/completions comme model_request_url pour acheminer les requêtes vers le service de cluster Kubernetes :

Récupérez l'adresse IP du point de terminaison AlloyDB Omni :

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

Connectez-vous à l'instance de VM via SSH :

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

Après vous être connecté à la VM, exportez la variable INSTANCE_IP de l'étape précédente (la valeur 10.128.0.33 est donnée à titre d'exemple, remplacez-la par votre adresse IP) :

export INSTANCE_IP=10.128.0.33

Exporter le mot de passe AlloyDB :

export PGPASSWORD=VeryStrongPassword

Connectez-vous à la base de données demo :

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

Dans la session psql, enregistrez le modèle :

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');

Testez le modèle avec un exemple de requête SQL :

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

Appuyez sur q pour quitter la fenêtre de résultats et revenir à l'invite psql.

Combiner la recherche vectorielle avec le RAG LLM dans AlloyDB Omni

Utilisez la recherche vectorielle avec la requête LLM pour illustrer la génération augmentée par récupération (RAG) avec le LLM.

Exécutez la requête SQL dans 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;

Résultat attendu :

----------------------------------------------------------------------------------------------------------------------------------------------
 "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 requête complète le prompt envoyé au LLM par les résultats de la recherche vectorielle.

Essayez d'autres requêtes et testez les modèles RAG. L'avantage de l'architecture présentée est son autonomie totale. Les données ne sont pas envoyées en dehors de votre cluster et peuvent s'exécuter dans des environnements complètement isolés.

Quittez la session psql :

\q

Déconnectez-vous de la session SSH sur la VM :

exit

N'oubliez pas qu'AlloyDB Omni propose d'autres fonctionnalités et ateliers.

Accélérer les requêtes analytiques avec le moteur de données en colonnes dans AlloyDB Omni

10. Nettoyer l'environnement

Pour éviter que les ressources créées dans cet atelier de programmation soient facturées en permanence sur votre compte Google Cloud, supprimez-les.

Supprimer le cluster GKE

Dans Cloud Shell, supprimez le cluster 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}

Résultat attendu :

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

Supprimer la VM cliente

Dans Cloud Shell, supprimez l'instance 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}

Résultat attendu :

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 vous avez créé un projet pour cet atelier de programmation, vous pouvez éventuellement le supprimer entièrement dans Google Cloud Resource Manager.

11. Félicitations

Félicitations, vous avez terminé cet atelier de programmation !

Sujets abordés

Déployer AlloyDB Omni sur un cluster GKE
Se connecter à AlloyDB Omni
Charger des données dans AlloyDB Omni
Déployer des modèles d'IA (embedding et LLM) sur GKE
Enregistrer des modèles d'IA dans AlloyDB Omni
Générer des embeddings pour la recherche sémantique
Exécuter des requêtes de recherche sémantique dans AlloyDB Omni
Créer et utiliser des index vectoriels dans AlloyDB Omni

Pour en savoir plus sur l'utilisation de l'IA dans AlloyDB Omni, consultez la documentation.

Enquête

Résultat :

Comment allez-vous utiliser ce tutoriel ?

Je vais le lire uniquement

Je vais le lire et effectuer les exercices