Premiers pas avec les embeddings vectoriels avec AlloyDB AI

1. Introduction

Dans cet atelier de programmation, vous allez apprendre à utiliser AlloyDB AI en combinant la recherche vectorielle avec les embeddings Vertex AI. Cet atelier fait partie d'une collection d'ateliers consacrés aux fonctionnalités AlloyDB/AI. Pour en savoir plus, consultez la page AlloyDB AI dans la documentation.

Prérequis

• Connaissances de base concernant la console Google Cloud
• Compétences de base concernant l'interface de ligne de commande et Cloud Shell

Points abordés

• Déployer un cluster AlloyDB et une instance principale
• Se connecter à AlloyDB à partir d'une VM Google Compute Engine
• Créer une base de données et activer AlloyDB AI
• Charger des données dans la base de données
• Utiliser AlloyDB Studio
• Utiliser le modèle d'embedding Gemini Enterprise Agent Platform dans AlloyDB
• Utiliser Gemini Enterprise Agent Platform Studio
• Enrichir les résultats à l'aide du modèle génératif Gemini Enterprise Agent Platform
• Améliorer les performances à l'aide de l'index vectoriel

Prérequis

• Un compte Google Cloud et un projet Google Cloud
• Un navigateur Web tel que Chrome

2. Préparation

Configuration du projet

1. Connectez-vous à la console Google Cloud. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)

Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire.

Attention : Il est possible que des restrictions vous empêchent d'activer les API nécessaires pour cet atelier ou d'accéder à certaines ressources avec votre compte professionnel ou scolaire.

2. Créez un projet ou réutilisez-en un existant. Pour créer un projet dans la console Google Cloud, cliquez sur le bouton "Sélectionner un projet" dans l'en-tête pour ouvrir une fenêtre pop-up.

Dans la fenêtre "Sélectionner un projet", cliquez sur le bouton "Nouveau projet" pour ouvrir une boîte de dialogue pour le nouveau projet.

Dans la boîte de dialogue, saisissez le nom de projet de votre choix et sélectionnez l'emplacement.

• Le nom du projet est le nom à afficher pour les participants au projet. Le nom de projet n'est utilisé par aucune API Google et peut être modifié à 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 le personnaliser. Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire ou en fournir un pour vérifier sa disponibilité. Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet, généralement identifié par l'espace réservé PROJECT_ID.
• Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet est unique. Une fois que vous l'avez choisi, personne d'autre ne peut l'employer. Vous en êtes le seul utilisateur. Même si un projet est supprimé, son ID ne peut pas être réutilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement qui ait du sens pour votre organisation.

Activer la facturation

Configurer un compte de facturation personnel

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

Pour configurer un compte de facturation personnel, cliquez ici pour activer la facturation dans la console Cloud.

Remarques :

• Cet atelier devrait vous coûter moins de 3 USD en ressources Cloud.
• Vous pouvez suivre les étapes à la fin de cet atelier pour supprimer les ressources et éviter ainsi 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

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Vous pouvez également appuyer sur G, puis sur S. Cette séquence activera Cloud Shell si vous êtes dans la console Google Cloud ou si vous utilisez ce lien.

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

3. Avant de commencer

Activer l'API

Résultat :

L'activation de ces ressources peut entraîner des coûts. Si vous supprimez l'instance AlloyDB et le bucket de stockage une fois l'atelier terminé, le coût total ne dépassera pas 5 $. Vérifiez vos paramètres de facturation avant de continuer.

Pour utiliser AlloyDB, Compute Engine, les services réseau et Gemini Enterprise Agent Platform, vous devez activer leurs API respectives dans votre projet Google Cloud.

Activer les API

Dans Cloud Shell, dans le terminal, assurez-vous que l'ID de votre projet est configuré :

gcloud config set project [YOUR-PROJECT-ID]

Définissez la variable d'environnement PROJECT_ID :

PROJECT_ID=$(gcloud config get-value project)

Activez toutes les API nécessaires :

gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       aiplatform.googleapis.com

Résultat attendu

student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$ 
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       aiplatform.googleapis.com
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

Avant de créer un cluster AlloyDB, allouez une plage d'adresses IP privées disponibles dans votre VPC qui sera utilisée par la future instance AlloyDB. Si vous n'en avez pas, vous devez en créer un, l'attribuer pour qu'il soit utilisé par les services Google internes, puis vous pourrez créer le cluster et l'instance.

Créer une plage d'adresses IP privées

Remarque : Cette étape n'est requise que si vous n'avez pas encore attribué de plage d'adresses IP privées inutilisées pour travailler avec les services internes de Google.

Vous devez configurer l'accès au service privé dans votre VPC pour AlloyDB. L'hypothèse ici est que vous avez le réseau VPC "par défaut" dans le projet et qu'il sera utilisé pour toutes les actions.

Créez la plage d'adresses IP privées :

gcloud compute addresses create psa-range \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --description="VPC private service access" \
    --network=default

Créez une connexion privée à l'aide de la plage d'adresses IP allouée :

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=psa-range \
    --network=default

Remarque : L'exécution de la deuxième commande prend quelques minutes.

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ gcloud compute addresses create psa-range \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --description="VPC private service access" \
    --network=default
Created [https://www.googleapis.com/compute/v1/projects/test-project-402417/global/addresses/psa-range].

student@cloudshell:~ (test-project-402417)$ gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=psa-range \
    --network=default
Operation "operations/pssn.p24-4470404856-595e209f-19b7-4669-8a71-cbd45de8ba66" finished successfully.

student@cloudshell:~ (test-project-402417)$

Créer un cluster AlloyDB

Créer un cluster AlloyDB dans la région us-central1

Définissez le mot de passe de l'utilisateur postgres. Vous pouvez définir votre propre mot de passe ou utiliser une fonction aléatoire pour en générer un.

export PGPASSWORD=`openssl rand -hex 16`

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ export PGPASSWORD=`openssl rand -hex 12`

Notez le mot de passe PostgreSQL (il vous servira plus tard) :

echo $PGPASSWORD

Vous aurez besoin de ce mot de passe à l'avenir pour vous connecter à l'instance en tant qu'utilisateur postgres. Enregistrez ce mot de passe pour l'utiliser dans les étapes suivantes.

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ echo $PGPASSWORD
bbefbfde7601985b0dee5723 (Note: Yours will be different!)

Créer un cluster d'essai sans frais

Si vous n'avez jamais utilisé AlloyDB, vous pouvez créer un cluster d'essai sans frais :

Définissez des variables d'environnement pour la région et le nom du cluster :

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01

Exécutez la commande pour créer le cluster :

gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION \
    --subscription-type=TRIAL

Résultat attendu sur la console :

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION \
    --subscription-type=TRIAL
Operation ID: operation-1697655441138-6080235852277-9e7f04f5-2012fce4
Creating cluster...done.                                                                                                                                                                                                                                                           

Créez une instance principale AlloyDB pour votre cluster dans la même session Cloud Shell. Si vous êtes déconnecté, vous devrez définir à nouveau les variables d'environnement pour la région et le nom du cluster.

Remarque : La création de l'instance prend généralement entre 6 et 10 minutes.

gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=8 \
    --region=$REGION \
    --cluster=$ADBCLUSTER

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=8 \
    --region=$REGION \
    --availability-type ZONAL \
    --cluster=$ADBCLUSTER
Operation ID: operation-1697659203545-6080315c6e8ee-391805db-25852721
Creating instance...done.                                                                                                                                                                                                                                                     

Créer un cluster AlloyDB Standard

Si ce n'est pas votre premier cluster AlloyDB dans le projet, créez un cluster standard. Si vous avez déjà créé un cluster d'essai sans frais, ignorez cette étape.

Définissez des variables d'environnement pour la région et le nom du cluster :

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01

Exécutez la commande pour créer le cluster :

gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION

Résultat attendu sur la console :

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION 
Operation ID: operation-1697655441138-6080235852277-9e7f04f5-2012fce4
Creating cluster...done.                                                                                                                                                                                                                                                           

Créez une instance principale AlloyDB pour votre cluster dans la même session Cloud Shell. Si vous êtes déconnecté, vous devrez définir à nouveau les variables d'environnement pour la région et le nom du cluster.

Remarque : La création de l'instance prend généralement entre 6 et 10 minutes.

gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=2 \
    --region=$REGION \
    --cluster=$ADBCLUSTER

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ gcloud alloydb instances create $ADBCLUSTER-pr \
    --instance-type=PRIMARY \
    --cpu-count=2 \
    --region=$REGION \
    --availability-type ZONAL \
    --cluster=$ADBCLUSTER
Operation ID: operation-1697659203545-6080315c6e8ee-391805db-25852721
Creating instance...done.                                                                                                                                                                                                                                                     

5. vous connecter à AlloyDB ;

AlloyDB est déployé à l'aide d'une connexion privée uniquement. Vous avez donc besoin d'une VM Compute Engine avec le client PostgreSQL installé pour pouvoir utiliser la base de données.

Déployer une VM GCE

Créez une VM GCE dans la même région et dans le même VPC que le cluster AlloyDB.

Dans Cloud Shell, exécutez :

export ZONE=us-central1-a
gcloud compute instances create instance-1 \
    --zone=$ZONE \
    --create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-13 AND family!=debian-13-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ export ZONE=us-central1-a
gcloud compute instances create instance-1 \
    --zone=$ZONE \
    --create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-13 AND family!=debian-13-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform

Created [https://www.googleapis.com/compute/v1/projects/test-project-402417/zones/us-central1-a/instances/instance-1].
NAME: instance-1
ZONE: us-central1-a
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE: 
INTERNAL_IP: 10.128.0.2
EXTERNAL_IP: 34.71.192.233
STATUS: RUNNING

Installer le client Postgres

Installez le logiciel client PostgreSQL sur la VM déployée.

Connectez-vous à la VM.

Remarque : La première connexion SSH à la VM peut prendre plus de temps, car le processus inclut la création d'une clé RSA pour une connexion sécurisée et la propagation de la partie publique de la clé au projet.

gcloud compute ssh instance-1 --zone=us-central1-a

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ gcloud compute ssh instance-1 --zone=us-central1-a
Updating project ssh metadata...working..Updated [https://www.googleapis.com/compute/v1/projects/test-project-402417].                                                                                                                                                         
Updating project ssh metadata...done.                                                                                                                                                                                                                                              
Waiting for SSH key to propagate.
Warning: Permanently added 'compute.5110295539541121102' (ECDSA) to the list of known hosts.
Linux instance-1 6.12.101+deb13-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.12.101-1 (2026-08-05) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
student@instance-1:~$ 

Installez la commande logicielle en cours d'exécution dans la VM :

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

Résultat attendu sur la console :

student@instance-1:~$ sudo apt-get update
sudo apt-get install --yes postgresql-client
Get:1 file:/etc/apt/mirrors/debian.list Mirrorlist [30 B]
Get:2 file:/etc/apt/mirrors/debian-security.list Mirrorlist [39 B]                      
Hit:3 https://deb.debian.org/debian trixie InRelease                                    
Get:4 https://deb.debian.org/debian trixie-updates InRelease [47.3 kB]
Get:5 https://deb.debian.org/debian trixie-backports InRelease [54.0 kB]
Get:6 https://deb.debian.org/debian-security trixie-security InRelease [43.4 kB]
Hit:10 https://packages.cloud.google.com/apt google-compute-engine-trixie-stable InRelease
...redacted...
update-alternatives: using /usr/share/postgresql/17/man/man1/psql.1.gz to provide /usr/share/man/man1/psql.1.gz (psql.1.gz) in auto mode
Setting up postgresql-client (17+278) ...
Processing triggers for man-db (2.13.1-1) ...
Processing triggers for libc-bin (2.41-12+deb13u3) ...

Se connecter à l'instance

Connectez-vous à l'instance principale depuis la VM à l'aide de psql.

Dans le même onglet Cloud Shell que la session SSH ouverte sur votre VM instance-1.

Utilisez la valeur du mot de passe AlloyDB (PGPASSWORD) notée et l'ID du cluster AlloyDB pour vous connecter à AlloyDB depuis la VM GCE :

export PGPASSWORD=<Noted password>

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
export INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"

Résultat attendu sur la console :

student@instance-1:~$ export PGPASSWORD=CQhOi5OygD4ps6ty
student@instance-1:~$ export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
export INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"
psql (17.10 (Debian 17.10-0+deb13u1), server 17.9)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off, ALPN: postgresql)
Type "help" for help.

postgres=>

Fermez la session psql :

exit

6. Préparer la base de données

Créez une base de données, activez l'intégration de l'IA Agent Platform, créez des objets de base de données et importez des données.

Accorder les autorisations nécessaires à AlloyDB

Ajoutez les autorisations Gemini Enterprise Agent Platform à l'agent de service AlloyDB.

Ouvrez un autre onglet Cloud Shell à l'aide du signe "+" situé en haut.

Dans le nouvel onglet Cloud Shell, exécutez :

PROJECT_ID=$(gcloud config get-value project)
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

Résultat attendu sur la console :

student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-11039]
student@cloudshell:~ (test-project-001-402417)$ gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"
Updated IAM policy for project [test-project-001-402417].
bindings:
- members:
  - serviceAccount:[e-mail]
  role: roles/aiplatform.user
- members:
...
etag: BwYIEbe_Z3U=
version: 1
 

Fermez l'onglet en exécutant la commande "exit" dans l'onglet :

exit

Créer une base de données

Démarrage rapide pour la création d'une base de données

Dans la session de la VM GCE, exécutez :

Remarque : Si votre session SSH a été interrompue, vous devez réinitialiser vos variables d'environnement. Par exemple :

export PGPASSWORD=<Noted password>

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

export REGION=us-central1

export ADBCLUSTER=alloydb-aip-01

export INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")

Créez une base de données :

psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db"

Résultat attendu sur la console :

student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE quickstart_db"
CREATE DATABASE
student@instance-1:~$  

Activer l'intégration à Vertex AI

Activez l'intégration Vertex AI et les extensions pgvector dans la base de données.

Dans la VM GCE, exécutez :

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE"
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS vector"

Résultat attendu sur la console :

student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE"
psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "CREATE EXTENSION IF NOT EXISTS vector"
CREATE EXTENSION
CREATE EXTENSION
student@instance-1:~$ 

Importer des données

Téléchargez les données préparées et importez-les dans la nouvelle base de données.

Dans la VM GCE, exécutez :

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

Résultat attendu sur la console :

student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"
SET
SET
SET
SET
SET
 set_config 
------------
 
(1 row)
SET
SET
SET
SET
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE SEQUENCE
ALTER TABLE
ALTER SEQUENCE
ALTER TABLE
ALTER TABLE
ALTER TABLE
student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_products from stdin csv header"
COPY 941
student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_inventory from stdin csv header"
COPY 263861
student@instance-1:~$ gsutil cat gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv |psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db" -c "\copy cymbal_stores from stdin csv header"
COPY 4654
student@instance-1:~$

7. Calculer des embeddings

Après avoir importé les données, vous disposez des données produit dans la table cymbal_products, de l'inventaire indiquant le nombre de produits disponibles dans chaque magasin dans la table cymbal_inventory et de la liste des magasins dans la table cymbal_stores. Vous devez calculer les données vectorielles en fonction des descriptions des produits. Pour ce faire, vous pouvez utiliser des fonctions telles que google_ml.embedding. Pour en savoir plus sur la technologie utilisée, consultez la documentation.

Il est facile de générer des embeddings pour quelques lignes, mais comment rendre le processus efficace si nous en avons des milliers ? Cette section explique comment générer et gérer des embeddings pour les grandes tables. Pour en savoir plus sur les différentes options et techniques, consultez le guide.

Activer la génération rapide d'embeddings

Connectez-vous à la base de données à l'aide de psql depuis votre VM en utilisant l'adresse IP de l'instance AlloyDB et le mot de passe postgres :

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"

Vérifiez la version de l'extension google_ml_integration.

SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

La version doit être 1.5.2 ou ultérieure. Voici un exemple de résultat :

quickstart_db=> SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
 extversion 
------------
 1.6
(1 row)

La version par défaut doit être la version 1.6 ou une version ultérieure. Si votre instance affiche une version antérieure, elle doit probablement être mise à jour. Vérifiez si la maintenance a été désactivée pour l'instance.

Remarque : La version de l'extension est gérée automatiquement dans le backend. Vous n'avez pas besoin de la mettre à niveau manuellement.

Toutefois, vous pouvez appeler une procédure permettant d'activer la version Preview pour le package (n'utilisez pas les versions Preview en production).

CALL google_ml.upgrade_to_preview_version();

Vérifiez que l'indicateur de base de données google_ml_integration.enable_faster_embedding_generation est activé. Dans la même session psql, vérifiez la valeur du signalement :

show google_ml_integration.enable_faster_embedding_generation;

Si l'indicateur est dans la bonne position, le résultat attendu ressemble à ceci :

quickstart_db=> show google_ml_integration.enable_faster_embedding_generation;                          
 google_ml_integration.enable_faster_embedding_generation 
----------------------------------------------------------
 on
(1 row)

Si la valeur du flag est "off", vous devez mettre à jour l'instance. Pour ce faire, utilisez la console Web ou la commande gcloud, comme décrit dans la documentation.

Quittez la session psql :

exit;

Pour mettre à jour l'indicateur à l'aide de gcloud, exécutez la commande suivante :

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
gcloud beta alloydb instances update $ADBCLUSTER-pr \
   --database-flags google_ml_integration.enable_faster_embedding_generation=on \
   --region=$REGION \
   --cluster=$ADBCLUSTER \
   --project=$PROJECT_ID \
   --update-mode=FORCE_APPLY

Cela peut prendre quelques minutes, mais la valeur du signalement devrait finir par passer sur "Activé". Vous pouvez ensuite passer aux étapes suivantes.

Créer une colonne d'embedding

Connectez-vous à la base de données à l'aide de psql et créez une colonne virtuelle avec le type de données vectoriel à utiliser par la fonction d'embedding dans la table cymbal_products.

Remarque : Si votre session SSH a été interrompue, réinitialisez vos variables d'environnement. Par exemple :

export PGPASSWORD=<Noted password>

export INSTANCE_IP=<AlloyDB Instance IP>

psql "host=$INSTANCE_IP user=postgres dbname=quickstart_db"

Dans la session psql, après vous être connecté à la base de données, exécutez la commande suivante :

ALTER TABLE cymbal_products ADD COLUMN embedding vector(768);

La commande crée une colonne virtuelle pour les futurs embeddings.

Résultat attendu sur la console :

quickstart_db=> ALTER TABLE cymbal_products ADD COLUMN embedding vector(768);
ALTER TABLE
quickstart_db=> 

Générez des embeddings par lots de 50 lignes. Dans la même session psql, exécutez :

Activez le timing pour mesurer le temps nécessaire :

\timing

Exécutez la commande suivante :

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'cymbal_products',
    content_column => 'product_description',
    embedding_column => 'embedding',
    batch_size => 50
);

La sortie de la console indique que la génération de l'embedding a pris moins de deux secondes :

quickstart_db=> CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'cymbal_products',
    content_column => 'product_description',
    embedding_column => 'embedding',
    batch_size => 50
);
NOTICE:  Initialize embedding completed successfully for table cymbal_products
CALL
Time: 1458.704 ms (00:01.459)
quickstart_db=>

Vous pouvez tester différentes tailles de lot et voir si cela modifie le temps d'exécution.

Par défaut, les embeddings ne sont pas actualisés si la colonne product_description correspondante est mise à jour ou si une nouvelle ligne entière est insérée. Toutefois, vous pouvez le faire en définissant le paramètre incremental_refresh_mode.

Créez une colonne product_embeddings et configurez-la pour qu'elle soit automatiquement modifiable :

ALTER TABLE cymbal_products ADD COLUMN product_embedding vector(768);
CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'cymbal_products',
    content_column => 'product_description',
    embedding_column => 'product_embedding',
    batch_size => 50,
    incremental_refresh_mode => 'transactional'
);

Insérez une ligne dans le tableau.

INSERT INTO "cymbal_products" ("uniq_id", "crawl_timestamp", "product_url", "product_name", "product_description", "list_price", "sale_price", "brand", "item_number", "gtin", "package_size", "category", "postal_code", "available", "product_embedding", "embedding") VALUES ('fd604542e04b470f9e6348e640cff794', NOW(), 'https://example.com/new_product', 'New Cymbal Product', 'This is a new cymbal product description.', 199.99, 149.99, 'Example Brand', 'EB123', '1234567890', 'Single', 'Cymbals', '12345', TRUE, NULL, NULL);

Interrogez la table pour comparer deux colonnes d'embedding :

SELECT uniq_id,embedding, (product_embedding::real[])[1:5] as product_embedding  FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';

Le résultat indique que product_embedding est renseigné automatiquement, tandis que embedding reste vide :

quickstart_db=> SELECT uniq_id,embedding, (product_embedding::real[])[1:5] as product_embedding  FROM cymbal_products WHERE uniq_id='fd604542e04b470f9e6348e640cff794';
             uniq_id              | embedding |                       product_embedding                       
----------------------------------+-----------+---------------------------------------------------------------
 fd604542e04b470f9e6348e640cff794 |           | {0.015003494,-0.005349732,-0.059790313,-0.0087091,-0.0271452}
(1 row)

Time: 3.295 ms

8. Exécuter une recherche de similarités

Exécutez une recherche de similarité basée sur les embeddings vectoriels générés à l'aide d'AlloyDB AI.

La requête SQL peut être exécutée à partir de la même interface de ligne de commande psql ou, en alternative, à partir d'AlloyDB Studio. Les sorties complexes et sur plusieurs lignes sont plus adaptées à AlloyDB Studio.

Se connecter à AlloyDB Studio

Remarque : Dans les chapitres suivants, toutes les commandes SQL nécessitant une connexion à la base de données peuvent également être exécutées dans AlloyDB Studio.

Pour ouvrir AlloyDB Studio, procédez comme suit :

1. Dans la console Google Cloud, accédez à la page Clusters pour AlloyDB pour PostgreSQL.
2. Sélectionnez votre instance principale pour ouvrir son interface Web.

3. Cliquez ensuite sur AlloyDB Studio à gauche :

4. Sélectionnez la base de données quickstart_db, l'utilisateur postgres, saisissez le mot de passe indiqué, puis cliquez sur "Authenticate" (S'authentifier).

Cette action ouvre l'interface AlloyDB Studio.

5. Sélectionnez l'onglet "Requête sans titre" pour ouvrir l'éditeur SQL.

Un éditeur s'ouvre, dans lequel vous pouvez exécuter des commandes SQL, comme illustré dans l'image suivante :

Si vous préférez utiliser la ligne de commande psql, suivez l'autre méthode et connectez-vous à la base de données depuis la session SSH de votre VM, comme décrit dans les chapitres précédents.

Exécuter une recherche de similarités

Exécutez une requête pour obtenir la liste des produits disponibles qui correspondent le mieux à la demande d'un client. Expression de recherche transmise au modèle d'embedding sur Gemini Enterprise Agent Platform (la même que celle que nous avons utilisée pour générer des embeddings pour nos produits) afin d'obtenir la valeur vectorielle pour "Quels types d'arbres fruitiers poussent bien ici ?"

Exécutez la requête :

SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) as distance
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        distance ASC
LIMIT 10;

Voici le résultat attendu :

quickstart_db=> SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) as distance
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        distance ASC
LIMIT 10;
      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.43922018972266397
 Meyer Lemon Tree        | Meyer Lemon trees are California's favorite lemon tree! Grow your own lemons by  |         34 |    93230 |  0.4685112926118228
 Toyon                   | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e |      10.00 |    93230 |  0.4835677149651668
 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.4947204525907498
 California Peppertree   | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e |      25.00 |    93230 |  0.5054166905547247
 California Black Walnut | This is a beautiful walnut tree that can grow to be over 80 feet tall. It is a d |     100.00 |    93230 |  0.5084219510932597
 California Sycamore     | This is a beautiful sycamore tree that can grow to be over 100 feet tall. It is  |     300.00 |    93230 |  0.5140519790508755
 Coast Live Oak          | This is a beautiful oak tree that can grow to be over 100 feet tall. It is an ev |     500.00 |    93230 |  0.5143126438081371
 Fremont Cottonwood      | This is a beautiful cottonwood tree that can grow to be over 100 feet tall. It i |     200.00 |    93230 |  0.5174774727252058
 Madrone                 | This is a beautiful madrona tree that can grow to be over 80 feet tall. It is an |      50.00 |    93230 |  0.5227400803389093

Vous obtenez 10 produits dont les descriptions sont sémantiquement proches de l'expression de recherche, classés par distance, les plus similaires étant en haut de la liste.

9. Améliorer la réponse

Vous pouvez améliorer la réponse à une application cliente en utilisant le résultat de la requête et préparer une sortie pertinente en utilisant les résultats de la requête fournie dans le cadre du prompt à un modèle de langage génératif de base.

Pour ce faire, vous devez générer un fichier JSON contenant les meilleurs résultats de la recherche vectorielle, puis l'utiliser en complément d'un prompt adressé à un modèle d'IA générative dans Agent Platform afin de créer un résultat pertinent. La première étape génère le JSON, qui est ensuite testé dans Agent Platform Studio. La dernière étape consiste à tout intégrer dans une instruction SQL qui peut être utilisée dans une application.

Générer la sortie au format JSON

Modifiez la requête pour générer la sortie au format JSON et ne renvoyer qu'une seule ligne à transmettre à la plate-forme d'agents.

Exécutez la requête :

WITH trees as (
SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id as product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;

Le JSON dans le résultat :

[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]

Exécuter le prompt dans Vertex AI Studio

Utilisez le fichier JSON généré pour l'inclure dans le prompt du modèle d'IA générative dans Vertex AI Studio.

Ouvrez Gemini Enterprise Agent Platform Studio dans la console Google Cloud.

Rédigez votre requête dans l'interface :

Saisissez le prompt suivant :

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","description":"some description","sale_price":10,"zip_code": 10234, "produt_id": "02056727942aeb714dc9a2313654e1b0"}

Here is the list of products:

{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}

The customer asked "What tree is growing the best here?"

You should give information about the product, price and some supplemental information

Voici le résultat lorsque nous exécutons l'invite :

La réponse inclut le prix, la description et des informations supplémentaires que le modèle obtient de sources externes en fonction des informations sur l'arbre et l'emplacement.

Exécuter le prompt dans PSQL

Vous pouvez obtenir un résultat similaire en exécutant "Utiliser l'intégration AlloyDB AI avec Gemini Enterprise Agent Platform" pour obtenir la même réponse d'un modèle génératif à l'aide de SQL directement dans la base de données. Avant de pouvoir utiliser le modèle gemini-3.6-flash, vous devez l'enregistrer.

Enregistrez le modèle gemini-3.6-flash :

Veuillez remplacer les valeurs de l'espace réservé PROJECT_ID par l'ID de votre projet dans la commande suivante avant de l'exécuter.

Dans l'exécution AlloyDB Studio :

CALL google_ml.create_model(
model_id => 'gemini-3.6-flash',
model_request_url => 'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.6-flash:generateContent',
model_provider => 'google',
model_type => 'llm'
);

Vous pouvez toujours vérifier la liste des modèles enregistrés en sélectionnant des informations dans google_ml.model_info_view.

SELECT model_id,model_type FROM google_ml.model_info_view WHERE model_id ILIKE '%flash%';

Voici un exemple de résultat :

quickstart_db=> SELECT model_id,model_type FROM google_ml.model_info_view WHERE model_id ILIKE '%flash%';
       model_id        | model_type 
-----------------------+------------
 gemini-3.6-flash      | llm
 gemini-2.0-flash      | llm
 gemini-2.5-flash      | llm
 gemini-2.0-flash-lite | llm
 gemini-2.5-flash-lite | llm
(5 rows)

Vous pouvez désormais utiliser le JSON généré dans une sous-requête dans le prompt du modèle gemini-3.6-flash à l'aide de SQL.

Dans votre session psql ou AlloyDB Studio, exécutez la requête suivante :

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_inventory ci ON
        ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON
        cs.store_id = ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005',
        '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 =>'gemini-3.6-flash',
        request_body => json_build_object('contents',
        json_build_object('role',
        'user',
        'parts',
        json_build_object('text',
        prompt_text))))->'candidates'->0->'content'->'parts'->0->'text' AS resp
FROM
        prompt)
SELECT
REPLACE(resp::text, '\n', CHR(10))
FROM
        response;

Voici le résultat attendu. Le résultat peut être différent en raison de la nature non déterministe des modèles d'IA générative :

"Hello there! I'd be delighted to help you pick out a wonderful fruit tree for your space. Based on our local selection, a fantastic option that grows very well is the **Cherry Tree**! Here are the details on this beautiful tree: * **Product:** Cherry Tree * **Price:** $75.00 ### Why it's a great choice: * **Delicious Harvest:** It produces tasty, fresh cherries right in your backyard. * **Size & Benefits:** It's a deciduous tree that grows to about 15 feet tall, making it ideal for providing both lovely shade and a bit of privacy. * **Year-Round Beauty:** It features lush, dark green leaves throughout the summer that transform into a stunning red in the autumn. * **Growing Requirements:** Cherry trees thrive best in cool, moist climates with sandy soil, and are perfectly suited for USDA hardiness zones 4 through 9. Please let me know if you have any questions about planting or if you'd like help adding this to your order!"

10. Créer un index vectoriel

Comme cet ensemble de données est petit, les temps de réponse dépendent principalement des interactions avec les modèles sur Gemini Enterprise Agent Platform. Toutefois, lorsque vous interrogez des millions de vecteurs, la recherche vectorielle elle-même peut consommer une partie importante du temps de réponse et augmenter la charge sur votre base de données. Pour améliorer les performances de recherche, vous pouvez créer un index vectoriel.

Créer un index ScaNN

Pour créer un index ScaNN, vous devez activer une extension supplémentaire. L'extension alloydb_scann fournit une interface permettant d'utiliser des index vectoriels ANN (Approximate Nearest Neighbor) à l'aide de l'algorithme ScaNN de Google.

Exécuter dans AlloyDB Studio :

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

L'index peut être créé en mode MANUEL ou AUTO. Le mode MANUEL est activé par défaut. Vous pouvez créer un index et le gérer comme n'importe quel autre index. Toutefois, si vous activez le mode AUTO, vous pouvez créer l'index sans avoir à l'entretenir. Pour en savoir plus sur toutes les options, consultez la documentation. Nous ne disposons pas d'un nombre suffisant de lignes pour créer l'index en mode AUTO. Vous allez donc le créer en mode MANUAL.

Exécutez la commande dans AlloyDB Studio :

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

Pour en savoir plus sur l'ajustement des paramètres d'index, consultez la documentation.

Résultat attendu :

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

Comparer la réponse

Répétez la requête que nous avons utilisée pour obtenir la valeur la plus élevée dans la recherche sémantique :

WITH trees as (
SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id as product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;

Résultat attendu :

[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]

Le même "cerisier" dans le résultat.

Vérifiez l'utilisation de l'index :

EXPLAIN (analyze) 
WITH trees as (
SELECT
        cp.product_name,
        left(cp.product_description,80) as description,
        cp.sale_price,
        cs.zip_code,
        cp.uniq_id as product_id
FROM
        cymbal_products cp
JOIN cymbal_inventory ci on
        ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
        cs.store_id=ci.store_id
        AND ci.inventory>0
        AND cs.store_id = 1583
ORDER BY
        (cp.embedding <=> embedding('text-embedding-005','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;

Résultat attendu (masqué pour plus de clarté) :

...
 Aggregate  (cost=27.24..27.25 rows=1 width=32) (actual time=0.964..0.965 rows=1 loops=1)
   ->  Subquery Scan on trees  (cost=18.91..27.23 rows=1 width=142) (actual time=0.953..0.954 rows=1 loops=1)
         ->  Limit  (cost=18.91..27.22 rows=1 width=158) (actual time=0.948..0.949 rows=1 loops=1)
               ->  Nested Loop  (cost=18.91..7126.86 rows=855 width=158) (actual time=0.948..0.948 rows=1 loops=1)
                     ->  Nested Loop  (cost=18.63..7103.59 rows=855 width=907) (actual time=0.931..0.931 rows=1 loops=1)
                           ->  Index Scan using cymbal_products_embeddings_scann on cymbal_products cp  (cost=18.21..343.15 rows=942 width=903) (actual time=0.906..0.908 rows=2 loops=1)
                                 Order By: (embedding <=> '[-0.106554024,0.035774965,-0.027267234,-0.045653425,-0.03286045,0.02124319...

La sortie indique que la requête utilisait "Index Scan using cymbal_products_embeddings_scann on cymbal_products".

La requête renvoie le même cerisier qui s'affichait en haut de vos résultats de recherche avant que vous ne créiez l'index. Étant donné que les index ANN (Approximate Nearest Neighbor) privilégient la vitesse de recherche plutôt que la précision absolue, les requêtes basées sur des index peuvent parfois renvoyer des résultats principaux légèrement différents de ceux d'une recherche exacte non indexée. Toutefois, l'index vectoriel permet d'améliorer considérablement les performances tout en conservant une grande précision.

Pour aller plus loin, vous pouvez essayer d'autres types d'index vectoriels ou trouver d'autres ateliers et exemples avec l'intégration de LangChain sur la page de documentation.

11. Nettoyer l'environnement

Détruisez les instances et le cluster AlloyDB une fois l'atelier terminé.

Supprimer le cluster AlloyDB et toutes les instances

Si vous avez utilisé la version d'essai d'AlloyDB, ne supprimez pas le cluster d'essai si vous prévoyez de tester d'autres ateliers et ressources. Vous ne pourrez pas créer d'autre cluster d'essai dans le même projet.

Le cluster est détruit avec l'option force, qui supprime également toutes les instances appartenant au cluster.

Si votre terminal s'est déconnecté, reconnectez-vous et définissez les variables de projet et d'environnement dans Cloud Shell :

gcloud config set project <YOUR_PROJECT_ID>

export REGION=us-central1
export ADBCLUSTER=alloydb-aip-01
export PROJECT_ID=$(gcloud config get-value project)

Supprimez le cluster :

gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force

Remarque : L'exécution de la commande prend trois à cinq minutes.

Résultat attendu sur la console :

student@cloudshell:~ (test-project-001-402417)$ gcloud alloydb clusters delete $ADBCLUSTER --region=$REGION --force
All of the cluster data will be lost when the cluster is deleted.

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

Operation ID: operation-1697820178429-6082890a0b570-4a72f7e4-4c5df36f
Deleting cluster...done.   

Supprimer les sauvegardes AlloyDB

Supprimez toutes les sauvegardes AlloyDB du cluster :

Remarque : La commande détruira toutes les sauvegardes de données du cluster dont le nom est spécifié dans la variable d'environnement.

for i in $(gcloud alloydb backups list \
  --filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" \
  --format="value(name)" \
  --sort-by=~createTime) ; do \
  gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done

Résultat attendu sur la console :

student@cloudshell:~ (test-project-001-402417)$ for i in $(gcloud alloydb backups list --filter="CLUSTER_NAME: projects/$PROJECT_ID/locations/$REGION/clusters/$ADBCLUSTER" --format="value(name)" --sort-by=~createTime) ; do gcloud alloydb backups delete $(basename $i) --region $REGION --quiet; done
Operation ID: operation-1697826266108-60829fb7b5258-7f99dc0b-99f3c35f
Deleting backup...done.                                                                                                                                                                                                                                                            

Nous pouvons maintenant détruire notre VM.

Supprimer la VM GCE

Dans Cloud Shell, exécutez :

export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet

Résultat attendu sur la console :

student@cloudshell:~ (test-project-001-402417)$ export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet
Deleted 

12. Félicitations

Bravo ! Vous avez terminé cet atelier de programmation.

Cet atelier fait partie du parcours de formation "L'IA prête pour la production avec Google Cloud".

• Découvrez le programme complet pour combler l'écart entre le prototype et la production.
• Partagez votre progression avec le hashtag #ProductionReadyAI.

Points abordés

• Déployer un cluster AlloyDB et une instance principale
• Se connecter à AlloyDB à partir d'une VM Google Compute Engine
• Créer une base de données et activer AlloyDB AI
• Charger des données dans la base de données
• Utiliser AlloyDB Studio
• Utiliser le modèle d'embedding Gemini Enterprise Agent Platform dans AlloyDB
• Utiliser Gemini Enterprise Agent Platform Studio
• Enrichir les résultats à l'aide du modèle génératif Gemini Enterprise Agent Platform
• Améliorer les performances à l'aide de l'index vectoriel

13. Enquête

Résultat :

Comment allez-vous utiliser ce tutoriel ?

Je vais le lire uniquement Je vais le lire et effectuer les exercices