1. Introduzione
In questo codelab imparerai a eseguire il deployment del servizio di recupero dei database GenAI e a creare un'applicazione interattiva di esempio utilizzando l'ambiente di cui è stato eseguito il deployment.
Qui puoi trovare ulteriori informazioni sul servizio di recupero dell'IA generativa e sull'applicazione di esempio.
Prerequisiti
- Conoscenza di base della console Google Cloud
- Competenze di base dell'interfaccia a riga di comando e di Google Cloud Shell
Cosa imparerai a fare
- Creare un'istanza Cloud SQL
- Come connettersi all'istanza
- Come configurare ed eseguire il deployment del servizio di recupero database GenAI
- Eseguire il deployment di un'applicazione di esempio utilizzando il servizio di cui è stato eseguito il deployment
Che cosa ti serve
- Un account Google Cloud e un progetto Google Cloud
- Un browser web come Chrome.
2. Configurazione e requisiti
Configurazione dell'ambiente da seguire in modo autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.
- Il Nome progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarla.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca; di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come
PROJECT_ID). Se l'ID generato non ti soddisfa, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per informazione, c'è un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. L'esecuzione di questo codelab non ha alcun costo. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.
Avvia Cloud Shell
Anche se Google Cloud può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Dalla console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:
Dovrebbe richiedere solo qualche istante per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere una schermata simile al seguente:
Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non occorre installare nulla.
3. Prima di iniziare
Abilita API
All'interno di Cloud Shell, assicurati che l'ID progetto sia configurato:
Di solito l'ID progetto è mostrato tra parentesi nel prompt dei comandi in Cloud Shell, come mostrato nell'immagine:
gcloud config set project [YOUR-PROJECT-ID]
Quindi imposta la variabile di ambiente PROJECT_ID sul tuo ID progetto Google Cloud:
PROJECT_ID=$(gcloud config get-value project)
Abilita tutti i servizi necessari:
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
Output console previsto:
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. Crea un'istanza Cloud SQL
Creare un'istanza Cloud SQL in cui è abilitato il supporto vettoriale.
Creare una password
Definisci la password per l'utente predefinito del database. Puoi definire la tua password o utilizzare una funzione casuale per generarne una
export CLOUDSQL_PASSWORD=`openssl rand -hex 12`
Prendi nota del valore generato per la password
echo $CLOUDSQL_PASSWORD
MySQL
Puoi abilitare il flag cloudsql_vector al momento della creazione dell'istanza. Attualmente, il supporto vettoriale è offerto in MySQL 8.0.36 & 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
Output console previsto (indirizzo IP oscurato):
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'estensione pgvector è offerta nelle versioni >= 11.
export region=us-central1
gcloud sql instances create my-cloudsql-instance --region=$region --database-version=POSTGRES_15 --tier=db-g1-small
Output console previsto (indirizzo IP oscurato):
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
Dopo aver creato l'istanza, dobbiamo definire una password per l'utente predefinito nell'istanza e verificare se possiamo connetterci con la password. Inserisci la password nel prompt quando il dispositivo è pronto per la connessione.
gcloud sql users set-password postgres \
--instance=my-cloudsql-instance \
--password=$CLOUDSQL_PASSWORD
gcloud sql connect my-cloudsql-instance --user=postgres
Output console previsto:
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=>
Esci dalla sessione psql:
exit
5. Prepara macchina virtuale GCE
Crea account di servizio
Poiché utilizzeremo la nostra VM per eseguire il deployment del nostro servizio di recupero dei database di IA generativa e ospitare un'applicazione di esempio, il primo passaggio consiste nel creare un account di servizio Google (GSA). La VM GCE utilizzerà la VM GCE e sarà necessario concederle i privilegi necessari per utilizzare gli altri servizi.
In Cloud Shell, esegui:
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"
Esegui il deployment della VM GCE
Crea una VM GCE nella stessa regione e nello stesso VPC dell'istanza Cloud SQL.
In Cloud Shell, esegui:
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
Output console previsto:
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
Autorizza la VM a connettersi a Cloud SQL
Dobbiamo aggiungere l'IP pubblico della VM all'elenco delle reti autorizzate per la nostra istanza Cloud SQL. In Cloud Shell esegui:
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
Output console previsto:
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].
Installa il client di database
MySQL
Installare il software client MySQL sulla VM di cui è stato eseguito il deployment.
Connettiti alla VM:
gcloud compute ssh instance-1 --zone=us-central1-a
Output console previsto:
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:~$
Installa il comando in esecuzione del software all'interno della VM:
sudo apt-get update
sudo apt-get install --yes default-mysql-client
Output console previsto:
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
Installare il software client PostgreSQL sulla VM di cui è stato eseguito il deployment.
Connettiti alla VM:
gcloud compute ssh instance-1 --zone=us-central1-a
Output console previsto:
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:~$
Installa il comando in esecuzione del software all'interno della VM:
sudo apt-get update
sudo apt-get install --yes postgresql-client
Output console previsto:
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) ...
Connettiti all'istanza
MySQL
Connettiti all'istanza principale dalla VM utilizzando MySQL.
Continua con la sessione SSH aperta per la VM. In caso di disconnessione, esegui di nuovo la connessione utilizzando lo stesso comando riportato sopra.
Usa $CLOUDSQL_PASSWORD indicati in precedenza e il nome dell'istanza per connetterti a Cloud SQL dalla 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
Output console previsto:
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)]>
Esci dalla sessione MySQL mantenendo attiva la connessione SSH:
exit
Output console previsto:
MySQL [(none)]> exit Bye student@instance-1:~$
PostgreSQL
Connettiti all'istanza principale dalla VM utilizzando psql.
Continua con la sessione SSH aperta per la VM. In caso di disconnessione, esegui di nuovo la connessione utilizzando lo stesso comando riportato sopra.
Usa $CLOUDSQL_PASSWORD indicati in precedenza e il nome dell'istanza per connetterti a PostgreSQL dalla 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"
Output console previsto:
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=>
Esci dalla sessione psql mantenendo attiva la connessione SSH:
exit
Output console previsto:
postgres=> exit student@instance-1:~$
6. Inizializzare il database
Utilizzeremo la nostra VM client come piattaforma per popolare il nostro database con i dati e ospitare la nostra applicazione. Il primo passaggio consiste nel creare un database e popolarlo con i dati.
Crea database
MySQL
Crea un database con il nome "assistantdemo".
Nella sessione VM GCE, esegui:
mysql --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD -e "CREATE DATABASE assistantdemo"
Output previsto della console (nessun output):
student@instance-1:~$ mysql --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD -e "CREATE DATABASE assistantdemo" student@instance-1:~$
PostgreSQL
Crea un database con il nome "assistantdemo".
Nella sessione VM GCE, esegui:
psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE assistantdemo"
Output console previsto:
student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE assistantdemo" CREATE DATABASE student@instance-1:~$
Attiva l'estensione pgvector.
psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "CREATE EXTENSION vector"
Output previsto della console (nessun output):
student@instance-1:~$ psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "CREATE EXTENSION vector" CREATE EXTENSION student@instance-1:~$
Prepara l'ambiente Python
Per continuare, utilizzeremo gli script Python preparati dal repository GitHub, ma prima di farlo dobbiamo installare il software richiesto.
Nella VM GCE, esegui:
sudo apt install -y python3.11-venv git
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
Output console previsto:
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:~$
Verifica la versione Python.
Nella VM GCE, esegui:
python -V
Output console previsto:
(.venv) student@instance-1:~$ python -V Python 3.11.2 (.venv) student@instance-1:~$
Preparare il file di configurazione
Clona il repository GitHub con il codice per il servizio di recupero e l'applicazione di esempio.
Nella VM GCE, esegui:
git clone https://github.com/GoogleCloudPlatform/genai-databases-retrieval-app.git
Output console previsto:
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
Nella VM GCE, esegui:
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
Output console previsto:
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
Nella VM GCE, esegui:
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
Output console previsto:
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..."
Compila database
Compila il database con il set di dati di esempio. Il primo comando aggiunge tutti i pacchetti necessari all'ambiente virtuale Python e il secondo completa i dati nel database.
Nella VM GCE, esegui:
cd ~/genai-databases-retrieval-app/retrieval_service
pip install -r requirements.txt
python run_database_init.py
Output previsto della console (oscurato):
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. esegui il deployment del servizio di recupero in Cloud Run
Ora possiamo eseguire il deployment del servizio di recupero in Cloud Run. Il servizio è responsabile di lavorare con il database ed estrarre le informazioni necessarie dal database in base alla richiesta di un'applicazione di IA.
Crea account di servizio
Crea un account di servizio per il servizio di recupero e concedi i privilegi necessari.
Apri un'altra scheda di Cloud Shell utilizzando il segno "+" in alto.
Nella nuova scheda Cloud Shell esegui:
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"
Output console previsto:
student@cloudshell:~ (gleb-test-short-003)$ gcloud iam service-accounts create retrieval-identity Created service account [retrieval-identity].
Chiudi la scheda utilizzando il comando di esecuzione "exit" nella scheda:
exit
Esegui il deployment del servizio di recupero
Continua nella prima scheda in cui sei connesso alla VM tramite SSH eseguendo il deployment del servizio.
Nella sessione SSH della VM, esegui:
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
Output console previsto:
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$
Verifica il servizio
Ora possiamo verificare se il servizio viene eseguito correttamente e la VM ha accesso all'endpoint. Usiamo l'utilità gcloud per ottenere l'endpoint del servizio di recupero. In alternativa, puoi verificarlo nella console Cloud e sostituire nel comando curl il valore "$(gcloud run services list –filter="(retrieval-service)" con il relativo valore.
Nella sessione SSH della VM, esegui:
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $(gcloud run services list --filter="(retrieval-service)" --format="value(URL)")
Output console previsto:
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$
Se vediamo "Hello World" significa che il nostro servizio è attivo e sta rispondendo alle richieste.
8. Esegui il deployment dell'applicazione di esempio
Ora, quando il servizio di recupero è attivo e in esecuzione, possiamo eseguire il deployment di un'applicazione di esempio che utilizzerà il servizio. Il deployment dell'applicazione può essere eseguito sulla VM o su qualsiasi altro servizio come Cloud Run, Kubernetes o anche localmente su un laptop. Qui vedremo come eseguirne il deployment sulla VM.
Prepara l'ambiente
Continuiamo a lavorare sulla VM utilizzando la stessa sessione SSH. Per eseguire la nostra applicazione dobbiamo aggiungere alcuni moduli Python. Il comando verrà eseguito dalla directory dell'applicazione nello stesso ambiente virtuale Python.
Nella sessione SSH della VM, esegui:
cd ~/genai-databases-retrieval-app/llm_demo
pip install -r requirements.txt
Output previsto (oscurato):
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) ...
Prepara l'ID client
Per utilizzare la funzionalità di prenotazione dell'applicazione, dobbiamo preparare l'ID client OAuth 2.0 mediante la console Cloud. Lo sarà quando accederai all'applicazione, perché la prenotazione utilizza le credenziali del client per registrare i dati di prenotazione nel database.
Nella console Cloud, vai alle API e ai servizi e fai clic su "Schermata consenso OAuth" e scegli "Interno" utente.
Quindi, esegui il push su "Crea". e procedi nella schermata successiva.
Devi compilare i campi obbligatori, ad esempio "Nome app" e "Email per l'assistenza utenti". Puoi anche aggiungere un dominio che vuoi mostrare nella schermata per il consenso e, infine, i "Dati di contatto dello sviluppatore".
Poi premi il pulsante "Salva e continua" in fondo alla pagina per passare alla pagina successiva.
Non devi apportare alcuna modifica, a meno che tu non voglia specificare gli ambiti. Infine confermi l'operazione premendo il pulsante "Salva e continua" di nuovo. Verrà configurata la schermata per il consenso dell'applicazione.
Il passaggio successivo consiste nel creare l'ID client. Nel riquadro a sinistra fai clic su "Credenziali" che indirizzano alle credenziali per OAuth2.
Qui fai clic su "Crea credenziali" in alto e scegli "ClientID OAuth". Si aprirà un'altra schermata.
Seleziona "Applicazione web". dall'elenco a discesa per il tipo di applicazione e inserisci l'URI dell'applicazione (e la porta, facoltativamente) nel campo "Origini JavaScript autorizzate". Devi aggiungere gli URI di reindirizzamento autorizzati l'host dell'applicazione con "/login/google" alla fine per poter usare la schermata popup di autorizzazione. Nell'immagine sopra puoi vedere che ho utilizzato http://localhost come URI di base dell'applicazione.
Dopo aver premuto il pulsante viene visualizzata una finestra popup con le credenziali del client.
In seguito avremo bisogno dell'ID client (e facoltativamente del client secret) da utilizzare nella nostra applicazione
Esegui l'applicazione dell'assistente
Prima di avviare l'applicazione, è necessario impostare alcune variabili di ambiente. La funzionalità di base dell'applicazione, come query sui voli e servizi aeroportuali, richiede solo BASE_URL che indirizza l'applicazione al servizio di recupero. Possiamo ottenere usando il comando gcloud .
Nella sessione SSH della VM, esegui:
export BASE_URL=$(gcloud run services list --filter="(retrieval-service)" --format="value(URL)")
Output previsto (oscurato):
student@instance-1:~/genai-databases-retrieval-app/llm_demo$ export BASE_URL=$(gcloud run services list --filter="(retrieval-service)" --format="value(URL)")
Per utilizzare le funzionalità più avanzate dell'applicazione, come la prenotazione e la modifica dei voli, dobbiamo accedere all'applicazione utilizzando il nostro Account Google. A questo scopo dobbiamo fornire la variabile di ambiente CLIENT_ID utilizzando l'ID client OAuth indicato nel capitolo "Preparare l'ID client".
export CLIENT_ID=215....apps.googleusercontent.com
Output previsto (oscurato):
student@instance-1:~/genai-databases-retrieval-app/llm_demo$ export CLIENT_ID=215....apps.googleusercontent.com
Ora possiamo eseguire la nostra applicazione:
python run_app.py
Output previsto:
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)
Connettiti all'applicazione
Esistono diversi modi per connettersi all'applicazione in esecuzione sulla VM. Ad esempio, puoi aprire la porta 8081 sulla VM utilizzando le regole del firewall nel VPC o creare un bilanciatore del carico con IP pubblico. Qui utilizzeremo un tunnel SSH alla VM traducendo la porta locale 8080 nella porta della VM 8081.
Connessione dal computer locale
Per connetterci da una macchina locale, dobbiamo eseguire un tunnel SSH. Può essere eseguito utilizzando gcloud compute ssh:
gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8081:localhost:8081
Output previsto:
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:~$
Ora possiamo aprire il browser e utilizzare http://localhost:8081 per connetterci alla nostra applicazione. Dovremmo vedere la schermata dell'applicazione.
Connessione da Cloud Shell
In alternativa, possiamo utilizzare Cloud Shell per la connessione. Apri un'altra scheda di Cloud Shell utilizzando il segno "+" in alto.
Nella nuova scheda Cloud Shell avvia il tunnel sulla tua VM eseguendo il comando gcloud:
gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081
Verrà visualizzato l'errore "Impossibile assegnare l'indirizzo richiesto" - Ignoralo.
Ecco l'output previsto:
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:~$
Apre la porta 8080 su Cloud Shell, che può essere utilizzata per "Anteprima web".
Fai clic sull'anteprima web in alto a destra in Cloud Shell e, dal menu a discesa, scegli "Anteprima sulla porta 8080".
Viene aperta una nuova scheda del browser web con l'interfaccia dell'applicazione. Dovresti visualizzare l'opzione "Assistente dell'assistenza clienti Cymbal Air" . Nella barra degli indirizzi della pagina è visualizzato l'URI della pagina di anteprima. Dobbiamo rimuovere la parte "/?authuser=0&redirectedPreviously=true" alla fine
E usa la prima parte dell'URI come "https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev/" deve essere lasciato nella finestra del browser e specificare come "Origini JavaScript autorizzate" e "URI di reindirizzamento autorizzati" per le credenziali create nel campo "Prepare Client ID" (Prepara ID client) capitolo sostituendo o aggiungendo i valori http://localhost:8080 forniti in origine. Il valore superiore sarà simile a "https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev" e quella inferiore sarebbe "https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev/login/google"
Accedere all'applicazione
Quando è tutto configurato e la tua applicazione è aperta, possiamo usare la casella di controllo "Accedi" in alto a destra nella schermata dell'applicazione per fornire le nostre credenziali. Questa operazione è facoltativa e obbligatoria solo se vuoi provare la funzionalità di prenotazione dell'applicazione.
Si aprirà una finestra popup in cui possiamo scegliere le nostre credenziali.
Una volta che l'applicazione è pronta e puoi iniziare a pubblicare le tue richieste nel campo nella parte inferiore della finestra.
Questa demo mostra l'assistente dell'assistenza clienti di Cymbal Air. Cymbal Air è una fittizia compagnia aerea passeggeri. L'assistente è un chatbot IA che aiuta i viaggiatori a gestire i voli e a cercare informazioni sull'hub di Cymbal Air all'aeroporto internazionale di San Francisco (SFO).
Senza l'accesso (senza CLIENT_ID), può rispondere a domande degli utenti quali:
Quando è il prossimo volo per Denver?
Ci sono negozi di lusso intorno al gate C28?
Dove posso prendere un caffè vicino al gate A6?
Dove posso acquistare un regalo?
Prenota un volo per Denver, con partenza alle 10:35
Dopo aver eseguito l'accesso all'applicazione, puoi provare altre funzionalità, come la prenotazione di voli o il controllo del posto assegnato a te, che è un posto vicino al finestrino o nel corridoio.
L'applicazione utilizza gli ultimi modelli di base di Google per generare risposte e aumentarle con informazioni su voli e comfort provenienti dal database operativo Cloud SQL. Per ulteriori informazioni su questa applicazione demo, visita la pagina GitHub del progetto.
9. Pulisci l'ambiente
Una volta completate tutte le attività, possiamo ripulire il nostro ambiente.
Elimina il servizio Cloud Run
In Cloud Shell, esegui:
gcloud run services delete retrieval-service --region us-central1
Output console previsto:
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].
Elimina l'account di servizio per il servizio Cloud Run
In Cloud Shell, esegui:
PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete retrieval-identity@$PROJECT_ID.iam.gserviceaccount.com --quiet
Output console previsto:
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)$
Elimina l'istanza Cloud SQL
Elimina l'istanza Cloud SQL al termine del lab
In Cloud Shell definisci le variabili di progetto e di ambiente se l'account è stato disconnesso e tutte le impostazioni precedenti vanno perse:
export INSTANCE_NAME=my-cloudsql-instance
export PROJECT_ID=$(gcloud config get-value project)
Elimina l'istanza:
gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID
Output console previsto:
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].
Ora possiamo eliminare la VM
Elimina VM GCE
In Cloud Shell, esegui:
export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
--zone=$ZONE \
--quiet
Output console previsto:
student@cloudshell:~ (test-project-001-402417)$ export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
--zone=$ZONE \
--quiet
Deleted
Elimina l'account di servizio per la VM GCE e il servizio di recupero
In Cloud Shell, esegui:
PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts delete compute-aip@$PROJECT_ID.iam.gserviceaccount.com --quiet
Output console previsto:
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. Complimenti
Complimenti per aver completato il codelab.
Argomenti trattati
- Creare un'istanza Cloud SQL
- Come connettersi all'istanza Cloud SQL
- Come configurare ed eseguire il deployment del servizio di recupero database GenAI
- Eseguire il deployment di un'applicazione di esempio utilizzando il servizio di cui è stato eseguito il deployment