Questa pagina è stata tradotta dall'API Cloud Translation.

Creazione di un'applicazione di chat basata su LLM e RAG utilizzando AlloyDB AI e LangChain

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 di IA generativa e sull'applicazione di esempio qui.

Prerequisiti

Conoscenza di base della console Google Cloud
Competenze di base nell'interfaccia a riga di comando e nella shell Google Cloud

Cosa imparerai a fare

Come eseguire il deployment di un cluster AlloyDB
Come connettersi ad AlloyDB
Come configurare ed eseguire il deployment del servizio di recupero di database di AI generativa
Come 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 a tuo ritmo

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 al progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
L'ID progetto è univoco per tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. In genere non è importante sapere cosa sia. Nella maggior parte dei codelab, devi fare riferimento al tuo ID progetto (in genere identificato come PROJECT_ID). Se non ti piace l'ID generato, potresti generarne un altro casuale. In alternativa, puoi provare il tuo e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane invariato per tutta la durata del progetto.
Per tua informazione, esiste un terzo valore, un Numero 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 le API/risorse Cloud. La partecipazione a questo codelab non ha costi, o quasi. 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

Sebbene Google Cloud possa essere utilizzato 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:

Dovrebbe richiedere solo pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere qualcosa di simile a questo:

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 e l'autenticazione di rete. Tutto il lavoro in questo codelab può essere svolto in un browser. Non occorre installare nulla.

3. Prima di iniziare

Attiva l'API

Output:

In 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]

Imposta quindi la variabile di ambiente PROJECT_ID sull'ID progetto Google Cloud:

PROJECT_ID=$(gcloud config get-value project)

Attiva tutti i servizi necessari:

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

Risultato previsto

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

4. Esegui il deployment di un cluster AlloyDB

Prima di creare un cluster AlloyDB, abbiamo bisogno di un intervallo IP privato disponibile nella nostra VPC da utilizzare per la futura istanza AlloyDB. Se non lo abbiamo, dobbiamo crearlo, assegnarlo per l'utilizzo da parte dei servizi Google interni e poi potremo creare il cluster e l'istanza.

Creare un intervallo IP privato

Dobbiamo configurare la configurazione dell'accesso privato ai servizi nel nostro VPC per AlloyDB. Si presuppone che nel progetto abbiamo la rete VPC "predefinita", che verrà utilizzata per tutte le azioni.

Crea l'intervallo IP privato:

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

Crea una connessione privata utilizzando l'intervallo IP allocato:

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

Output della console previsto:

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

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

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

Creare un cluster AlloyDB

Crea un cluster AlloyDB nella regione us-central1.

Definisci la password per l'utente postgres. Puoi definire la tua password o utilizzare una funzione casuale per generarne una

export PGPASSWORD=`openssl rand -hex 12`

Output della console previsto:

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

Prendi nota della password PostgreSQL per uso futuro:

echo $PGPASSWORD

Output della console previsto:

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

Definisci la regione e il nome del cluster AlloyDB. Utilizzeremo la regione us-central1 e alloydb-aip-01 come nome del cluster:

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

Esegui il comando per creare il cluster:

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

Output della console previsto:

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

Creare un'istanza principale AlloyDB

Crea un'istanza principale AlloyDB per il nostro cluster nella stessa sessione Cloud Shell. Se la connessione è disconnessa, dovrai definire di nuovo le variabili di ambiente per la regione e il nome del cluster.

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

Output console previsto:

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

5. Prepara la macchina virtuale GCE

Crea account di servizio

Poiché utilizzeremo la VM per eseguire il deployment del 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). Il token GSA verrà utilizzato dalla VM GCE e dovremo concedergli i privilegi necessari per lavorare 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/alloydb.viewer"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:compute-aip@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/serviceusage.serviceUsageConsumer"

Esegui il deployment della VM GCE

Creare una VM GCE nella stessa regione e nella stessa regione del cluster AlloyDB.

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 della 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

Installa il client Postgres

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 della 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 della 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

Connettiti all'istanza principale dalla VM utilizzando psql.

Continua con la sessione SSH aperta alla VM. Se la connessione si è interrotta, ricollega utilizzando lo stesso comando riportato sopra.

Utilizza $PGASSWORD e il nome del cluster indicati in precedenza per connetterti ad AlloyDB dalla VM GCE:

export PGPASSWORD=<Noted password>

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

Output della console previsto:

student@instance-1:~$ export PGPASSWORD=P9...
student@instance-1:~$ export REGION=us-central1
student@instance-1:~$ export ADBCLUSTER=alloydb-aip-01
student@instance-1:~$ export INSTANCE_IP=export INSTANCE_IP=$(gcloud alloydb instances describe $ADBCLUSTER-pr --cluster=$ADBCLUSTER --region=$REGION --format="value(ipAddress)")
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 della 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 compilarlo con i dati.

Crea database

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

Attiva l'estensione pgVector.

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

Output console previsto:

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

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 della 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 della console previsto:

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

Compila il database

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

Prepara il file di configurazione

Nella VM GCE, esegui:

cd genai-databases-retrieval-app/retrieval_service
cp example-config.yml config.yml
sed -i s/127.0.0.1/$INSTANCE_IP/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 della console previsto:

student@instance-1:~$ cd genai-databases-retrieval-app/retrieval_service
cp example-config.yml config.yml
sed -i s/127.0.0.1/$INSTANCE_IP/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
host: 0.0.0.0
# port: 8080
datastore:
  # Example for AlloyDB
  kind: "postgres"
  host: 10.65.0.2
  # port: 5432
  database: "assistantdemo"
  user: "postgres"
  password: "P9..."

Compila il database con il set di dati di esempio. Il primo comando aggiunge tutti i pacchetti richiesti al nostro ambiente virtuale Python e il secondo popola il database con i dati.

Nella VM GCE, esegui:

pip install -r requirements.txt
python run_database_init.py

Output della console previsto(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 del lavoro con il database ed estrae 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"

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" 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 della 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 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 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, possiamo eseguire il deployment di un'applicazione di esempio che lo utilizzerà. L'applicazione può essere dispiattata sulla VM o su qualsiasi altro servizio come Cloud Run, Kubernetes o anche localmente su un laptop. Qui illustreremo come eseguirlo nella 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

Risultato 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)
...

Preparare l'ID client

Per utilizzare la funzionalità di prenotazione dell'applicazione, dobbiamo preparare l'ID client OAuth 2.0 utilizzando la console Cloud. Accederemo all'applicazione poiché la prenotazione utilizza le credenziali dei clienti per registrare i dati della prenotazione nel database.

In Cloud Console, vai ad API e servizi, fai clic su "Schermata del consenso OAuth" e scegli l'utente "Interno".

Quindi premi "Crea" e segui le istruzioni nella schermata successiva.

Devi compilare i campi obbligatori come "Nome dell'app" e "Indirizzo email dell'assistenza utente". Puoi anche aggiungere un dominio che vuoi mostrare nella schermata per il consenso e, infine, i "Dati di contatto dello sviluppatore".

Premi poi 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 confermi l'operazione premendo di nuovo il pulsante "Salva e continua". Verrà configurata la schermata per il consenso all'applicazione.

Il passaggio successivo consiste nel creare l'ID client. Nel riquadro a sinistra, fai clic su "Credenziali" per accedere alle credenziali per OAuth2.

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, per poter utilizzare la finestra popup di autorizzazione, devi aggiungere agli "URI di reindirizzamento autorizzati" l'host dell'applicazione con "/login/google" alla fine. Nell'immagine sopra puoi vedere che ho utilizzato http://localhost come URI dell'applicazione di base.

Dopo aver fatto clic sul 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 di assistenza

Prima di avviare l'applicazione, è necessario impostare alcune variabili di ambiente. La funzionalità di base dell'applicazione, come le query sui voli e sui 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)")

Risultato 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 funzionalità più avanzate dell'applicazione, come la prenotazione e la modifica dei voli, dobbiamo accedere all'applicazione utilizzando il nostro Account Google e, a tal fine, 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

Risultato 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

Risultato 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 traducendo la porta locale 8080 nella porta della VM 8081.

Connessione da un computer locale

Per 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

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

Nel nuovo Cloud Shell, recupera l'URI di origine e di reindirizzamento del client web che esegue il comando gcloud:

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

Ecco l'output previsto:

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

Inoltre, utilizza l'origine e il reindirizzamento degli URI come "Origini JavaScript autorizzate" e "URI di reindirizzamento autorizzati" per le nostre credenziali create nel capitolo "Preparare l'ID client", sostituendo o aggiungendo ai valori http://localhost:8080 forniti in origine.

Nella nuova scheda Cloud Shell, avvia il tunnel per la VM eseguendo il comando gcloud:

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

Viene visualizzato il messaggio di 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:~$

Viene aperta la porta 8080 su Cloud Shell, che può essere utilizzata per l'opzione "Anteprima web".

Fai clic sul pulsante "Anteprima web" in alto a destra in 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 riuscire a vedere la pagina "Assistente del servizio clienti Cymbal Air".

Accedere all'applicazione

Una volta completata la configurazione e aperta l'applicazione, possiamo utilizzare il pulsante "Accedi" in alto a destra nella schermata dell'applicazione per fornire le nostre credenziali. Questa opzione è 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.

Dopo aver eseguito l'accesso, l'applicazione è pronta e puoi iniziare a pubblicare le tue richieste nel campo in fondo alla finestra.

Questa demo mostra l'assistente del servizio clienti di Cymbal Air. Cymbal Air è una compagnia aerea passeggeri immaginaria. 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 accedere (senza CLIENT_ID), può essere utile per rispondere a domande degli utenti come:

Quando parte il prossimo volo per Denver?

Ci sono negozi di lusso intorno al varco 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 controllare se il posto assegnato è vicino al finestrino o al corridoio.

L'applicazione utilizza i modelli di base di Google più recenti per generare risposte e integrarle con informazioni su voli e servizi del database AlloyDB operativo. Puoi scoprire di più su questa applicazione di dimostrazione nella pagina GitHub del progetto.

9. Ripulire l'ambiente

Ora che tutte le attività sono state completate, possiamo ripulire l'ambiente

Elimina il servizio Cloud Run

In Cloud Shell, esegui:

gcloud run services delete retrieval-service --region us-central1

Output della 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 le istanze e il cluster AlloyDB al termine del lab

Elimina il cluster AlloyDB e tutte le istanze

Il cluster viene distrutto con l'opzione force, che elimina anche tutte le istanze appartenenti al cluster.

In Cloud Shell, definisci le variabili di progetto e di ambiente se la connessione è stata disconnessa e tutte le impostazioni precedenti sono andate perse:

gcloud config set project <your project id>

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

Elimina il cluster:

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

Output console previsto:

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

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

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

Eliminare i backup di AlloyDB

Elimina tutti i backup di AlloyDB per il cluster:

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

Output della console previsto:

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

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 della 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 della 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

Come eseguire il deployment di AlloyDB Cluster
Come connettersi ad AlloyDB
Come configurare ed eseguire il deployment del servizio di recupero di database di AI generativa
Come eseguire il deployment di un'applicazione di esempio utilizzando il servizio di cui è stato eseguito il deployment

11. Sondaggio

Output:

Come utilizzerai questo tutorial?

Leggi solo il testo

Leggilo e completa gli esercizi