Application RAG agentive AlloyDB avec MCP Toolbox

1. Introduction

Dans cet atelier de programmation, vous allez apprendre à créer un cluster AlloyDB, à déployer la boîte à outils MCP et à la configurer pour utiliser AlloyDB comme source de données. Vous allez ensuite créer un exemple d'application RAG interactive qui utilise la boîte à outils déployée pour ancrer ses requêtes.

Pour en savoir plus sur la boîte à outils MCP, consultez la page de documentation et l'exemple d'application Cymbal Air ici.

Cet atelier fait partie d'une collection d'ateliers consacrés aux fonctionnalités d'IA d'AlloyDB. Pour en savoir plus, consultez la page AlloyDB AI dans la documentation et découvrez d'autres ateliers.

Prérequis

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

Points abordés

• Déployer un cluster AlloyDB avec l'intégration de Vertex AI
• Se connecter à AlloyDB
• Configurer et déployer le service MCP Toolbox
• Déployer un exemple d'application à l'aide du service déployé

Ce dont vous avez besoin

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

2. Préparation

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
• L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
• 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.

2. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'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 :

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 :

Veuillez noter que certaines ressources que vous activez entraîneront des frais si vous n'utilisez pas le niveau promotionnel. En temps normal, si toutes les ressources sont détruites à la fin de l'atelier, le coût de l'ensemble des ressources ne dépassera pas 5 $. Nous vous recommandons de vérifier la facturation et de vous assurer que cela vous convient.

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

Généralement, l'ID du projet est entre parenthèses dans l'invite de commande du Cloud Shell, comme indiqué sur l'image :

gcloud config set project [YOUR-PROJECT-ID]

Définissez ensuite la variable d'environnement PROJECT_ID sur l'ID de votre projet Google Cloud :

PROJECT_ID=$(gcloud config get-value project)

Activez tous les services nécessaires :

gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       vpcaccess.googleapis.com \
                       aiplatform.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       run.googleapis.com \
                       iam.googleapis.com \
                       secretmanager.googleapis.com

Résultat attendu

student@cloudshell:~ (gleb-test-short-004)$ gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       vpcaccess.googleapis.com \
                       aiplatform.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       run.googleapis.com \
                       iam.googleapis.com \
                       secretmanager.googleapis.com
Operation "operations/acf.p2-404051529011-664c71ad-cb2b-4ab4-86c1-1f3157d70ba1" finished successfully.

4. Déployer un cluster AlloyDB

Créez un cluster AlloyDB et une instance principale. La procédure suivante explique comment créer un cluster et une instance AlloyDB à l'aide du SDK Google Cloud. Si vous préférez utiliser la console, vous pouvez consulter la documentation sur cette page.

Avant de créer un cluster AlloyDB, nous avons besoin d'une plage d'adresses IP privées disponible dans notre VPC, qui sera utilisée par la future instance AlloyDB. Si nous ne l'avons pas, nous devons le créer et l'attribuer pour qu'il soit utilisé par les services Google internes. Nous pourrons ensuite 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ée pour travailler avec les services internes de Google.

Nous devons configurer l'accès au service privé dans notre VPC pour AlloyDB. L'hypothèse ici est que nous avons 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

Dans cette section, nous allons 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 12`

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. Je vous suggère de le noter ou de le copier quelque part pour pouvoir l'utiliser plus tard.

Résultat attendu sur la console :

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

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 la région et le nom du cluster AlloyDB. Nous allons utiliser la région us-central1 et alloydb-aip-01 comme nom de 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 le 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.

Définissez la région et le nom du cluster AlloyDB. Nous allons utiliser la région us-central1 et alloydb-aip-01 comme nom de 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 le 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.                                                                                                                                                                                                                                                     

Accorder les autorisations nécessaires à AlloyDB

Ajoutez des autorisations Vertex AI à 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

5. Préparer la machine virtuelle GCE

Nous allons utiliser une VM Google Compute Engine (GCE) comme plate-forme pour travailler avec la base de données et déployer différentes parties de l'exemple d'application. L'utilisation d'une VM nous offre plus de flexibilité en termes de composants installés et d'accès direct à l'adresse IP AlloyDB privée pour les étapes de préparation des données.

Créer un compte de service

Comme nous allons utiliser la VM pour déployer la boîte à outils MCP en tant que service et déployer ou héberger l'exemple d'application, la première étape consiste à créer un compte de service Google. Ce compte sera utilisé par la VM GCE, et nous devrons lui accorder les droits nécessaires pour fonctionner avec d'autres services.

Dans Cloud Shell, exécutez :

PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts create compute-aip --project $PROJECT_ID

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/cloudbuild.builds.editor"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/artifactregistry.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/storage.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/run.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/iam.serviceAccountUser"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/alloydb.viewer"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/alloydb.client"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/serviceusage.serviceUsageConsumer"

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/secretmanager.admin

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 :

ZONE=us-central1-a
PROJECT_ID=$(gcloud config get-value project)
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-12 AND family!=debian-12-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --service-account=compute-aip@$PROJECT_ID.iam.gserviceaccount.com

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ ZONE=us-central1-a
PROJECT_ID=$(gcloud config get-value project)
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-12 AND family!=debian-12-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --service-account=compute-aip@$PROJECT_ID.iam.gserviceaccount.com
Your active configuration is: [cloudshell-10282]
Created [https://www.googleapis.com/compute/v1/projects/gleb-test-short-002-470613/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.28.55.32
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 5.10.0-26-cloud-amd64 #1 SMP Debian 5.10.197-1 (2023-09-29) 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:4 file:/etc/apt/mirrors/debian-security.list Mirrorlist [39 B]
Hit:7 https://packages.cloud.google.com/apt google-compute-engine-bookworm-stable InRelease
Get:8 https://packages.cloud.google.com/apt cloud-sdk-bookworm InRelease [1652 B]
Get:2 https://deb.debian.org/debian bookworm InRelease [151 kB]
Get:3 https://deb.debian.org/debian bookworm-updates InRelease [55.4 kB]
...redacted...
update-alternatives: using /usr/share/postgresql/15/man/man1/psql.1.gz to provide /usr/share/man/man1/psql.1.gz (psql.1.gz) in auto mode
Setting up postgresql-client (15+248) ...
Processing triggers for man-db (2.11.2-2) ...
Processing triggers for libc-bin (2.36-9+deb12u7) ...

Se connecter à l'instance AlloyDB

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

Poursuivez la session SSH ouverte sur votre VM. Si vous avez été déconnecté, reconnectez-vous en utilisant la même commande que ci-dessus.

Utilisez le $PGASSWORD noté précédemment et le nom du cluster pour vous connecter à AlloyDB depuis la VM GCE :

export PGPASSWORD=<Noted password>

PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
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:~$ PROJECT_ID=$(gcloud config get-value project)
REGION=us-central1
ADBCLUSTER=alloydb-aip-01
INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"
psql (15.13 (Debian 15.13-0+deb12u1), server 16.8)
WARNING: psql major version 15, server major version 16.
         Some psql features might not work.
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off)
Type "help" for help.

postgres=>

Quittez la session psql en maintenant la connexion SSH active :

exit

Résultat attendu sur la console :

postgres=> exit
student@instance-1:~$ 

6. Initialiser la base de données

Nous allons utiliser la VM cliente comme plate-forme pour enrichir notre base de données et héberger notre application. La première étape consiste à créer une base de données et à l'enrichir.

Créer une base de données

Créez une base de données intitulée "assistantdemo".

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=<The noted AlloyDB password>

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" -c "CREATE DATABASE assistantdemo"  

Résultat attendu sur la console :

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

Préparer l'environnement Python

Pour continuer, nous allons utiliser des scripts Python préparés issus du dépôt GitHub, mais avant cela, nous devons installer le logiciel requis.

Dans la VM GCE, exécutez :

sudo apt install -y python3.11-venv git
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip

Résultat attendu sur la console :

student@instance-1:~$ sudo apt install -y python3.11-venv git
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
  git-man liberror-perl patch python3-distutils python3-lib2to3 python3-pip-whl python3-setuptools-whl
Suggested packages:
  git-daemon-run | git-daemon-sysvinit git-doc git-email git-gui gitk gitweb git-cvs git-mediawiki git-svn ed diffutils-doc
The following NEW packages will be installed:
  git git-man liberror-perl patch python3-distutils python3-lib2to3 python3-pip-whl python3-setuptools-whl python3.11-venv
0 upgraded, 9 newly installed, 0 to remove and 2 not upgraded.
Need to get 12.4 MB of archives.
After this operation, 52.2 MB of additional disk space will be used.
Get:1 file:/etc/apt/mirrors/debian.list Mirrorlist [30 B]
...redacted...
Installing collected packages: pip
  Attempting uninstall: pip
    Found existing installation: pip 23.0.1
    Uninstalling pip-23.0.1:
      Successfully uninstalled pip-23.0.1
Successfully installed pip-24.0
(.venv) student@instance-1:~$

Vérifiez la version de Python.

Dans la VM GCE, exécutez :

python -V

Résultat attendu sur la console :

(.venv) student@instance-1:~$ python -V
Python 3.11.2
(.venv) student@instance-1:~$ 

Installer la boîte à outils MCP en local

MCP Toolbox for Databases (ci-après "boîte à outils MCP" ou "boîte à outils") est un serveur MCP Open Source fonctionnant avec différentes sources de données. Il vous aide à développer des outils plus rapidement en fournissant un niveau d'abstraction pour différentes sources de données et en ajoutant des fonctionnalités telles que l'authentification et le regroupement de connexions. Pour en savoir plus sur toutes les fonctionnalités, consultez la page officielle.

Nous allons utiliser la boîte à outils MCP pour initialiser notre exemple d'ensemble de données, puis l'utiliser comme serveur MCP pour gérer les demandes de sources de données de notre application lors du flux de génération augmentée par récupération (RAG).

Installons la boîte à outils MCP en local pour remplir la base de données assistantdemo.

Dans la VM GCE, exécutez :

export VERSION=0.16.0
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox

Résultat attendu sur la console :

(.venv) student@instance-1:~$ export VERSION=0.16.0
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  133M  100  133M    0     0   158M      0 --:--:-- --:--:-- --:--:--  158M

Exécuter Toolbox pour l'initialisation des données

Dans la VM GCE, exécutez :

Remarque : Si votre session SSH a été interrompue en raison de l'inactivité ou pour toute autre raison, vous devez définir vos variables d'environnement. Par exemple :

export PGPASSWORD=<Noted password>

REGION=us-central1

ADBCLUSTER=alloydb-aip-01

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

Exportez les variables d'environnement pour le remplissage de la base de données :

export ALLOYDB_POSTGRES_PROJECT=$(gcloud config get-value project)
export ALLOYDB_POSTGRES_REGION="us-central1"
export ALLOYDB_POSTGRES_CLUSTER="alloydb-aip-01"
export ALLOYDB_POSTGRES_INSTANCE="alloydb-aip-01-pr"
export ALLOYDB_POSTGRES_DATABASE="assistantdemo"
export ALLOYDB_POSTGRES_USER="postgres"
export ALLOYDB_POSTGRES_PASSWORD=$PGPASSWORD
export ALLOYDB_POSTGRES_IP_TYPE="private"

Démarrez la boîte à outils pour l'initialisation de la base de données. Le processus démarrera en local, ce qui vous aidera à vous connecter facilement à la base de données de destination sur AlloyDB pour la remplir avec des exemples de données.

./toolbox --prebuilt alloydb-postgres

Résultat attendu sur la console. La dernière ligne du résultat doit indiquer "Server ready to serve!" (Serveur prêt à servir) :

student@instance-1:~$ cexport ALLOYDB_POSTGRES_PROJECT=$PROJECT_ID
export ALLOYDB_POSTGRES_REGION="us-central1"
export ALLOYDB_POSTGRES_CLUSTER="alloydb-aip-01"
export ALLOYDB_POSTGRES_INSTANCE="alloydb-aip-01-pr"
export ALLOYDB_POSTGRES_DATABASE="assistantdemo"
export ALLOYDB_POSTGRES_USER="postgres"
export ALLOYDB_POSTGRES_PASSWORD=$PGPASSWORD
export ALLOYDB_POSTGRES_IP_TYPE="private"
student@instance-1:~$ ./toolbox --prebuilt alloydb-postgres
2025-09-02T18:30:58.957655886Z INFO "Using prebuilt tool configuration for alloydb-postgres" 
2025-09-02T18:30:59.507306664Z INFO "Initialized 1 sources." 
2025-09-02T18:30:59.50748379Z INFO "Initialized 0 authServices." 
2025-09-02T18:30:59.507618807Z INFO "Initialized 2 tools." 
2025-09-02T18:30:59.507726704Z INFO "Initialized 2 toolsets." 
2025-09-02T18:30:59.508258894Z INFO "Server ready to serve!" 

Ne quittez pas ni ne fermez cet onglet Cloud Shell tant que le remplissage des données n'est pas terminé.

Enrichir la base de données

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

Connectez-vous à la VM instance-1 :

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
Linux instance-1 6.1.0-37-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) 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.
Last login: Tue Sep  2 21:44:07 2025 from 35.229.111.9
student@instance-1:~$ 

Clonez le dépôt GitHub avec le code du service de récupération et de l'exemple d'application.

Dans la VM GCE, exécutez :

git clone  https://github.com/GoogleCloudPlatform/cymbal-air-toolbox-demo.git

Résultat attendu sur la console :

student@instance-1:~$ git clone  https://github.com/GoogleCloudPlatform/cymbal-air-toolbox-demo.git
Cloning into 'cymbal-air-toolbox-demo'...
remote: Enumerating objects: 3481, done.
remote: Counting objects: 100% (47/47), done.
remote: Compressing objects: 100% (41/41), done.
remote: Total 3481 (delta 16), reused 7 (delta 5), pack-reused 3434 (from 3)
Receiving objects: 100% (3481/3481), 57.96 MiB | 6.04 MiB/s, done.
Resolving deltas: 100% (2549/2549), done.
student@instance-1:~

Veuillez faire attention si vous rencontrez des erreurs.

Préparez l'environnement Python et installez les packages requis :

source .venv/bin/activate
cd cymbal-air-toolbox-demo
pip install -r requirements.txt

Définissez le chemin d'accès Python sur le dossier racine du dépôt et exécutez le script pour remplir la base de données avec l'ensemble de données en exemple. La première commande ajoute un chemin d'accès à nos modules Python à notre environnement, et la seconde insère les données dans notre base de données.

export PYTHONPATH=$HOME/cymbal-air-toolbox-demo
python data/run_database_init.py

Résultat attendu sur la console(masqué). Le message "database init done" (initialisation de la base de données terminée) doit s'afficher à la fin :

student@instance-1:~$ source .venv/bin/activate
(.venv) student@instance-1:~$ 
(.venv) student@instance-1:~$ cd cymbal-air-toolbox-demo/
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ pip install -r requirements.txt
python run_database_init.py
Collecting fastapi==0.115.0 (from -r requirements.txt (line 1))
  Downloading fastapi-0.115.0-py3-none-any.whl.metadata (27 kB)
Collecting google-auth==2.40.3 (from -r requirements.txt (line 2))
  Downloading google_auth-2.40.3-py2.py3-none-any.whl.metadata (6.2 kB)
Collecting google-cloud-aiplatform==1.97.0 (from google-cloud-aiplatform[evaluation]==1.97.0->-r requirements.txt (line 3))
  Downloading google_cloud_aiplatform-1.97.0-py2.py3-none-any.whl.metadata (36 kB)
Collecting itsdangerous==2.2.0 (from -r requirements.txt (line 4))
  Downloading itsdangerous-2.2.0-py3-none-any.whl.metadata (1.9 kB)
Collecting jinja2==3.1.5 (from -r requirements.txt (line 5))
  Downloading jinja2-3.1.5-py3-none-any.whl.metadata (2.6 kB)
Collecting langchain-community==0.3.25 (from -r requirements.txt (line 6))
  Downloading langchain_community-0.3.25-py3-none-any.whl.metadata (2.9 kB)
Collecting langchain==0.3.25 (from -r requirements.txt (line 7))
...

(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ 
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ export PYTHONPATH=$HOME/cymbal-air-toolbox-demo
python data/run_database_init.py
Airports table initialized
Amenities table initialized
Flights table initialized
Tickets table initialized
Policies table initialized
database init done.
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$ 

Vous pouvez maintenant fermer cet onglet.

Dans la session de la VM, exécutez :

exit

Dans la session Cloud Shell, appuyez sur Ctrl+D ou exécutez :

exit

Dans le premier onglet avec la boîte à outils MCP en cours d'exécution, appuyez sur Ctrl+C pour quitter la session d'exécution de la boîte à outils.

La base de données a été remplie avec des exemples de données pour l'application.

Pour le vérifier, connectez-vous à la base de données et vérifiez le nombre de lignes dans la table "airports". Vous pouvez utiliser l'utilitaire psql comme nous l'avons fait précédemment ou AlloyDB Studio . Voici comment le vérifier à l'aide de psql.

Dans la session SSH de la VM instance-1, exécutez :

export PGPASSWORD=<Noted AlloyDB password>

REGION=us-central1
ADBCLUSTER=alloydb-aip-01
INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "SELECT COUNT(*) FROM airports"  

Résultat attendu sur la console :

student@instance-1:~$ REGION=us-central1
ADBCLUSTER=alloydb-aip-01
INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "SELECT COUNT(*) FROM airports"
 count 
-------
  7698
(1 row)

La base de données est prête. Nous pouvons passer au déploiement de MCP Toolbox.

7. Déployer la boîte à outils MCP sur Cloud Run

Nous pouvons maintenant déployer la MCP Toolbox sur Cloud Run. Il existe différentes manières de déployer la boîte à outils MCP. Le moyen le plus simple consiste à l'exécuter à partir de la ligne de commande, mais si nous voulons qu'il s'agisse d'un service évolutif et fiable, Cloud Run est une meilleure solution.

Préparer l'ID client

Pour utiliser la fonctionnalité de réservation de l'application, nous devons préparer un ID client OAuth 2.0 à l'aide de la console Cloud. Sans cela, nous ne pouvons pas nous connecter à l'application avec nos identifiants Google pour effectuer une réservation et l'enregistrer dans la base de données.

Dans la console Cloud, accédez à "API et services", puis cliquez sur "Écran de consentement OAuth". Voici un lien vers la page. La page de présentation d'OAuth s'ouvre. Cliquez sur "Get Started" (Commencer).

Sur la page suivante, nous indiquons le nom de l'application et l'adresse e-mail de l'assistance utilisateur, puis nous cliquons sur "Suivant".

Sur l'écran suivant, sélectionnez "Interne" pour votre application, puis cliquez de nouveau sur "Suivant".

Ensuite, nous fournissons à nouveau une adresse e-mail de contact et cliquons sur "Suivant".

Nous acceptons ensuite les règles des services d'API Google et cliquons sur le bouton "Créer".

Nous serons redirigés vers la page où nous pourrons créer un client OAuth.

Sur l'écran, nous sélectionnons "Application Web" dans le menu déroulant, saisissons "Cymbal Air" comme application, puis cliquons sur le bouton "Ajouter un URI".

Les URI représentent des sources fiables pour l'application et dépendent de l'endroit à partir duquel vous essayez d'accéder à l'application. Nous avons défini "http://localhost:8081" comme URI autorisé et "http://localhost:8081/login/google" comme URI de redirection. Ces valeurs fonctionneraient si vous saisissiez "http://localhost:8081" dans votre navigateur en tant qu'URI de connexion. Par exemple, lorsque vous vous connectez via un tunnel SSH depuis votre ordinateur. Je vous montrerai comment faire plus tard.

Après avoir cliqué sur le bouton "Créer", une fenêtre pop-up contenant les identifiants de vos clients s'affiche. Les identifiants seront enregistrés dans le système. Vous pouvez toujours copier l'ID client à utiliser lorsque vous démarrez votre application.

Vous verrez plus tard où fournir cet ID client.

Créer un compte de service

Nous avons besoin d'un compte de service dédié pour notre service Cloud Run, avec tous les privilèges requis. Pour notre service, nous avons besoin d'accéder à AlloyDB et à Cloud Secret Manager. Pour le nom du compte de service, nous allons utiliser "toolbox-identity".

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

Dans le nouvel onglet Cloud Shell, exécutez :

export PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts create toolbox-identity

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/alloydb.client"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/serviceusage.serviceUsageConsumer"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

Veuillez faire attention si vous rencontrez des erreurs. La commande est censée créer un compte de service pour le service Cloud Run et accorder des droits d'accès pour utiliser Secret Manager, la base de données et Vertex AI.

Fermez l'onglet en appuyant sur Ctrl+D ou en exécutant la commande "exit" dans l'onglet :

exit

Préparer la configuration de la boîte à outils MCP

Préparez le fichier de configuration pour la boîte à outils MCP. Vous trouverez toutes les options de configuration dans la documentation. Toutefois, nous allons utiliser ici l'exemple de fichier tools.yaml et remplacer certaines valeurs telles que le nom du cluster et de l'instance, le mot de passe AlloyDB et l'ID du projet par nos valeurs réelles.

Exporter le mot de passe AlloyDB :

export PGPASSWORD=<noted AlloyDB password>

Exportez l'ID client que nous avons préparé à l'étape précédente :

export CLIENT_ID=<noted OAuth 2.0 client ID for our application>

Préparez le fichier de configuration.

PROJECT_ID=$(gcloud config get-value project)
ADBCLUSTER=alloydb-aip-01
sed -e "s/project: retrieval-app-testing/project: $(gcloud config get-value project)/g" \
-e "s/cluster: my-alloydb-cluster/cluster: $ADBCLUSTER/g" \
-e "s/instance: my-alloydb-instance/instance: $ADBCLUSTER-pr/g" \
-e "s/password: postgres/password: $PGPASSWORD\\n    ipType: private/g" \
-e "s/^ *clientId: .*/    clientId: $CLIENT_ID/g" \
cymbal-air-toolbox-demo/tools.yaml >~/tools.yaml

Si vous examinez la section du fichier qui définit la source de données cible, vous verrez que nous avons également ajouté une ligne pour utiliser une adresse IP privée pour la connexion.

sources:
  my-pg-instance:
    kind: alloydb-postgres
    project: gleb-test-short-003-471020
    region: us-central1
    cluster: alloydb-aip-01
    instance: alloydb-aip-01-pr
    database: assistantdemo
    user: postgres
    password: L23F...
    ipType: private
authServices:
  my_google_service:
    kind: google
    clientId: 96828*******-***********.apps.googleusercontent.com

Créez un secret à l'aide de la configuration tools.yaml comme source.

Dans la console SSH de la VM, exécutez :

gcloud secrets create tools --data-file=tools.yaml

Résultat attendu sur la console :

student@instance-1:~$ gcloud secrets create tools --data-file=tools.yaml
Created version [1] of the secret [tools].

Déployer la boîte à outils MCP en tant que service Cloud Run

Tout est maintenant prêt pour déployer la boîte à outils MCP en tant que service sur Cloud Run. Pour les tests locaux, vous pouvez exécuter "./toolbox –tools-file=./tools.yaml". Toutefois, si vous souhaitez que votre application s'exécute dans le cloud, le déploiement dans Cloud Run est beaucoup plus judicieux.

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

export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest
gcloud run deploy toolbox \
    --image $IMAGE \
    --service-account toolbox-identity \
    --region us-central1 \
    --set-secrets "/app/tools.yaml=tools:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
    --network default \
    --subnet default \
    --no-allow-unauthenticated

Résultat attendu sur la console :

student@instance-1:~$ export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest
gcloud run deploy toolbox \
    --image $IMAGE \
    --service-account toolbox-identity \
    --region us-central1 \
    --set-secrets "/app/tools.yaml=tools:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
    --network default \
    --subnet default \
    --no-allow-unauthenticated
Deploying container to Cloud Run service [toolbox] in project [gleb-test-short-002-470613] region [us-central1]
✓ Deploying new service... Done.                                                                                                                                                                                                
  ✓ Creating Revision...                                                                                                                                                                                                        
  ✓ Routing traffic...                                                                                                                                                                                                          
Done.                                                                                                                                                                                                                           
Service [toolbox] revision [toolbox-00001-l9c] has been deployed and is serving 100 percent of traffic.
Service URL: https://toolbox-868691532292.us-central1.run.app

student@instance-1:~$

Vérifier le service

Nous pouvons maintenant vérifier si le service est opérationnel et si nous pouvons accéder au point de terminaison. Nous utilisons l'utilitaire gcloud pour obtenir le point de terminaison du service de récupération et le jeton d'authentification. Vous pouvez également vérifier l'URI du service dans la console Cloud.

Vous pouvez copier la valeur et remplacer la partie "$(gcloud run services list –filter="(toolbox)" –format="value(URL)" dans la commande curl .

Voici comment obtenir l'URL de manière dynamique à partir de la ligne de commande :

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $(gcloud  run services list --filter="(toolbox)" --format="value(URL)")

Résultat attendu sur la console :

student@instance-1:~$ curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $(gcloud  run services list --filter="(toolbox)" --format="value(URL)")
🧰 Hello, World! 🧰student@instance-1:~$

Si le message "Hello World" s'affiche, cela signifie que le service est opérationnel et traite les requêtes.

8. Déployer un exemple d'application

Maintenant que le service de récupération est opérationnel, nous pouvons déployer un exemple d'application. L'application représente un assistant aéroportuaire en ligne qui peut vous fournir des informations sur les vols et les aéroports, et même réserver un vol en fonction des données sur les vols et les aéroports de notre base de données.

L'application peut être déployée localement, sur une VM dans le cloud ou sur n'importe quel autre service comme Cloud Run ou Kubernetes. Nous allons d'abord voir comment la déployer sur la VM.

Préparer l'environnement

Nous continuons à travailler sur notre VM en utilisant la même session SSH. Pour exécuter notre application, nous avons besoin de certains modules Python. Nous les avons déjà ajoutés lorsque nous avons initialisé notre base de données plus tôt. Passons à notre environnement virtuel Python et changeons de répertoire pour accéder à celui de l'application.

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

source ~/.venv/bin/activate
cd cymbal-air-toolbox-demo

Résultat attendu (masqué) :

student@instance-1:~$ source ~/.venv/bin/activate
cd cymbal-air-toolbox-demo
(.venv) student@instance-1:~/cymbal-air-toolbox-demo$

Exécuter l'application Assistant

Avant de démarrer l'application, nous devons configurer certaines variables d'environnement. Les fonctionnalités de base de l'application, telles que l'interrogation des vols et des services aéroportuaires, ne nécessitent que TOOLBOX_URL, qui redirige l'application vers le service de récupération. Nous pouvons l'obtenir à l'aide de la commande gcloud .

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

export TOOLBOX_URL=$(gcloud  run services list --filter="(toolbox)" --format="value(URL)")

Résultat attendu (masqué) :

student@instance-1:~/cymbal-air-toolbox-demo$ export BASE_URL=$(gcloud  run services list --filter="(toolbox)" --format="value(URL)")

Pour utiliser des fonctionnalités plus avancées de l'application, comme la réservation et la modification de vols, nous devons nous connecter à l'application à l'aide de notre compte Google. Pour ce faire, nous devons fournir la variable d'environnement CLIENT_ID en utilisant l'ID client OAuth du chapitre "Préparer l'ID client" :

export CLIENT_ID=215....apps.googleusercontent.com

Résultat attendu (masqué) :

student@instance-1:~/cymbal-air-toolbox-demo$ export CLIENT_ID=215....apps.googleusercontent.com

Nous pouvons maintenant exécuter notre application :

python run_app.py

Résultat attendu :

student@instance-1:~/cymbal-air-toolbox-demo/llm_demo$ python run_app.py
INFO:     Started server process [2900]
INFO:     Waiting for application startup.
Loading application...
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8081 (Press CTRL+C to quit)

Se connecter à l'application

Vous avez plusieurs façons de vous connecter à l'application exécutée sur la VM. Par exemple, vous pouvez ouvrir le port 8081 sur la VM en utilisant les règles de pare-feu dans le VPC ou créer un équilibreur de charge avec une adresse IP publique. Dans le cas présent, nous allons utiliser un tunnel SSH vers la VM en remplaçant le port 8080 local par le port 8081 de la VM.

Se connecter depuis une machine locale

Lorsque nous souhaitons nous connecter à partir d'une machine locale, nous devons exécuter un tunnel SSH. Vous pouvez le faire à l'aide de gcloud compute ssh :

gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8081:localhost:8081

Résultat attendu :

student-macbookpro:~ student$ gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081
Warning: Permanently added 'compute.7064281075337367021' (ED25519) to the list of known hosts.
Linux instance-1.us-central1-c.c.gleb-test-001.internal 6.1.0-21-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.90-1 (2024-05-03) 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:~$

Nous pouvons maintenant ouvrir le navigateur et utiliser http://localhost:8081 pour nous connecter à notre application. L'écran de l'application devrait s'afficher.

Se connecter depuis Cloud Shell

Vous pouvez également utiliser Google Cloud Shell pour vous connecter. Ouvrez un autre onglet Cloud Shell à l'aide du signe "+" situé en haut.

Dans le nouvel onglet, obtenez l'URI d'origine et de redirection pour votre client Web en exécutant la commande gcloud :

echo "origin:"; echo "https://8080-$WEB_HOST"; echo "redirect:"; echo "https://8080-$WEB_HOST/login/google"

Voici le résultat attendu :

student@cloudshell:~ echo "origin:"; echo "https://8080-$WEB_HOST"; echo "redirect:"; echo "https://8080-$WEB_HOST/login/google"
origin:
https://8080-cs-35704030349-default.cs-us-east1-rtep.cloudshell.dev
redirect:
https://8080-cs-35704030349-default.cs-us-east1-rtep.cloudshell.dev/login/google

Utilisez l'origine et la redirection des URI comme Origines JavaScript autorisées et URI de redirection autorisés pour nos identifiants créés dans le chapitre "Préparer l'ID client", en remplaçant ou en ajoutant les valeurs http://localhost:8080 fournies à l'origine.

Cliquez sur "Cymbal Air" sur la page des ID client OAuth 2.0.

Saisissez les URI d'origine et de redirection pour Cloud Shell, puis cliquez sur le bouton "Enregistrer".

Dans le nouvel onglet Cloud Shell, démarrez le tunnel vers votre VM en exécutant la commande gcloud :

gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081

Le message d'erreur "Impossible d'attribuer l'adresse demandée" s'affiche. Veuillez l'ignorer.

Voici le résultat attendu :

student@cloudshell:~ gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081
bind [::1]:8081: Cannot assign requested address
inux instance-1.us-central1-a.c.gleb-codelive-01.internal 6.1.0-21-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.90-1 (2024-05-03) 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.
Last login: Sat May 25 19:15:46 2024 from 35.243.235.73
student@instance-1:~$

Il ouvre le port 8080 dans Cloud Shell, qui peut être utilisé pour l'aperçu sur le Web.

Cliquez sur le bouton "Aperçu sur le Web" en haut à droite de votre Cloud Shell, puis sélectionnez "Prévisualiser sur le port 8080" dans le menu déroulant.

Un nouvel onglet affichant l'interface de l'application s'ouvre dans votre navigateur Web. La page "Assistant du service client Cymbal Air" devrait s'afficher.

Se connecter à l'application

Une fois que tout est configuré et que votre application est ouverte, nous pouvons utiliser le bouton "Se connecter" en haut à droite de l'écran de l'application pour fournir nos identifiants. Cette étape est facultative et n'est requise que si vous souhaitez essayer la fonctionnalité de réservation de l'application.

Une fenêtre pop-up s'ouvre, dans laquelle nous pouvons choisir nos identifiants.

Une fois connecté, l'application est prête et vous pouvez commencer à saisir vos requêtes dans le champ au bas de la fenêtre.

Cette démo présente l'assistant du service client Cymbal Air. Cymbal Air est une compagnie aérienne fictive. L'assistant est un chatbot basé sur l'IA, qui aide les voyageurs à gérer leurs vols et à rechercher des informations sur le hub Cymbal Air de l'aéroport international de San Francisco (SFO).

Sans vous connecter (sans CLIENT_ID), il peut vous aider à répondre à ce type de questions :

Quand est le prochain vol pour Denver ?

Y a-t-il des boutiques de luxe aux environs de la porte C28 ?

Où puis-je prendre un café près de la porte A6 ?

Où puis-je acheter un cadeau ?

Trouve-moi un vol de SFO à Denver qui part aujourd'hui.

Une fois connecté à l'application, vous pouvez essayer d'autres fonctionnalités, comme réserver des vols ou vérifier si le siège qui vous a été attribué est côté hublot ou côté couloir.

L'application utilise les derniers modèles de fondation de Google pour générer des réponses et l'enrichir avec des informations sur les vols et services issues de la base de données opérationnelle AlloyDB. Pour en savoir plus sur cette application de démonstration, consultez la page GitHub du projet.

9. Nettoyer l'environnement

Maintenant que toutes les tâches sont terminées, nous pouvons nettoyer notre environnement.

Supprimer le service Cloud Run

Dans Cloud Shell, exécutez :

gcloud run services delete toolbox --region us-central1

Résultat attendu sur la console :

student@cloudshell:~ (gleb-test-short-004)$ gcloud run services delete retrieval-service --region us-central1
Service [retrieval-service] will be deleted.

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

Deleting [retrieval-service]...done.                                                                                                                                                                                                                 
Deleted service [retrieval-service].

Supprimez le compte de service pour le service Cloud Run.

Dans Cloud Shell, exécutez :

PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com --quiet

Résultat attendu sur la console :

student@cloudshell:~ (gleb-test-short-004)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-222]
student@cloudshell:~ (gleb-test-short-004)$ gcloud iam service-accounts delete retrieval-identity@$PROJECT_ID.iam.gserviceaccount.com --quiet
deleted service account [[e-mail]]
student@cloudshell:~ (gleb-test-short-004)$

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 à l'aide de ce cluster. 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.

Dans Cloud Shell, définissez le projet et les variables d'environnement si vous avez été déconnecté et que tous les paramètres précédents sont perdus :

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 

Supprimez le compte de service pour la VM GCE et le service de récupération.

Dans Cloud Shell, exécutez :

PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete compute-aip@$PROJECT_ID.iam.gserviceaccount.com --quiet

Résultat attendu sur la console :

student@cloudshell:~ (gleb-test-short-004)$ PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete compute-aip@$PROJECT_ID.iam.gserviceaccount.com --quiet
Your active configuration is: [cloudshell-222]
deleted service account [[e-mail]]
student@cloudshell:~ (gleb-test-short-004)$ 

10. Félicitations

Bravo ! Vous avez terminé cet atelier de programmation.

Points abordés

• Déployer un cluster AlloyDB
• Se connecter à AlloyDB
• Configurer et déployer le service MCP Toolbox
• Déployer un exemple d'application à l'aide du service déployé

11. Enquête

Résultat :

Comment allez-vous utiliser ce tutoriel ?

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