Aplicación de RAG con agente de AlloyDB y MCP Toolbox

1. Introducción

En este codelab, aprenderás a crear un clúster de AlloyDB, implementar la caja de herramientas del MCP y configurarla para usar AlloyDB como fuente de datos. Luego, compilarás una aplicación de RAG interactiva de muestra que usa la caja de herramientas implementada para fundamentar sus solicitudes.

Puedes obtener más información sobre la caja de herramientas de MCP en la página de documentación y la aplicación de muestra Cymbal Air aquí.

Este lab forma parte de una colección de labs dedicados a las funciones potenciadas por IA de AlloyDB. Puedes leer más en la página de AlloyDB AI en la documentación y ver otros labs.

Requisitos previos

• Conocimientos básicos sobre la consola de Google Cloud
• Habilidades básicas de la interfaz de línea de comandos y de Google Cloud Shell

Qué aprenderás

• Cómo implementar un clúster de AlloyDB con la integración de Vertex AI
• Cómo conectarse a AlloyDB
• Cómo configurar e implementar el servicio de MCP Toolbox
• Cómo implementar una aplicación de muestra a través del servicio implementado

Requisitos

• Una cuenta de Google Cloud y un proyecto de Google Cloud
• Un navegador web, como Chrome

2. Configuración y requisitos

Configuración del entorno de autoaprendizaje

1. Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

• El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
• El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto.
• Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

Precaución: El ID del proyecto es único a nivel global y no lo puede usar nadie más después de que lo hayas seleccionado. Eres el único usuario de ese ID. Incluso si se borra un proyecto, no se puede volver a usar el ID.

Nota: Si usas una cuenta de Gmail, puedes dejar la ubicación predeterminada como Sin organización. Si usas una cuenta de Google Workspace, elige una ubicación adecuada para tu organización.

2. A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.

Inicia Cloud Shell

Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte superior derecha:

El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.

3. Antes de comenzar

Habilita la API

Resultado:

Ten en cuenta que algunos recursos que habilites generarán costos si no usas el nivel promocional. En circunstancias normales, si todos los recursos se destruyen después de completado el lab, el costo de todos los recursos no superará los USD 5. Te recomendamos revisar tu facturación y asegurarte de que el ejercicio sea aceptable para ti.

En Cloud Shell, asegúrate de que tu ID del proyecto esté configurado:

Por lo general, el ID del proyecto aparece entre paréntesis en el símbolo del sistema en Cloud Shell, como se muestra en la siguiente imagen:

gcloud config set project [YOUR-PROJECT-ID]

Luego, configura la variable de entorno PROJECT_ID para tu ID del proyecto de Google Cloud:

PROJECT_ID=$(gcloud config get-value project)

Habilita todos los servicios necesarios con el siguiente comando:

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

Resultado esperado

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

4. Implementa el clúster de AlloyDB

Crea un clúster y una instancia principal de AlloyDB. En el siguiente procedimiento, se describe cómo crear un clúster y una instancia de AlloyDB con el SDK de Google Cloud. Si prefieres el enfoque de la consola, puedes seguir la documentación aquí.

Antes de crear un clúster de AlloyDB, necesitamos un rango de IP privada disponible en nuestra VPC para que lo utilice la instancia futura de AlloyDB. Si no lo tenemos, debemos crearlo, asignarlo para que lo usen los servicios internos de Google y, luego, podremos crear el clúster y la instancia.

Crea un rango de IP privada

Nota: Este paso solo es necesario si aún no tienes un rango de IP privada sin usar asignado para trabajar con los servicios internos de Google.

Debemos establecer la configuración del acceso privado a servicios en nuestra VPC para AlloyDB. Aquí, suponemos que tenemos la red de VPC “predeterminada” en el proyecto y que se utilizará para todas las acciones.

Crea el rango de IP privada:

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

Crea una conexión privada con el rango de IP asignado:

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

Nota: El segundo comando tarda unos minutos en ejecutarse.

Resultado esperado en la consola:

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)$

Crea un clúster de AlloyDB

En esta sección, crearemos un clúster de AlloyDB en la región us-central1.

Define la contraseña para el usuario de postgres. Puedes definir tu propia contraseña o usar una función aleatoria para generar una.

export PGPASSWORD=`openssl rand -hex 12`

Resultado esperado en la consola:

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

Toma nota de la contraseña de PostgreSQL para utilizarla más adelante.

echo $PGPASSWORD

Necesitarás esa contraseña en el futuro para conectarte a la instancia como usuario de postgres. Te sugiero que la anotes o la copies en algún lugar para poder usarla más adelante.

Resultado esperado en la consola:

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

Crea un clúster de prueba gratuita

Si no has usado AlloyDB antes, puedes crear un clúster de prueba gratuito:

Define la región y el nombre del clúster de AlloyDB. Usaremos la región us-central1 y alloydb-aip-01 como nombre del clúster:

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

Ejecuta el comando para crear el clúster:

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

Resultado esperado en la consola:

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

Crea una instancia principal de AlloyDB para nuestro clúster en la misma sesión de Cloud Shell. Si te desconectas, deberás volver a definir las variables de entorno de la región y el nombre del clúster.

Nota: La creación de la instancia suele tardar entre 6 y 10 minutos en completarse.

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

Resultado esperado en la consola:

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

Crea un clúster estándar de AlloyDB

Si no es tu primer clúster de AlloyDB en el proyecto, continúa con la creación de un clúster estándar.

Define la región y el nombre del clúster de AlloyDB. Usaremos la región us-central1 y alloydb-aip-01 como nombre del clúster:

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

Ejecuta el comando para crear el clúster:

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

Resultado esperado en la consola:

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.                                                                                                                                                                                                                                                           

Crea una instancia principal de AlloyDB para nuestro clúster en la misma sesión de Cloud Shell. Si te desconectas, deberás volver a definir las variables de entorno de la región y el nombre del clúster.

Nota: La creación de la instancia suele tardar entre 6 y 10 minutos en completarse.

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

Resultado esperado en la consola:

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.                                                                                                                                                                                                                                                     

Otorga los permisos necesarios a AlloyDB

Agrega permisos de Vertex AI al agente de servicio de AlloyDB.

Abre otra pestaña de Cloud Shell con el signo "+" en la parte superior.

En la nueva pestaña de Cloud Shell, ejecuta lo siguiente:

PROJECT_ID=$(gcloud config get-value project)
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

Resultado esperado en la consola:

student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-11039]
student@cloudshell:~ (test-project-001-402417)$ gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"
Updated IAM policy for project [test-project-001-402417].
bindings:
- members:
  - serviceAccount:[e-mail]
  role: roles/aiplatform.user
- members:
...
etag: BwYIEbe_Z3U=
version: 1
 

Cierra la pestaña con el comando de ejecución “exit” en la pestaña:

exit

5. Prepara la máquina virtual de GCE

Usaremos una VM de Google Compute Engine (GCE) como plataforma para trabajar con la base de datos y, luego, implementaremos diferentes partes de la aplicación de ejemplo. Usar una VM nos brinda más flexibilidad en los componentes instalados y acceso directo a la IP privada de AlloyDB para los pasos de preparación de datos.

Crea una cuenta de servicio

Como usaremos la VM para implementar la caja de herramientas de MCP como un servicio y para implementar o alojar la aplicación de muestra, el primer paso es crear una cuenta de servicio de Google (GSA). La VM de GCE utilizará la GPU y tendremos que otorgarle los privilegios necesarios para trabajar con otros servicios.

En Cloud Shell, ejecuta lo siguiente:

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

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

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

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

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

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

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

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

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

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

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

Implementa la VM de GCE

Crea una VM de GCE en la misma región y VPC que el clúster de AlloyDB.

En Cloud Shell, ejecuta el siguiente comando:

ZONE=us-central1-a
PROJECT_ID=$(gcloud config get-value project)
gcloud compute instances create instance-1 \
    --zone=$ZONE \
    --create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --service-account=compute-aip@$PROJECT_ID.iam.gserviceaccount.com

Resultado esperado en la consola:

student@cloudshell:~ (test-project-402417)$ ZONE=us-central1-a
PROJECT_ID=$(gcloud config get-value project)
gcloud compute instances create instance-1 \
    --zone=$ZONE \
    --create-disk=auto-delete=yes,boot=yes,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" --format="value(name)") \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --service-account=compute-aip@$PROJECT_ID.iam.gserviceaccount.com
Your active configuration is: [cloudshell-10282]
Created [https://www.googleapis.com/compute/v1/projects/gleb-test-short-002-470613/zones/us-central1-a/instances/instance-1].
NAME: instance-1
ZONE: us-central1-a
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE: 
INTERNAL_IP: 10.128.0.2
EXTERNAL_IP: 34.28.55.32
STATUS: RUNNING

Instala el cliente de Postgres

Instala el software del cliente de PostgreSQL en la VM implementada

Conéctate a la VM:

Nota: La primera vez que se conecta el SSH a la VM puede tardar más, ya que el proceso incluye la creación de una clave RSA para una conexión segura y la propagación de la parte pública de la clave al proyecto.

gcloud compute ssh instance-1 --zone=us-central1-a

Resultado esperado en la consola:

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

Instala el comando de ejecución de software dentro de la VM:

sudo apt-get update
sudo apt-get install --yes postgresql-client

Resultado esperado en la consola:

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

Conéctate a la instancia de AlloyDB

Conéctate a la instancia principal desde la VM usando psql.

Continúa con la sesión abierta de SSH en tu VM. Si te desconectaste, vuelve a conectarte con el mismo comando anterior.

Usa el comando $PGASSWORD que se mencionó anteriormente y el nombre del clúster para conectarte a AlloyDB desde la VM de GCE:

export PGPASSWORD=<Noted password>

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

Resultado esperado en la consola:

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

postgres=>

Sal de la sesión de psql y mantén la conexión SSH activa:

exit

Resultado esperado en la consola:

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

6. Inicializa la base de datos

Vamos a usar la VM del cliente como una plataforma para completar la base de datos con datos y alojar la aplicación. El primer paso es crear una base de datos y completarla con datos.

Crea la base de datos

Crea una base de datos con el nombre "assistantdemo".

En la sesión de la VM de GCE, ejecuta lo siguiente:

Nota: Si se cerró tu sesión SSH, deberás restablecer las variables de entorno, como las siguientes:

export PGPASSWORD=<The noted AlloyDB password>

export REGION=us-central1

export ADBCLUSTER=alloydb-aip-01

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

psql "host=$INSTANCE_IP user=postgres" -c "CREATE DATABASE assistantdemo"  

Resultado esperado en la consola:

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

Prepara el entorno de Python

Para continuar, usaremos secuencias de comandos de Python preparadas del repositorio de GitHub, pero, antes de hacerlo, debemos instalar el software requerido.

En la VM de GCE, ejecuta lo siguiente:

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

Resultado esperado en la consola:

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 versión de Python.

En la VM de GCE, ejecuta lo siguiente:

python -V

Resultado esperado en la consola:

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

Cómo instalar MCP Toolbox de forma local

MCP Toolbox for Databases (más adelante en el texto, MCP Toolbox o Toolbox) es un servidor de MCP de código abierto que funciona con diferentes fuentes de datos. Te ayuda a desarrollar herramientas más rápido, ya que proporciona un nivel de abstracción para diferentes fuentes de datos y agrega funciones como la autenticación y la agrupación de conexiones. Puedes leer sobre todas las funciones en la página oficial.

Usaremos la caja de herramientas de MCP para iniciar nuestro conjunto de datos de muestra y, luego, para usarlo como servidor de MCP y controlar las solicitudes de fuentes de datos de nuestra aplicación durante el flujo de generación mejorada por recuperación (RAG).

Instalemos el proyecto de código abierto de MCP Toolbox de forma local para completar la base de datos de assistantdemo.

En la VM de GCE, ejecuta lo siguiente:

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

Resultado esperado en la consola:

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

Ejecuta Toolbox for Data Initialization

En la VM de GCE, ejecuta lo siguiente:

Nota: Si tu sesión SSH se cerró por inactividad o por cualquier otro motivo, debes configurar las variables de entorno como se indica a continuación:

export PGPASSWORD=<Noted password>

REGION=us-central1

ADBCLUSTER=alloydb-aip-01

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

Exporta las variables de entorno para completar la base de datos:

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

Caja de herramientas de inicio de la base de datos. Se iniciará el proceso de forma local, lo que te ayudará a conectarte sin problemas a la base de datos de destino en AlloyDB para completarla con datos de muestra.

./toolbox --prebuilt alloydb-postgres

Resultado esperado en la consola. En la última línea del resultado, deberías ver el mensaje "Server ready to serve!":

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

No salgas ni cierres esta pestaña de Cloud Shell hasta que se complete la propagación de datos.

Propaga la base de datos

Abre otra pestaña de Cloud Shell con el signo "+" en la parte superior.

Y conéctate a la VM instance-1:

gcloud compute ssh instance-1 --zone=us-central1-a

Resultado esperado en la consola:

student@cloudshell:~ (test-project-402417)$ gcloud compute ssh instance-1 --zone=us-central1-a
Linux instance-1 6.1.0-37-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Tue Sep  2 21:44:07 2025 from 35.229.111.9
student@instance-1:~$ 

Clona el repositorio de GitHub con el código del servicio de recuperación y la aplicación de muestra.

En la VM de GCE, ejecuta lo siguiente:

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

Resultado esperado en la consola:

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

Presta atención si tienes algún error.

Prepara el entorno de Python y, luego, instala los paquetes de requisitos:

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

Establece la ruta de Python en la carpeta raíz del repositorio y ejecuta la secuencia de comandos para completar la base de datos con el conjunto de datos de muestra. El primer comando agrega una ruta a nuestros módulos de Python a nuestro entorno, y el segundo comando completa nuestra base de datos con los datos.

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

Resultado esperado de la consola(oculto). Al final, deberías ver el mensaje "database init done":

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

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

Ya puedes cerrar esta pestaña.

En la sesión de la VM, ejecuta lo siguiente:

exit

En la sesión de Cloud Shell, presiona Ctrl + D o ejecuta el siguiente comando :

exit

En la primera pestaña con MCP Toolbox en ejecución, presiona Ctrl + C para salir de la sesión en ejecución de la caja de herramientas.

La base de datos se completó con datos de muestra para la aplicación.

Para verificarlo, conéctate a la base de datos y comprueba la cantidad de filas en la tabla de aeropuertos. Puedes usar la utilidad psql como lo hicimos antes o AlloyDB Studio . Aquí te mostramos cómo puedes verificarlo con psql

En la sesión SSH de la VM instance-1, ejecuta lo siguiente:

export PGPASSWORD=<Noted AlloyDB password>

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

Resultado esperado en la consola:

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

La base de datos está lista y podemos continuar con la implementación de MCP Toolbox.

7. Implementa la caja de herramientas de MCP en Cloud Run

Ahora podemos implementar la caja de herramientas de MCP en Cloud Run. Existen diferentes formas de implementar la caja de herramientas de MCP. La forma más sencilla es ejecutarlo desde la línea de comandos, pero si queremos que sea un servicio confiable y escalable, Cloud Run es una mejor solución.

Prepara el ID de cliente

Para usar la función de reserva de la aplicación, debemos preparar el ID de cliente de OAuth 2.0 con la consola de Cloud. Sin ella, no podemos acceder a la aplicación con nuestras credenciales de Google para hacer una reserva y registrarla en la base de datos.

En la consola de Cloud, ve a APIs y servicios y haz clic en "Pantalla de consentimiento de OAuth". Aquí hay un vínculo a la página. Se abrirá la página de descripción general de OAuth, en la que haremos clic en Comenzar.

En la página siguiente, proporcionamos el nombre de la aplicación y el correo electrónico de asistencia al usuario, y hacemos clic en Siguiente.

En la siguiente pantalla, elegimos Internal para nuestra aplicación y volvemos a hacer clic en Next.

Luego, volvemos a proporcionar el correo electrónico de contacto y hacemos clic en Siguiente.

Luego, aceptamos las políticas de los servicios de las APIs de Google y presionamos el botón Create.

Esto nos llevará a la página en la que podemos crear un cliente de OAuth.

En la pantalla, elegimos "Aplicación web" en el menú desplegable, ingresamos "Cymbal Air" como aplicación y presionamos el botón Agregar URI.

Los URIs representan fuentes de confianza para la aplicación y dependen de dónde intentes acceder a ella. Establecimos “http://localhost:8081” como URI autorizado y “http://localhost:8081/login/google” como URI de redireccionamiento. Esos valores funcionarían si ingresaras "http://localhost:8081" en tu navegador como URI de conexión. Por ejemplo, cuando te conectas a través de un túnel SSH desde tu computadora. Te mostraré cómo hacerlo más adelante.

Después de presionar el botón "Crear", aparecerá una ventana emergente con las credenciales de tus clientes. Las credenciales se registrarán en el sistema. Siempre puedes copiar el ID de cliente para usarlo cuando inicies tu aplicación.

Más adelante, verás dónde proporcionar ese ID de cliente.

Crea una cuenta de servicio

Necesitamos una cuenta de servicio dedicada para nuestro servicio de Cloud Run con todos los privilegios requeridos. Para nuestro servicio, necesitamos acceso a AlloyDB y a Cloud Secret Manager. En cuanto al nombre de la cuenta de servicio, usaremos toolbox-identity.

Abre otra pestaña de Cloud Shell con el signo "+" en la parte superior.

En la nueva pestaña de Cloud Shell, ejecuta lo siguiente:

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

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

Presta atención si tienes algún error. Se supone que el comando crea una cuenta de servicio para el servicio de Cloud Run y otorga privilegios para trabajar con Secret Manager, la base de datos y Vertex AI.

Cierra la pestaña presionando Ctrl + D o ejecutando el comando “exit” en la pestaña:

exit

Prepara la configuración de MCP Toolbox

Prepara el archivo de configuración para MCP Toolbox. Puedes leer sobre todas las opciones de configuración en la documentación, pero aquí usaremos el archivo de muestra tools.yaml y reemplazaremos algunos valores, como el nombre del clúster y de la instancia, la contraseña de AlloyDB y el ID del proyecto por nuestros valores reales.

Contraseña de exportación de AlloyDB:

export PGPASSWORD=<noted AlloyDB password>

ID de cliente de exportación que preparamos en el paso anterior:

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

Prepara el archivo de configuración.

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

Si observas la sección del archivo que define la fuente de datos de destino, verás que también agregamos una línea para usar la IP privada para la conexión.

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

Crea un secreto con la configuración de tools.yaml como fuente.

En la consola SSH de la VM, ejecuta lo siguiente:

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

Resultado esperado en la consola:

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

Implementa la caja de herramientas de MCP como un servicio de Cloud Run

Ahora todo está listo para implementar MCP Toolbox como un servicio en Cloud Run. Para las pruebas locales, puedes ejecutar "./toolbox –tools-file=./tools.yaml", pero si queremos que nuestra aplicación se ejecute en la nube, la implementación en Cloud Run tiene mucho más sentido.

En la sesión SSH de la VM, ejecuta lo siguiente:

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

Resultado esperado en la consola:

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

student@instance-1:~$

Verifica el servicio

Ahora podemos verificar si el servicio está activo y si podemos acceder al extremo. Usamos la utilidad de gcloud para obtener el extremo del servicio de recuperación y el token de autenticación. Como alternativa, puedes verificar el URI del servicio en la consola de Cloud.

Puedes copiar el valor y reemplazar en el comando curl la parte "$(gcloud run services list –filter="(toolbox)" –format="value(URL)" .

Sigue estos pasos para obtener la URL de forma dinámica desde la línea de comandos:

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

Resultado esperado en la consola:

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

Si vemos el mensaje "Hello World", significa que nuestro servicio está funcionando y entregando las solicitudes.

8. Implementa la aplicación de muestra

Ahora que tenemos el servicio de recuperación en funcionamiento, podemos implementar una aplicación de muestra. La aplicación representa un asistente en línea para el aeropuerto que puede brindarte información sobre vuelos y aeropuertos, e incluso reservar un vuelo según los datos de vuelos y aeropuertos de nuestra base de datos.

La aplicación se puede implementar de forma local, en una VM en la nube o en cualquier otro servicio, como Cloud Run o Kubernetes. Aquí te mostraremos cómo implementarlo primero en la VM.

Prepara el entorno

Seguimos trabajando en nuestra VM con la misma sesión de SSH. Para ejecutar nuestra aplicación, necesitamos algunos módulos de Python, que ya agregamos cuando iniciamos nuestra base de datos anteriormente. Cambiemos a nuestro entorno virtual de Python y cambiemos nuestra ubicación al directorio de la app.

En la sesión SSH de la VM, ejecuta lo siguiente:

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

Resultado esperado (oculto):

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

Ejecuta la aplicación del asistente

Antes de iniciar la aplicación, debemos configurar algunas variables de entorno. La funcionalidad básica de la aplicación, como la búsqueda de vuelos y las comodidades del aeropuerto, solo requiere TOOLBOX_URL, que dirige la aplicación al servicio de recuperación. Podemos obtenerlo con el comando de gcloud .

En la sesión SSH de la VM, ejecuta lo siguiente:

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

Resultado esperado (oculto):

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

Para usar capacidades más avanzadas de la aplicación, como reservar y cambiar vuelos, debemos acceder a la aplicación con nuestra Cuenta de Google. Para ello, debemos proporcionar la variable de entorno CLIENT_ID con el ID de cliente de OAuth del capítulo Preparar el ID de cliente:

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

Resultado esperado (oculto):

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

Ahora podemos ejecutar nuestra aplicación:

python run_app.py

Resultado esperado:

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

Conéctate a la aplicación

Tienes varias formas de conectarte a la aplicación que se ejecuta en la VM. Por ejemplo, puedes abrir el puerto 8081 en la VM usando reglas de firewall en la VPC o crear un balanceador de cargas con una IP pública. En ese caso, usaremos un túnel SSH para la VM que traduce el puerto local 8080 al puerto 8081 de la VM.

Conexión desde la máquina local

Cuando queremos conectarnos desde una máquina local, debemos ejecutar un túnel SSH. Puedes hacerlo con gcloud compute ssh:

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

Resultado esperado:

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

Ahora podemos abrir el navegador y usar http://localhost:8081 para conectarnos a nuestra aplicación. Deberíamos ver la pantalla de la aplicación.

Conéctate desde Cloud Shell

Como alternativa, podemos usar Google Cloud Shell para conectarnos. Abre otra pestaña de Cloud Shell con el signo "+" en la parte superior.

En la pestaña nueva, obtén el URI de origen y de redireccionamiento para tu cliente web ejecutando el comando de gcloud:

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

Este es el resultado esperado:

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

Usa el origen y el redireccionamiento de los URI como los "Orígenes autorizados de JavaScript" y los"URI de redireccionamiento autorizados" para nuestras credenciales creadas en el capítulo "Prepara el ID de cliente", reemplazando o agregando los valores http://localhost:8080 proporcionados originalmente.

Haz clic en "Cymbal Air" en la página IDs de cliente de OAuth 2.0.

Coloca los URIs de origen y redireccionamiento para Cloud Shell y presiona el botón Save.

En la pestaña nueva de Cloud Shell, ejecuta el comando de gcloud para iniciar el túnel hacia tu VM:

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

Se mostrará un error que dice que no se puede asignar la dirección solicitada. Ignóralo.

Este es el resultado esperado:

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

Se abrirá el puerto 8080 en Cloud Shell, que se puede usar para la "Vista previa en la Web".

Haz clic en el botón "Vista previa en la Web", en la parte superior derecha de Cloud Shell y, en el menú desplegable, selecciona "Vista previa en el puerto 8080".

Se abrirá una pestaña nueva en tu navegador web con la interfaz de la aplicación. Deberías ver la página del asistente de atención al cliente de Cymbal Air.

Accede a la aplicación

Cuando todo esté configurado y la aplicación esté abierta, podemos usar el botón "Acceder" en la parte superior derecha de la pantalla de la aplicación para proporcionar nuestras credenciales. Esto es opcional y solo se requiere si deseas probar la funcionalidad de reserva de la aplicación.

Se abrirá una ventana emergente en la que podremos elegir nuestras credenciales.

Después de acceder, la aplicación estará lista y podrás comenzar a publicar tus solicitudes en el campo que se encuentra en la parte inferior de la ventana.

En esta demostración, se muestra el asistente de atención al cliente de Cymbal Air. Cymbal Air es una aerolínea de pasajeros ficticia. El asistente es un chatbot de IA que ayuda a los viajeros a administrar vuelos y buscar información sobre el centro de Cymbal Air en el Aeropuerto Internacional de San Francisco (SFO).

Sin acceder (sin CLIENT_ID), puede ayudar a responder las siguientes preguntas de los usuarios:

¿Cuándo es el próximo vuelo a Denver?

¿Hay alguna tienda de lujo cerca de la puerta C28?

¿Dónde puedo comprar un café cerca de la puerta A6?

¿Dónde puedo comprar un regalo?

Busca un vuelo de SFO a Denver que salga hoy

Cuando accedas a la aplicación, podrás probar otras funciones, como reservar vuelos o verificar si el asiento que se te asignó es junto a la ventanilla o al pasillo.

La aplicación usa los modelos de base más recientes de Google para generar respuestas y mejorarlas con información sobre vuelos y comodidades de la base de datos operativa de AlloyDB. Puedes leer más sobre esta aplicación de demostración en la página de GitHub del proyecto.

9. Limpia el entorno

Cuando se completen todas las tareas, podremos limpiar nuestro entorno

Borra el servicio de Cloud Run

En Cloud Shell, ejecuta el siguiente comando:

gcloud run services delete toolbox --region us-central1

Resultado esperado en la consola:

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

Borra la cuenta de servicio del servicio de Cloud Run

En Cloud Shell, ejecuta el siguiente comando:

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

Resultado esperado en la consola:

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

Cuando termines el lab, destruye las instancias y el clúster de AlloyDB.

Borra el clúster de AlloyDB y todas las instancias

Si usaste la versión de prueba de AlloyDB No borres el clúster de prueba si planeas probar otros labs y recursos con él. No podrás crear otro clúster de prueba en el mismo proyecto.

El clúster se destruye con la opción force que también borra todas las instancias que pertenecen al clúster.

En Cloud Shell, define el proyecto y las variables de entorno si te desconectaste y se perdieron todos los parámetros de configuración anteriores:

gcloud config set project <your project id>

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

Borra el clúster:

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

Nota: El comando tarda entre 3 y 5 minutos en ejecutarse

Resultado esperado en la consola:

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.   

Borra las copias de seguridad de AlloyDB

Borra todas las copias de seguridad de AlloyDB del clúster:

Nota: El comando destruirá todas las copias de seguridad de datos del clúster cuyo nombre se haya especificado en la variable de entorno.

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

Resultado esperado en la consola:

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.                                                                                                                                                                                                                                                            

Ahora podemos destruir nuestra VM

Borra la VM de GCE

En Cloud Shell, ejecuta el siguiente comando:

export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet

Resultado esperado en la consola:

student@cloudshell:~ (test-project-001-402417)$ export GCEVM=instance-1
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet
Deleted 

Borra la cuenta de servicio para la VM de GCE y el servicio de recuperación

En Cloud Shell, ejecuta el siguiente comando:

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

Resultado esperado en la consola:

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

10. Felicitaciones

Felicitaciones por completar el codelab.

Temas abordados

• Cómo implementar un clúster de AlloyDB
• Cómo conectarse a AlloyDB
• Cómo configurar e implementar el servicio de MCP Toolbox
• Cómo implementar una aplicación de muestra a través del servicio implementado

11. Encuesta

Resultado:

¿Cómo usarás este instructivo?

Solo lo leeré Lo leeré y completaré los ejercicios