1. Introduzione
In questo codelab imparerai a eseguire il deployment del servizio di recupero di database di AI generativa e a creare un'applicazione interattiva di esempio utilizzando l'ambiente di cui è stato eseguito il deployment.
Puoi trovare ulteriori informazioni sul servizio di recupero dell'IA generativa e sull'applicazione di esempio qui.
Prerequisiti
- Una comprensione di base della console Google Cloud
- Competenze di base nell'interfaccia a riga di comando e in Google Cloud Shell
Cosa imparerai a fare
- Come creare un'istanza Cloud SQL
- Come connettersi all'istanza
- Come configurare ed eseguire il deployment del servizio di recupero dei database di AI generativa
- Come eseguire il deployment di un'applicazione di esempio utilizzando il servizio di cui hai 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 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 del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come
PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.
Avvia Cloud Shell
Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:
Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:
Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.
3. Prima di iniziare
Abilita l'API
In Cloud Shell, assicurati che l'ID progetto sia configurato:
Di solito, l'ID progetto viene mostrato tra parentesi nel prompt dei comandi in Cloud Shell, come mostrato nell'immagine:
gcloud config set project [YOUR-PROJECT-ID]
Poi imposta la variabile di ambiente PROJECT_ID sull'ID del tuo progetto Google Cloud:
PROJECT_ID=$(gcloud config get-value project)
Attiva 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
Crea un'istanza Cloud SQL con il supporto dei vettori abilitato.
Creare una password
Definisci la password per l'utente del database predefinito. Puoi definire una password personalizzata o utilizzare una funzione casuale per generarla.
export CLOUDSQL_PASSWORD=`openssl rand -hex 12`
Prendi nota del valore generato per la password.
echo $CLOUDSQL_PASSWORD
MySQL
Puoi attivare il flag cloudsql_vector durante la creazione dell'istanza. Al momento, il supporto dei vettori è offerto in MySQL 8.0.36 e 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 della 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 della 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 è 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 la macchina virtuale GCE
Crea service account
Poiché utilizzeremo la nostra VM per eseguire il deployment del servizio di recupero dei database di AI generativa e ospitare un'applicazione di esempio, il primo passaggio consiste nel creare un service account Google (GSA). L'account di servizio Google verrà utilizzato dalla VM GCE e dovremo concedergli i privilegi necessari per funzionare con 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 nostra 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].
Installare il client di database
MySQL
Installa 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 di 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
Installa 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 di 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 primaria dalla VM utilizzando MySQL.
Continua con la sessione SSH aperta nella VM. Se la connessione è stata interrotta, connettiti di nuovo utilizzando lo stesso comando riportato sopra.
Utilizza $CLOUDSQL_PASSWORD annotato 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 primaria dalla VM utilizzando psql.
Continua con la sessione SSH aperta nella VM. Se la connessione è stata interrotta, connettiti di nuovo utilizzando lo stesso comando riportato sopra.
Utilizza $CLOUDSQL_PASSWORD annotata 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 database con i dati e ospitare la nostra applicazione. Il primo passaggio consiste nel creare un database e compilarlo con i dati.
Crea database
MySQL
Crea un database con il nome "assistantdemo".
Nella sessione della VM GCE esegui:
mysql --host=$INSTANCE_IP --user=root --password=$CLOUDSQL_PASSWORD -e "CREATE DATABASE assistantdemo"
Output della console previsto (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 della 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:~$
Abilita l'estensione pgvector.
psql "host=$INSTANCE_IP user=postgres dbname=assistantdemo" -c "CREATE EXTENSION vector"
Output della console previsto (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 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 di 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..."
Popola database
Compila il database con il set di dati di esempio. Il primo comando aggiunge tutti i pacchetti richiesti all'ambiente virtuale Python, mentre il secondo comando popola il database con i dati.
Nella VM GCE esegui:
cd ~/genai-databases-retrieval-app/retrieval_service
pip install -r requirements.txt
python run_database_init.py
Output della console previsto (modificato):
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 su Cloud Run. Il servizio è responsabile dell'utilizzo del database e dell'estrazione delle informazioni necessarie dal database in base alla richiesta di un'applicazione di AI.
Crea service account
Crea un service account 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 di 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 con il comando di esecuzione "exit":
exit
Esegui il deployment del servizio di recupero
Continua nella prima scheda in cui ti 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$
Verificare il servizio
Ora possiamo verificare se il servizio viene eseguito correttamente e se la VM ha accesso all'endpoint. Utilizziamo l'utilità gcloud per ottenere l'endpoint del servizio di recupero. In alternativa, puoi controllarlo in Cloud Console e sostituire "$(gcloud run services list –filter="(retrieval-service)" nel comando curl con il valore corrispondente.
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 visualizziamo il messaggio "Hello World", significa che il nostro servizio è attivo e gestisce le richieste.
8. Esegui il deployment dell'applicazione di esempio
Ora che il servizio di recupero è attivo e in esecuzione, possiamo eseguire il deployment di un'applicazione di esempio che utilizzerà il servizio. L'applicazione può essere implementata sulla VM o su qualsiasi altro servizio come Cloud Run, Kubernetes o anche localmente su un laptop. Qui ti mostreremo come eseguirne il deployment sulla VM.
Prepara l'ambiente
Continuiamo a lavorare sulla nostra 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 (modificato):
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) ...
Preparare l'ID client
Per utilizzare la funzionalità di prenotazione dell'applicazione, dobbiamo preparare l'ID client OAuth 2.0 utilizzando la console Cloud. Avverrà quando accediamo all'applicazione, poiché la prenotazione utilizza le credenziali dei clienti per registrare i dati di prenotazione nel database.
Nella console Cloud, vai ad API e servizi, fai clic su "Schermata per il consenso OAuth" e scegli l'utente "Interno".
Quindi premi "Crea" e segui le istruzioni nella schermata successiva.
Devi compilare i campi obbligatori, ad esempio "Nome app" ed "Email di assistenza utenti". Puoi anche aggiungere un dominio da mostrare nella schermata del 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 è necessario modificare nulla, a meno che tu non voglia specificare gli ambiti. Infine, conferma facendo di nuovo clic sul pulsante "Salva e continua". In questo modo 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 ti indirizza alle credenziali per OAuth2.
Qui fai clic su "Crea credenziali" in alto e scegli "ID client 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) come "Origini JavaScript autorizzate". Inoltre, devi aggiungere agli "URI di reindirizzamento autorizzati" l'host dell'applicazione con "/login/google" alla fine per poter utilizzare la schermata popup di autorizzazione. Nell'immagine sopra puoi vedere che ho utilizzato http://localhost come URI dell'applicazione di base.
Dopo aver premuto il pulsante "Crea", viene visualizzata una finestra popup con le credenziali del cliente.
Avremo bisogno dell'ID client (e, facoltativamente, del client secret) in un secondo momento per utilizzarlo con la nostra applicazione
Esegui l'applicazione dell'assistente
Prima di avviare l'applicazione, dobbiamo configurare alcune variabili di ambiente. La funzionalità di base dell'applicazione, come la ricerca di voli e servizi aeroportuali, richiede solo BASE_URL, che indirizza l'applicazione al servizio di recupero. Possiamo ottenerlo utilizzando il comando gcloud .
Nella sessione SSH della VM esegui:
export BASE_URL=$(gcloud run services list --filter="(retrieval-service)" --format="value(URL)")
Output previsto (modificato):
student@instance-1:~/genai-databases-retrieval-app/llm_demo$ export BASE_URL=$(gcloud run services list --filter="(retrieval-service)" --format="value(URL)")
Per utilizzare funzionalità più avanzate dell'applicazione, come la prenotazione e la modifica dei voli, dobbiamo accedere all'applicazione utilizzando il nostro Account Google e a questo scopo dobbiamo fornire la variabile di ambiente CLIENT_ID utilizzando l'ID client OAuth del capitolo Prepara l'ID client:
export CLIENT_ID=215....apps.googleusercontent.com
Output previsto (modificato):
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)
Connettersi 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 firewall nel VPC o creare un bilanciatore del carico con IP pubblico. Qui utilizzeremo un tunnel SSH alla VM che traduce la porta locale 8080 nella porta VM 8081.
Connessione dalla macchina locale
Quando vogliamo connetterci da una macchina locale, dobbiamo eseguire un tunnel SSH. Puoi farlo 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 visualizzare la schermata dell'applicazione.
Connessione da Cloud Shell
In alternativa, possiamo utilizzare Cloud Shell per connetterci. Apri un'altra scheda di Cloud Shell utilizzando il segno "+" in alto.
Nella nuova scheda di Cloud Shell, avvia il tunnel alla tua VM eseguendo il comando gcloud:
gcloud compute ssh instance-1 --zone=us-central1-a -- -L 8080:localhost:8081
Verrà visualizzato l'errore "Cannot assign requested address" (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 in Cloud Shell, che può essere utilizzata per l'anteprima web.
Fai clic sul pulsante "Anteprima web" in alto a destra di Cloud Shell e scegli "Anteprima sulla porta 8080" dal menu a discesa.
Si apre una nuova scheda nel browser web con l'interfaccia dell'applicazione. Dovresti visualizzare la pagina "Cymbal Air Customer Service Assistant". Nella barra degli indirizzi della pagina vediamo l'URI della pagina di anteprima. Dobbiamo rimuovere la parte "/?authuser=0&redirectedPreviously=true" alla fine
La prima parte dell'URI, ad esempio "https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev/", deve essere lasciata nella finestra del browser e fornita come "Origini JavaScript autorizzate" e "URI di reindirizzamento autorizzati" per le nostre credenziali create nel capitolo "Prepara l'ID client", sostituendo o aggiungendo i valori http://localhost:8080 forniti originariamente. Il valore superiore sarà "https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev" e quello inferiore "https://8080-cs-35704030349-default.cs-us-east1-vpcf.cloudshell.dev/login/google".
Accedere all'applicazione
Una volta configurato tutto e aperta l'applicazione, possiamo utilizzare il pulsante "Accedi" in alto a destra della schermata dell'applicazione per fornire le nostre credenziali. È facoltativo e obbligatorio solo se vuoi provare la funzionalità di prenotazione dell'applicazione.
Si aprirà una finestra popup in cui possiamo scegliere le nostre credenziali.
Dopo aver eseguito l'accesso, l'applicazione è pronta e puoi iniziare a pubblicare le tue richieste nel campo nella parte inferiore della finestra.
Questa demo mostra l'assistente al servizio clienti Cymbal Air. Cymbal Air è una compagnia aerea passeggeri fittizia. L'assistente è un chatbot AI che aiuta i viaggiatori a gestire i voli e a cercare informazioni sull'hub di Cymbal Air presso l'aeroporto internazionale di San Francisco (SFO).
Senza accedere (senza CLIENT_ID), può aiutare a rispondere a domande degli utenti come:
Quando è il prossimo volo per Denver?
Ci sono negozi di lusso vicino 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.
Una volta eseguito l'accesso all'applicazione, puoi provare altre funzionalità, come prenotare voli o controllare se il posto assegnato è vicino al finestrino o al corridoio.
L'applicazione utilizza i foundation model di Google più recenti per generare risposte e le integra con informazioni su voli e servizi dal database Cloud SQL operativo. Puoi leggere di più su questa applicazione demo nella pagina GitHub del progetto.
9. Pulizia dell'ambiente
Una volta completate tutte le attività, possiamo ripulire l'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 il service account 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 la connessione è stata interrotta e tutte le impostazioni precedenti sono andate 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 nostra 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 il service account 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
Congratulazioni per aver completato il codelab.
Argomenti trattati
- Come creare un'istanza Cloud SQL
- Come connettersi all'istanza Cloud SQL
- Come configurare ed eseguire il deployment del servizio di recupero dei database di AI generativa
- Come eseguire il deployment di un'applicazione di esempio utilizzando il servizio di cui hai eseguito il deployment