Créer une application de chat basée sur un LLM et une RAG à l'aide de bases de données Cloud SQL et de LangChain

1. Introduction

Dans cet atelier de programmation, vous allez apprendre à déployer le service de récupération de bases de données par IA générative et à créer un exemple d'application interactive à l'aide du service déployé.

8727a44c8c402834.png

Pour en savoir plus sur le service de récupération par IA générative et sur l'exemple d'application, cliquez ici.

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

  • Créer une instance Cloud SQL
  • Se connecter à l'instance
  • Configurer et déployer le service de récupération de bases de données par IA générative
  • 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.

fbef9caa1602edd0.png

a99b7ace416376c4.png

5e3ff691252acf41.png

  • 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.
  1. 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 :

55efc1aaa7a4d3ad.png

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

7ffe5cbb04455448.png

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

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 :

fa6ee779963405d5.png

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

Résultat attendu sur la console :

student@cloudshell:~ (gleb-test-short-004)$ gcloud services enable sqladmin.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
Operation "operations/acf.p2-404051529011-664c71ad-cb2b-4ab4-86c1-1f3157d70ba1" finished successfully.

4. Créer une instance Cloud SQL

Créez une instance Cloud SQL avec la prise en charge des vecteurs activée.

Créer un mot de passe

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

export CLOUDSQL_PASSWORD=`openssl rand -hex 12`

Notez la valeur générée pour le mot de passe.

echo $CLOUDSQL_PASSWORD

MySQL

Vous pouvez activer le flag cloudsql_vector lors de la création de l'instance. Actuellement, la prise en charge des vecteurs est proposée dans MySQL 8.0.36 et 8.0.37.

export region=us-central1
gcloud sql instances create my-cloudsql-instance --region=$region --database-version=MYSQL_8_0_36 --database-flags=cloudsql_vector=ON --root-password=$CLOUDSQL_PASSWORD

Résultat attendu sur la console (adresse IP masquée) :

student@cloudshell:~ export region=us-central1
gcloud sql instances create my-cloudsql-instance --region=$region --database-version=MYSQL_8_0_36 --database-flags=cloudsql_vector=ON --root-password=$CLOUDSQL_PASSWORD
Creating Cloud SQL instance for MYSQL_8_0_36...done.                                                                                                                                 
Created [https://sqladmin.googleapis.com/sql/v1beta4/projects/test-project-402417/instances/my-cloudsql-instance].
NAME                   DATABASE_VERSION  LOCATION       TIER             PRIMARY_ADDRESS  PRIVATE_ADDRESS  STATUS
my-cloudsql-instance  MYSQL_8_0_36      us-central1-a  db-n1-standard-1  00.000.00.00   -                RUNNABLE

PostgreSQL

L'extension pgvector est proposée dans les versions >= 11.

export region=us-central1
gcloud sql instances create my-cloudsql-instance --region=$region --database-version=POSTGRES_15 --tier=db-g1-small

Résultat attendu sur la console (adresse IP masquée) :

student@cloudshell:~ export region=us-central1
gcloud sql instances create my-cloudsql-instance --region=$region --database-version=POSTGRES_15 --tier=db-g1-small
Creating Cloud SQL instance for POSTGRES_15...done.                                                                                                                                  
Created [https://sqladmin.googleapis.com/sql/v1beta4/projects/test-project-402417/instances/my-cloudsql-instance].
NAME                   DATABASE_VERSION  LOCATION       TIER         PRIMARY_ADDRESS  PRIVATE_ADDRESS  STATUS
my-cloudsql-instance  POSTGRES_15       us-central1-a  db-g1-small  00.000.00.00     -                RUNNABLE

Après avoir créé l'instance, nous devons définir un mot de passe pour l'utilisateur par défaut de l'instance et vérifier si nous pouvons nous connecter avec ce mot de passe. Saisissez votre mot de passe dans l'invite lorsqu'il est prêt à se connecter.

gcloud sql users set-password postgres \
    --instance=my-cloudsql-instance \
    --password=$CLOUDSQL_PASSWORD
gcloud sql connect my-cloudsql-instance --user=postgres

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ gcloud sql users set-password postgres \
    --instance=my-cloudsql-instance \
    --password=$CLOUDSQL_PASSWORD
gcloud sql connect my-cloudsql-instance --user=postgres
Updating Cloud SQL user...done.                                                                                                                                                                                                                                            
Allowlisting your IP for incoming connection for 5 minutes...done.                                                                                                                                                                                                         
Connecting to database with SQL user [postgres].Password: 
psql (16.3 (Ubuntu 16.3-1.pgdg22.04+1), server 15.7)
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off)
Type "help" for help.

postgres=>

Quittez la session psql :

exit

5. Préparer la machine virtuelle GCE

Créer un compte de service

Comme nous allons utiliser la VM pour déployer le service de récupération de bases de données par IA générative et héberger un 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/cloudsql.viewer"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

Déployer une VM GCE

Créez une VM GCE dans la même région et le même VPC que l'instance Cloud SQL.

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-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)$ export ZONE=us-central1-a
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-12 AND family!=debian-12-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

Autoriser la VM à se connecter à Cloud SQL

Nous devons ajouter l'adresse IP publique de notre VM à la liste des réseaux autorisés pour notre instance Cloud SQL. Dans Cloud Shell, exécutez :

VM_EXTERNAL_IP=$(gcloud compute instances describe instance-1 --zone=us-central1-a --format='get(networkInterfaces[0].accessConfigs[0].natIP)')
gcloud sql instances patch my-cloudsql-instance --authorized-networks=$VM_EXTERNAL_IP

Résultat attendu sur la console :

student@cloudshell:~ (test-project-402417)$ export ZONE=us-central1-a
student@cloudshell:~ (test-project-402417)$ VM_EXTERNAL_IP=$(gcloud compute instances describe instance-1 --zone=us-central1-a --format='get(networkInterfaces[0].accessConfigs[0].natIP)')
gcloud sql instances patch my-cloudsql-instance --authorized-networks=$VM_EXTERNAL_IP
When adding a new IP address to authorized networks, make sure to also include any IP addresses that have already been authorized. Otherwise, they will be overwritten and de-authorized.

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

The following message will be used for the patch API method.
{"name": "my-cloudsql-instance", "project": "test-project-402417", "settings": {"ipConfiguration": {"authorizedNetworks": [{"value": "34.71.252.173"}]}}}
Patching Cloud SQL instance...done.                                                                                                                                                                                     
Updated [https://sqladmin.googleapis.com/sql/v1beta4/projects/test-project-402417/instances/my-cloudsql-instance].

Installer le client de base de données

MySQL

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

Connectez-vous à la VM.

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 default-mysql-client

Résultat attendu sur la console :

student@instance-1:~$ sudo apt-get update
sudo apt-get install --yes mysql-client
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
  libconfig-inifiles-perl libdbd-mariadb-perl libdbi-perl libgdbm-compat4 libperl5.32 libterm-readkey-perl mariadb-client-10.5 mariadb-client-core-10.5 perl perl-modules-5.32
Suggested packages:
  libclone-perl libmldbm-perl libnet-daemon-perl libsql-statement-perl perl-doc libterm-readline-gnu-perl | libterm-readline-perl-perl make libtap-harness-archive-perl
The following NEW packages will be installed:
  default-mysql-client libconfig-inifiles-perl libdbd-mariadb-perl libdbi-perl libgdbm-compat4 libperl5.32 libterm-readkey-perl mariadb-client-10.5 mariadb-client-core-10.5 perl
  Perl-modules-5.32
...redacted...
Processing triggers for libc-bin (2.31-13+deb11u10) ...

PostgreSQL

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

Connectez-vous à la VM.

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

MySQL

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

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 $CLOUDSQL_PASSWORD noté précédemment et le nom de l'instance pour vous connecter à Cloud SQL depuis la VM GCE :

export CLOUDSQL_PASSWORD=<Noted password>

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export INSTANCE_NAME=my-cloudsql-instance
export INSTANCE_IP=$(gcloud sql instances list --filter=name:$INSTANCE_NAME --format="value(PRIMARY_ADDRESS)")
mysql --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD

Résultat attendu sur la console :

student@instance-1:~$ export CLOUDSQL_PASSWORD=P9...
student@instance-1:~$ export REGION=us-central1
student@instance-1:~$ export INSTANCE_NAME=my-cloud-sql-instance
student@instance-1:~$ export INSTANCE_IP=$(gcloud sql instances list --filter=name:$INSTANCE_NAME --format="value(PRIMARY_ADDRESS)")
student@instance-1:~$ mysql  –host=$INSTANCE_IP –user=root –password=$CLOUDSQL_PASSWORD –sslmode=require 
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MySQL connection id is 2824706
Server version: 8.0.36-google (Google)

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MySQL [(none)]>

Quittez la session MySQL en maintenant la connexion SSH active :

exit

Résultat attendu sur la console :

MySQL [(none)]> exit
Bye
student@instance-1:~$

PostgreSQL

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 $CLOUDSQL_PASSWORD noté précédemment et le nom de l'instance pour vous connecter à PostgreSQL depuis la VM GCE :

export PGPASSWORD=<Noted password (CLOUDSQL_PASSWORD)>
export CLOUDSQL_PASSWORD=$PGPASSWORD

export PROJECT_ID=$(gcloud config get-value project)
export REGION=us-central1
export INSTANCE_NAME=my-cloudsql-instance
export INSTANCE_IP=$(gcloud sql instances list --filter=name:$INSTANCE_NAME --format="value(PRIMARY_ADDRESS)")
psql "host=$INSTANCE_IP user=postgres sslmode=require"

Résultat attendu sur la console :

student@instance-1:~$ export CLOUDSQL_PASSWORD=P9...
student@instance-1:~$ export REGION=us-central1
student@instance-1:~$ export INSTANCE_IP=$(gcloud sql instances list --filter=name:$INSTANCE_NAME --format="value(PRIMARY_ADDRESS)")
student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres sslmode=require"
psql (13.11 (Debian 13.11-0+deb11u1), server 14.7)
WARNING: psql major version 13, server major version 14.
         Some psql features might not work.
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, 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

MySQL

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

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

mysql --host=$INSTANCE_IP  --user=root --password=$CLOUDSQL_PASSWORD -e "CREATE DATABASE assistantdemo"

Résultat attendu sur la console (aucune sortie) :

student@instance-1:~$ mysql --host=$INSTANCE_IP  --user=root --password=$CLOUDSQL_PASSWORD -e "CREATE DATABASE assistantdemo"
student@instance-1:~$

PostgreSQL

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

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

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

Activez l'extension pgvector.

psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "CREATE EXTENSION vector"

Résultat attendu sur la console (aucune sortie) :

student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "CREATE EXTENSION vector"
CREATE EXTENSION
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:~$

Préparer le fichier de configuration

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/genai-databases-retrieval-app.git

Résultat attendu sur la console :

student@instance-1:~$ git clone https://github.com/GoogleCloudPlatform/genai-databases-retrieval-app.git
Cloning into 'genai-databases-retrieval-app'...
remote: Enumerating objects: 525, done.
remote: Counting objects: 100% (336/336), done.
remote: Compressing objects: 100% (201/201), done.
remote: Total 525 (delta 224), reused 179 (delta 135), pack-reused 189
Receiving objects: 100% (525/525), 46.58 MiB | 16.16 MiB/s, done.
Resolving deltas: 100% (289/289), done.

MySQL

Dans la VM GCE, exécutez :

cd ~/genai-databases-retrieval-app/retrieval_service
cp example-config-cloudsql.yml config.yml
cp example-config-cloudsql.yml config.yml
sed -i s/engine/mysql/g config.yml
sed -i s/my-project/$PROJECT_ID/g config.yml
sed -i s/my-region/$REGION/g config.yml
sed -i s/my-instance/$INSTANCE_NAME/g config.yml
sed -i s/my-password//g config.yml
sed -i s/my_database/assistantdemo/g config.yml
sed -i s/my-user/root/g config.yml
cat config.yml

Résultat attendu sur la console :

student@instance-1:~$ cd genai-databases-retrieval-app/retrieval_service
cp example-config-cloudsql.yml config.yml
sed -i s/127.0.0.1/$INSTANCE_IP/g config.yml
sed -i s/my-password/$CLOUDSQL_PASSWORD/g config.yml
sed -i s/my_database/assistantdemo/g config.yml
sed -i s/my-user/postgres/g config.yml
cat config.yml
host: 0.0.0.0
# port: 8080
datastore:
  # Example for MySQL
  kind: "cloudsql-mysql"
  host: 10.65.0.2
  # port: 5432
  database: "assistantdemo"
  user: "root"
  password: "P9..."

Postgres

Dans la VM GCE, exécutez :

cd ~/genai-databases-retrieval-app/retrieval_service
cp example-config-cloudsql.yml config.yml
sed -i s/engine/postgres/g config.yml
sed -i s/my-project/$PROJECT_ID/g config.yml
sed -i s/my-region/$REGION/g config.yml
sed -i s/my-instance/$INSTANCE_NAME/g config.yml
sed -i s/my-password/$PGPASSWORD/g config.yml
sed -i s/my_database/assistantdemo/g config.yml
sed -i s/my-user/postgres/g config.yml
cat config.yml

Résultat attendu sur la console :

student@instance-1:~$ cd genai-databases-retrieval-app/retrieval_service
cp example-config-cloudsql.yml config.yml
sed -i s/engine/postgres/g config.yml
sed -i s/my-project/$PROJECT_ID/g config.yml
sed -i s/my-region/$REGION/g config.yml
sed -i s/my-instance/$INSTANCE_NAME/g config.yml
sed -i s/my-password/$CLOUDSQL_PASSWORD/g config.yml
sed -i s/my_database/assistantdemo/g config.yml
sed -i s/my-user/postgres/g config.yml
cat config.yml
host: 0.0.0.0
# port: 8080
datastore:
  # Example for Postgres
  kind: "cloudsql-postgres"
  host: 10.65.0.2
  # port: 5432
  database: "assistantdemo"
  user: "postgres"
  password: "P9..."

Enrichir la base de données

Enrichissez la base de données avec l'ensemble de données en exemple. La première commande ajoute tous les packages requis à notre environnement virtuel Python, et la seconde insère les données dans notre base de données.

Dans la VM GCE, exécutez :

cd ~/genai-databases-retrieval-app/retrieval_service
pip install -r requirements.txt
python run_database_init.py

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

student@instance-1:~/genai-databases-retrieval-app/retrieval_service$ pip install -r requirements.txt
python run_database_init.py
Collecting asyncpg==0.28.0 (from -r requirements.txt (line 1))
  Obtaining dependency information for asyncpg==0.28.0 from https://files.pythonhosted.org/packages/77/a4/88069f7935b14c58534442a57be3299179eb46aace2d3c8716be199ff6a6/asyncpg-0.28.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata
  Downloading asyncpg-0.28.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.3 kB)
Collecting fastapi==0.101.1 (from -r requirements.txt (line 2))
...
database init done.
student@instance-1:~/genai-databases-retrieval-app/retrieval_service$

7. Déployer le service de récupération sur Cloud Run

Nous pouvons maintenant déployer le service de récupération sur Cloud Run. Le service est chargé de travailler avec la base de données et d'en extraire les informations nécessaires en fonction de la requête d'une application d'IA.

Créer un compte de service

Créez un compte de service pour le service de récupération et accordez les droits nécessaires.

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

4ca978f5142bb6ce.png

Dans le nouvel onglet Cloud Shell, exécutez :

export PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts create retrieval-identity
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:retrieval-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:retrieval-identity@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"

Résultat attendu sur la console :

student@cloudshell:~ (gleb-test-short-003)$ gcloud iam service-accounts create retrieval-identity
Created service account [retrieval-identity].

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

exit

Déployer le service de récupération

Continuez dans le premier onglet où vous êtes connecté à la VM via SSH en déployant le service.

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

cd ~/genai-databases-retrieval-app
gcloud alpha run deploy retrieval-service \
    --source=./retrieval_service/\
    --no-allow-unauthenticated \
    --service-account retrieval-identity \
    --region us-central1 \
    --network=default \
    --quiet

Résultat attendu sur la console :

student@instance-1:~/genai-databases-retrieval-app$ gcloud alpha run deploy retrieval-service \
    --source=./retrieval_service/\
    --no-allow-unauthenticated \
    --service-account retrieval-identity \
    --region us-central1 \
    --network=default
This command is equivalent to running `gcloud builds submit --tag [IMAGE] ./retrieval_service/` and `gcloud run deploy retrieval-service --image [IMAGE]`

Building using Dockerfile and deploying container to Cloud Run service [retrieval-service] in project [gleb-test-short-003] region [us-central1]
X Building and deploying... Done.
  ✓ Uploading sources...
  ✓ Building Container... Logs are available at [https://console.cloud.google.com/cloud-build/builds/6ebe74bf-3039-4221-b2e9-7ca8fa8dad8e?project=1012713954588].
  ✓ Creating Revision...
  ✓ Routing traffic...
    Setting IAM Policy...
Completed with warnings:
  Setting IAM policy failed, try "gcloud beta run services remove-iam-policy-binding --region=us-central1 --member=allUsers --role=roles/run.invoker retrieval-service"
Service [retrieval-service] revision [retrieval-service-00002-4pl] has been deployed and is serving 100 percent of traffic.
Service URL: https://retrieval-service-onme64eorq-uc.a.run.app
student@instance-1:~/genai-databases-retrieval-app$

Vérifier le service

Nous pouvons maintenant vérifier si le service s'exécute correctement et si la VM a accès au point de terminaison. Nous utilisons l'utilitaire gcloud pour obtenir le point de terminaison du service de récupération. Vous pouvez également le vérifier dans la console Cloud et remplacer "$(gcloud run services list –filter="(retrieval-service)" par la valeur correspondante dans la commande curl.

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

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

Résultat attendu sur la console :

student@instance-1:~/genai-databases-retrieval-app$ curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $(gcloud  run services list --filter="(retrieval-service)" --format="value(URL)")
{"message":"Hello World"}student@instance-1:~/genai-databases-retrieval-app$

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

Le service de récupération est maintenant opérationnel et nous pouvons déployer un exemple d'application qui va l'utiliser. L'application peut être déployée sur la VM ou sur n'importe quel autre service comme Cloud Run ou Kubernetes, ou même localement sur un ordinateur portable. Nous allons maintenant voir comment la déployer sur la VM.

Préparer l'environnement

Poursuivons sur la VM en utilisant la même session SSH. Pour exécuter notre application, nous devons ajouter des modules Python. La commande sera exécutée à partir du répertoire de l'application dans le même environnement virtuel Python.

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

cd ~/genai-databases-retrieval-app/llm_demo
pip install -r requirements.txt

Résultat attendu (masqué) :

student@instance-1:~$ cd ~/genai-databases-retrieval-app/llm_demo
pip install -r requirements.txt
Collecting fastapi==0.104.0 (from -r requirements.txt (line 1))
  Obtaining dependency information for fastapi==0.104.0 from https://files.pythonhosted.org/packages/db/30/b8d323119c37e15b7fa639e65e0eb7d81eb675ba166ac83e695aad3bd321/fastapi-0.104.0-py3-none-any.whl.metadata
  Downloading fastapi-0.104.0-py3-none-any.whl.metadata (24 kB)
...

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. Ce sera lorsque nous nous connecterons à l'application, car la réservation utilise les identifiants du client pour enregistrer les données de réservation dans la base de données.

Dans la console Cloud, accédez à "API et services", cliquez sur "Écran de consentement OAuth", puis sélectionnez "Utilisateur interne".

2400e5dcdb93eab8.png

Cliquez ensuite sur "Créer" et suivez les instructions sur l'écran suivant.

6c34d235156e571f.png

Vous devez remplir les champs obligatoires, tels que "Nom de l'application" et "Adresse e-mail d'assistance aux utilisateurs". Vous pouvez également ajouter un domaine que vous souhaitez afficher sur l'écran de consentement, ainsi que les coordonnées du développeur.

2b7cd51aff915072.png

Cliquez ensuite sur le bouton "Enregistrer et continuer" en bas de la page pour passer à la page suivante.

d90c10c88fd347f9.png

Vous n'avez pas besoin de modifier quoi que ce soit, sauf si vous souhaitez spécifier les niveaux d'accès. Enfin, confirmez en cliquant à nouveau sur le bouton "Enregistrer et continuer". L'écran d'autorisation de l'application sera alors configuré.

L'étape suivante consiste à créer l'ID client. Dans le panneau de gauche, cliquez sur "Identifiants" pour accéder aux identifiants OAuth2.

7ad97432390f224c.png

Cliquez sur "Créer des identifiants" en haut de la page, puis sélectionnez "ID client OAuth". Un autre écran s'ouvre alors.

325a926431c8f16d.png

Sélectionnez "Application Web" dans la liste déroulante du type d'application, puis saisissez l'URI (et le port, le cas échéant) de votre application dans le champ "Origines JavaScript autorisées". Vous devez également ajouter l'hôte de votre application avec "/login/google" à la fin à la section "URI de redirection autorisés" pour pouvoir utiliser l'écran pop-up d'autorisation. Dans l'image ci-dessus, vous pouvez voir que j'ai utilisé http://localhost comme URI de base de mon application.

Après avoir cliqué sur le bouton "Créer", une fenêtre pop-up contenant les identifiants de vos clients s'affiche.

e91adf03ec31cd15.png

Nous aurons besoin de l'ID client (et éventuellement du code secret du client) ultérieurement pour l'utiliser avec notre application.

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 de l'aéroport, ne nécessitent que BASE_URL, qui indique à l'application 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 BASE_URL=$(gcloud  run services list --filter="(retrieval-service)" --format="value(URL)")

Résultat attendu (masqué) :

student@instance-1:~/genai-databases-retrieval-app/llm_demo$ export BASE_URL=$(gcloud  run services list --filter="(retrieval-service)" --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:~/genai-databases-retrieval-app/llm_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:~/genai-databases-retrieval-app/llm_demo$ python main.py
INFO:     Started server process [28565]
INFO:     Waiting for application startup.
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.

c667b9013afac3f9.png

Se connecter depuis Cloud Shell

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

4ca978f5142bb6ce.png

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.

444fbf54dcd4d160.png

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. Dans la barre d'adresse de la page, nous voyons l'URI de la page d'aperçu. Nous devons supprimer la partie "/?authuser=0&redirectedPreviously=true" à la fin.

389f0ae2945beed5.png

La première partie de l'URI, par exemple "https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev/", doit être laissée dans la fenêtre du navigateur et fournie en tant que origines JavaScript autorisées et URI de redirection autorisés pour les identifiants créés dans le chapitre"Préparer l'ID client". Elle doit remplacer ou s'ajouter aux valeurs http://localhost:8080 fournies à l'origine. La valeur supérieure se présente comme suit : https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev, et la valeur inférieure comme suit : https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev/login/google.

2c37eeda0a7e2f80.png

Se connecter à l'application

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

a1f571371b957129.png

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

Une fois connecté, l'application est prête. Vous pouvez commencer à saisir vos demandes dans le champ en 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 ?

Réservez-moi un vol pour Denver avec un départ à 10h35.

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.

6e7758f707c67c3e.png

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

9. Nettoyer l'environnement

Une fois toutes les tâches terminées, nous pouvons nettoyer notre environnement.

Supprimer le service Cloud Run

Dans Cloud Shell, exécutez :

gcloud run services delete retrieval-service --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 retrieval-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 [retrieval-identity@gleb-test-short-004.iam.gserviceaccount.com]
student@cloudshell:~ (gleb-test-short-004)$

Supprimez l'instance Cloud SQL.

Détruisez l'instance Cloud SQL une fois l'atelier terminé.

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 :

export INSTANCE_NAME=my-cloudsql-instance
export PROJECT_ID=$(gcloud config get-value project)

Supprimez l'instance :

gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID

Résultat attendu sur la console :

student@cloudshell:~$ gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID
All of the instance data will be lost when the instance is deleted.

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

Deleting Cloud SQL instance...done.                                                                                                                
Deleted [https://sandbox.googleapis.com/v1beta4/projects/test-project-001-402417/instances/my-cloudsql-instance].

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 [compute-aip@gleb-test-short-004.iam.gserviceaccount.com]
student@cloudshell:~ (gleb-test-short-004)$

10. Félicitations

Bravo ! Vous avez terminé cet atelier de programmation.

Points abordés

  • Créer une instance Cloud SQL
  • Se connecter à l'instance Cloud SQL
  • Configurer et déployer le service de récupération de bases de données par IA générative
  • Déployer un exemple d'application à l'aide du service déployé

11. Enquête

Comment allez-vous utiliser ce tutoriel ?

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