Accede al chat de Gemini con el SDK de Python a través del extremo de Private Service Connect

1. Descripción general

Se puede acceder a la API de Vertex AI a través de Internet. Sin embargo, en tu empresa, es posible que desees acceder a la API de Vertex AI de forma privada sin usar Internet. En este lab, primero accederás a la API de chat de Vertex Gemini a través del SDK de Python que se ejecuta en una instancia de VM a través de Internet pública.

Luego, crearás un extremo de Private Service Connect a las APIs de Google y cambiarás el flujo de tráfico para usar el extremo privado y conectarte a la API de chat de Gemini. Las configuraciones serán una combinación de Terraform, gcloud y la consola.

En este lab, crearás el siguiente patrón.

Figura 1.

2. Objetivo

En este lab, aprenderás a realizar las siguientes tareas:

• Configura la instancia de VM para usar el SDK de Python
• Cómo conectarse a Gemini Chat a través de una secuencia de comandos de Python
• Configura el extremo de PSC para conectarte a Googleapis
• Verifica la ruta de conectividad a Googleais
• Configura entradas de DNS manuales

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. Tarea 1: Configura el entorno con Terraform

Crearemos una VPC personalizada con reglas de firewall y subred. Abre la consola de Cloud y selecciona el proyecto que usarás.

1. Abre Cloud Shell, que se encuentra en la parte superior de la consola a la derecha, asegúrate de ver el ID del proyecto correcto en Cloud Shell y confirma las indicaciones para permitir el acceso.
2. Crea una carpeta llamada terraform-build y muévela a la carpeta

mkdir terraform-build  && cd terraform-build

3. Crea los archivos main.tf y variable.tf.

touch main.tf variable.tf 

4. Cambia a la vista del editor de Cloud Shell. Selecciona editor y asegúrate de permitir las indicaciones necesarias para que se cargue la interfaz.
5. Una vez cargado, navega a File > Open Folder y ve a /home/your-user-name/terraform-build y selecciona Ok para abrir la carpeta en el editor.
6. Selecciona el archivo variable.tf y agrega lo siguiente. Reemplaza el texto your-project-id-here por el ID de tu proyecto real entre comillas.

variable "project_id" {
  type = string
  default = "your-project-id-here"
}

variable "network_id" {
  type = string
  default = "python-net"
}

7. Luego, abre el archivo main.tf. Agregaremos código de Terraform para realizar varias acciones, como se explica a continuación.

Habilita las APIs	resource "google_project_service" "default"
Crea una VPC llamada python-net	resource "google_compute_network" "default"
Agrega una subred	resource "google_compute_subnetwork" "default"
Agrega dos reglas de firewall	resource "google_compute_firewall" "allow_icmp"resource "google_compute_firewall" "allow_ssh"

8. Copia y pega lo siguiente en el archivo main .tf.

resource "google_project_service" "default" {
  for_each = toset([
    "dns.googleapis.com",
    "aiplatform.googleapis.com",
    "servicedirectory.googleapis.com"
  ])

  service            = each.value
  disable_on_destroy = false
}

resource "google_compute_network" "default" {
  project                 = var.project_id
  name                    = var.network_id
  auto_create_subnetworks = false
  mtu                     = 1460
  routing_mode            = "GLOBAL"
}

resource "google_compute_subnetwork" "default" {
  name          = "vm1-subnet"
  ip_cidr_range = "10.0.11.0/24"
  region        = "us-east1"
  stack_type    = "IPV4_ONLY"
  network       = google_compute_network.default.id
}

resource "google_compute_firewall" "allow_icmp" {
  name    = "allow-icmp-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "icmp"
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-icmp"]
}

resource "google_compute_firewall" "allow_ssh" {
  name    = "allow-ssh-${google_compute_network.default.name}"
  network = google_compute_network.default.id
  project = var.project_id

  allow {
    protocol = "tcp"
    ports    = ["22"]
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["allow-ssh"]
}

9. Regresa a la terminal de Cloud Shell, asegúrate de que te encuentras en el directorio cd terraform-build terraform-build y ejecuta los siguientes comandos:

terraform init

Inicializa el directorio de trabajo. En este paso, se descargan los proveedores necesarios para la configuración determinada.

terraform plan

Genera un plan de ejecución que muestra las acciones que Terraform realizará para implementar tu infraestructura.

10. Ahora, para crear los recursos, ejecuta el comando terraform apply y escribe yes para ejecutarlo.

Verifica la configuración: Comprueba si tu entorno tiene los siguientes problemas:

1 VPC llamada python-net

1 subred

2 firewall-rules

4. Tarea 2. Crea una puerta de enlace NAT y VMs con Terraform

Debemos otorgar acceso externo saliente a Internet, así que crearemos una puerta de enlace de Cloud NAT y la adjuntaremos.

1. Abre Cloud Shell, navega a la carpeta terraform-build y crea los siguientes archivos (tres en total). Editaremos estos datos más adelante.

touch nat-vm.tf psc.tf dns.tf

2. Cambia a la vista del editor de Cloud Shell, selecciona el archivo nat-vm.tf y agrega el siguiente código de Terraform. De esta forma, se creará una puerta de enlace NAT y dos VMs.

Terraform nat-vm.tf

resource "google_compute_router" "default" {
  name    = "py-outbound-nat"
  region  = "us-east1"
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name                               = "py-outbound-nat-gw"
  router                             = google_compute_router.default.name
  region                             = google_compute_router.default.region
  nat_ip_allocate_option             = "AUTO_ONLY"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"

  log_config {
    enable = true
    filter = "ERRORS_ONLY"
  }
}

resource "google_compute_instance" "vm1" {
  name         = "py-vm1"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  network_interface {
    subnetwork = google_compute_subnetwork.default.id  
    stack_type = "IPV4_ONLY"
  }

  tags = ["allow-ssh", "allow-icmp"]

  metadata_startup_script = <<-EOF
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv -y
    sudo apt-get install tcpdump dnsutils -y
    sudo -i
    sudo mkdir -p ~/py-gem-env
    cd ~/py-gem-env
    python3 -m venv env
    source env/bin/activate
    pip install ipython google-cloud-aiplatform
  EOF
}

resource "google_compute_instance" "vm2" {
  name         = "py-vm2"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  network_interface {
    subnetwork = google_compute_subnetwork.default.id   
    stack_type = "IPV4_ONLY"
  }

  tags = ["allow-ssh", "allow-icmp"]

  metadata_startup_script = <<-EOF
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv -y
    sudo apt-get install tcpdump dnsutils -y
    sudo -i
    sudo mkdir -p ~/py-gem-env
    cd ~/py-gem-env
    python3 -m venv env
    source env/bin/activate
    pip install ipython google-cloud-aiplatform
  EOF
}

3. Cambia a la terminal de Cloud Shell, asegúrate de estar en la carpeta terraform-build y ejecuta terraform plan. Se mostrará que se agregarán 4 elementos. Luego, ejecuta terraform apply y escribe yes para crear la puerta de enlace de NAT y dos VMs.

Verifica la configuración: Comprueba si tu entorno tiene los siguientes problemas:

1 puerta de enlace NAT

1 router de nube

VM con el nombre py-vm1

VM con el nombre py-vm2

5. Tarea 3: Configura las VMs y realiza pruebas

1. Navega a las instancias de VM. Selecciona la VM que comienza con py-vm1. Elige SSH.
2. Una vez que establezcas una conexión SSH a py-vm1, escribe sudo -i para habilitar el usuario raíz.
3. Activa tu entorno venv:

cd py-gem-env
source env/bin/activate

4. Ahora, autentiquemos esto para realizar algunas pruebas más adelante. Ejecuta el siguiente comando en la VM y presiona y cuando se te solicite.

gcloud auth application-default login

5. A continuación, copia la URL que aparece en el mensaje que comienza con https://, abre una pestaña nueva en la ventana del navegador del lab y pega la URL. Acepta las instrucciones.
6. Cuando veas el siguiente mensaje, selecciona "Copiar", vuelve a la sesión de la VM py-vm1 y, en Enter authorization code:, pega el código que copiaste y presiona Intro para autenticarte.

7. Ahora, hagamos una prueba rápida para ver si podemos conectarnos a la API de Vertex Gemini, que usa us-central1-aiplatform.googleapis.com, por lo que haremos un dig a esa dirección para ver cómo se enruta el tráfico.

dig us-central1-aiplatform.googleapis.com

8. Deberías ver algo similar (la dirección será diferente). Ten en cuenta que la ruta es a través de direcciones IP públicas, ya que la API es pública. NO COPIES

; <<>> DiG 9.16.48-Debian <<>> us-central1-aiplatform.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 9117
;; flags: qr rd ra; QUERY: 1, ANSWER: 16, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;us-central1-aiplatform.googleapis.com. IN A

;; ANSWER SECTION:
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.210.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.211.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.212.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.213.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.215.95
us-central1-aiplatform.googleapis.com. 300 IN A 173.194.216.95
us-central1-aiplatform.googleapis.com. 300 IN A 108.177.12.95
us-central1-aiplatform.googleapis.com. 300 IN A 108.177.13.95
us-central1-aiplatform.googleapis.com. 300 IN A 74.125.26.95

9. Ahora, usemos Python. Escribe ipython para activar la interfaz ipython.

ipython

10. Ahora copia y pega lo siguiente. Esto le pregunta a Gemini "¿Cuáles son todos los colores del logotipo de Google?" y "¿De qué color es el cielo?" . Reemplaza enter-your-project-id-here por el ID de tu proyecto entre comillas.

import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "What color is the sky?"
print(get_chat_response(chat_session, prompt))

11. Presiona Intro para ejecutarlo y ver el resultado.
12. Esta solicitud accedió a Vertex a través de la API pública.
13. Cierra la sesión de SSH y continuemos.

Nota: Puedes modificar la pregunta de la instrucción por otra.

Ahora, configura py-vm2 con las mismas configuraciones

14. Navega a las instancias de VM. Selecciona la VM que comienza con py-vm2. Elige SSH.
15. Una vez que establezcas una conexión SSH a py-vm2, escribe **sudo -i** para habilitar el usuario raíz.
16. Activa tu entorno venv:

cd py-gem-env
source env/bin/activate

17. Ahora, autentiquemos esto para realizar algunas pruebas más adelante. Ejecuta el siguiente comando en la VM:

gcloud auth application-default login

18. A continuación, copia la URL que aparece en el mensaje que comienza con https://, abre una pestaña nueva en la ventana del navegador del lab y pega la URL. Acepta las instrucciones.
19. Cuando veas el siguiente mensaje, selecciona "Copiar", vuelve a la sesión de la VM py-vm2 y, en Enter authorization code:, pega el código que copiaste y presiona Intro para autenticarte.

20. Ahora, hagamos una prueba rápida para ver si podemos conectarnos a la API de Vertex Gemini. Este comando usará 4 pings a us-central1-aiplatform.googleapis.com para que obtengamos una respuesta de la dirección pública de la API.

ping -c 4 us-central1-aiplatform.googleapis.com

21. Volveremos a probar esta VM más adelante. Cierra la sesión de SSH y continuemos.

6. Tarea 4: Crea el extremo de PSC a googleapis con Terraform

Para habilitar la conectividad privada a nuestro extremo de la API de Vertex, crearemos un extremo de Private Service Connect para las APIs de Google. Esto nos permitirá usar una dirección IP privada que asignaremos para enrutar el tráfico a las APIs de Google que necesitamos, en este caso, Vertex.

1. Abre Cloud Shell en la vista de editor si aún no está abierto. Crearemos lo siguiente:

• Crea una IP para el extremo PSC 192.168.255.250 (resource "google_compute_global_address" "default")
• Crea un extremo de PSC para las APIs de Google (resource "google_compute_global_forwarding_rule" "default")

Abre el archivo psc.tf en la carpeta terraform-build. Agrega el siguiente código al archivo.

Terraform psc.tf

resource "google_compute_global_address" "default" {
  name         = "vertex-ip"
  purpose      = "PRIVATE_SERVICE_CONNECT"
  network      = google_compute_network.default.id
  address_type = "INTERNAL"
  address      = "192.168.255.250"
}

resource "google_compute_global_forwarding_rule" "default" {  
  name                  = "pscvertexgemini"
  target                = "all-apis"
  network               = google_compute_network.default.id
  ip_address            = google_compute_global_address.default.id
  load_balancing_scheme = ""
  }

2. Cambia a la terminal de Cloud Shell y asegúrate de que te encuentras en la carpeta terraform-build. Luego, ejecuta terraform init y, luego, terraform plan. Se mostrará que se agregarán 2 elementos.
   Luego, ejecuta terraform apply y escribe yes para crear el extremo de las APIs de Google de IP y PSC.
3. Verifica que exista el extremo

gcloud compute addresses list --filter="name=( 'vertex-ip' ...)"

gcloud compute forwarding-rules describe pscvertexgemini --global

7. Tarea 5. Verifica la conectividad del extremo a través de la dirección IP

Conectémonos con el extremo privado para conectarnos a Gemini.

1. Ve a la instancia de VM py-vm1. Selecciona SSH y establece una conexión SSH a la VM
2. Para obtener acceso raíz, escribe sudo -i.
3. Solo usaremos esta instancia individual para probar el extremo de PSC, por lo que modificaremos el archivo host con la siguiente entrada:

echo 192.168.255.250 us-central1-aiplatform.googleapis.com >> /etc/hosts

cat /etc/hosts

Nota: Se agregará una entrada estática que asignará la dirección us-central1-aiplatform.googleapis.com a la IP del extremo de PSC.

4. Verifica la ruta de conectividad a us-central1-aiplatform.googleapis.com con el comando ping. Se enviará un ping a la dirección IP que ingresaste en los archivos host. Este es un extremo de PSC, por lo que tus pings no se realizarán correctamente.

ping -c 2 us-central1-aiplatform.googleapis.com

5. Regresa a la consola y abre otra instancia de la instancia de VM py-vm1. Selecciona SSH y establece una conexión SSH a la VM.
6. Para obtener acceso raíz, escribe sudo -i.
7. Ejecuta el siguiente comando para ver la conectividad en un volcado de TCP.

sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com

8. Ahora, vuelve a la primera instancia de SSH de la instancia de VM py-vm1.
9. Activa el entorno con

cd py-gem-env
source env/bin/activate

10. Ahora probemos Python. Escribe ipython para activar la interfaz de ipython. Esta vez, el tráfico fluirá a través del extremo del PSC.

ipython

11. Ahora copia y pega lo siguiente. Esto le pregunta a Gemini "¿Cuáles son todos los colores del logotipo de Google?" y "Describe las Cataratas del Niágara". Reemplaza enter-your-project-id-here por el ID de tu proyecto entre comillas.

import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  # Corrected line

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "Describe Niagara Falls"
print(get_chat_response(chat_session, prompt))

12. Presiona Intro para ejecutar la fórmula y ver el resultado.
13. Regresa a la segunda instancia de la instancia de VM py-vm1. Deberías ver el resultado de TCPDUMP. Verás las entradas y salidas con las direcciones IP de la VM y también la dirección IP del extremo de PSC para conectarte a us-central1-aiplatform.googleapis.com.

22:21:55.032433 ens4  Out IP 10.0.11.18.57114 > 192.168.255.250.443: Flags [.], ack 8606, win 501, options [nop,nop,TS val 1797790182 ecr 2593039209], length 0
22:21:55.468285 ens4  In  IP 192.168.255.250.443 > 10.0.11.18.57114: Flags [P.], seq 8606:8991, ack 5785, win 296, options [nop,nop,TS val 2593039645 ecr 1797790182], length 385
22:21:55.468320 ens4  Out IP 10.0.11.18.57114 > 192.168.255.250.443: Flags [.], ack 8991, win 501, options [nop,nop,TS val 1797790618 ecr 2593039645], length 0

14. Cierra todas las sesiones de SSH a la instancia de VM py-vm1.

8. Tarea 6. Crea una entrada de DNS manual en googleapis con Terraform (opcional)

Puedes crear una entrada de DNS manual para dirigirla al extremo de PSC con el DNS privado. Esto afectaría a todas las redes que le asignes.

1. Navega a Servicios de red y selecciona Cloud DNS.
2. En Zonas, deberías ver una zona creada automáticamente para Private Service Connect para las APIs de Google, con el directorio de servicios de tipo de zona. Se puede usar para conectarse al extremo de PSC con el formato **EXTREMO-DE-SERVICIO.p.googleapis.com. Ejemplo: aiplatform-pscvertexgemini.p.googleapis.com
3. En este caso, queremos crear manualmente una entrada de DNS privada. La configuración será la siguiente:

• Crea una zona de DNS privada llamada "googleapis-private" para "googleapis.com" y resérvala a la red "python-net".
• Agrega un registro A para asignar "googleapis.com" a la dirección IP "192.168.255.250".
• Agrega un registro CNAME para redireccionar todos los subdominios de “googleapis.com” (p.ej., www.googleapis.com) a “googleapis.com”.

4. Abre Cloud Shell en la vista de editor si aún no está abierto. Abre el archivo dns.tf en la carpeta terraform-build. Agrega el siguiente código al archivo.

Terraform dns.tf

resource "google_dns_managed_zone" "private_zone" {
  name        = "googleapis-private"
  dns_name    = "googleapis.com."  
  visibility  = "private"
  project     = var.project_id     

  private_visibility_config {
    networks {
      network_url = google_compute_network.default.id  
    }
  }
}

resource "google_dns_record_set" "a_record" {
  name    = "googleapis.com."  
  type    = "A"
  ttl     = 300
  managed_zone = google_dns_managed_zone.private_zone.name
  project = var.project_id    

  rrdatas = ["192.168.255.250"]
}

resource "google_dns_record_set" "cname_record" {
 name    = "*.googleapis.com."
 type    = "CNAME"
 ttl     = 300
 managed_zone = google_dns_managed_zone.private_zone.name
 project = var.project_id    

 rrdatas = ["googleapis.com."]  
}

5. Cambia a la terminal de Cloud Shell y asegúrate de que te encuentras en la carpeta terraform-build. Luego, ejecuta terraform plan, que te mostrará qué elementos se agregarán.
   Luego, ejecuta terraform apply y escribe yes para crear la entrada de DNS privada.
6. Deberías ver una configuración con un registro A y CNAME como este, consulta
7. A continuación, verificamos la conectividad con estos cambios en py-vm2.

9. Tarea 7. Verifica la conectividad del extremo a través de la dirección IP (opcional)

Conectémonos con el extremo privado para conectarnos a Gemini.

Nota: No es necesario realizar configuraciones manuales en la VM.

1. Ve a la instancia de VM py-vm2. Selecciona SSH y establece una conexión SSH a la VM
2. Para obtener acceso raíz, escribe sudo -i.
3. Verifica la ruta de conectividad a us-central1-aiplatform.googleapis.com con el comando ping. Esto enviará un ping a la dirección IP en el DNS privado, el registro A de googleapis. Esta IP es un extremo de PSC, por lo que tus pings no se realizarán correctamente.

ping -c 2 us-central1-aiplatform.googleapis.com

4. Verifica la ruta de conectividad con un ping usando la entrada de DNS creada automáticamente para las APIs de Google de PSC con aiplatform-pscvertexgemini.p.googleapis.com. Esto apunta a la dirección IP del extremo de PSC, y tus pings no se realizarán correctamente.

ping -c 2 aiplatform-pscvertexgemini.p.googleapis.com

5. Verifica la ruta de conectividad a us-central1-aiplatform.googleapis.com con el comando dig. Esta debe ser la dirección IP del extremo de PSC.

dig us-central1-aiplatform.googleapis.com

6. Regresa a la consola y abre otra instancia de la instancia de VM py-vm2. Selecciona SSH y establece una conexión SSH a la VM.
7. Para obtener acceso raíz, escribe sudo -i.
8. Ejecuta el siguiente comando para ver la conectividad en un volcado de TCP:

sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com

9. Ahora, vuelve a la primera instancia de SSH de la instancia de VM py-vm2.
10. Activa el entorno con

cd py-gem-env
source env/bin/activate

11. Ahora probemos Python. Escribe ipython para activar la interfaz de ipython.

ipython

12. Ahora copia y pega lo siguiente. Esto le pregunta a Gemini "¿Cuáles son todos los colores del logotipo de Google?" y "¿Cuáles son dos funciones de Gemini Pro?". Reemplaza enter-your-project-id-here por el ID de tu proyecto entre comillas.

import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  # Corrected line

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "What are two features of Gemini pro"
print(get_chat_response(chat_session, prompt))

13. Presiona Intro para ejecutar la fórmula y ver el resultado.
14. Regresa a la segunda instancia de la instancia de VM py-vm2. Deberías ver el resultado del TCPDUMP. Verás las entradas y salidas, y la dirección IP de la VM usará la dirección IP del extremo de PSC para conectarse a us-central1-aiplatform.googleapis.com.

Cierra todas las sesiones de SSH a la instancia de VM py-vm2.

10. Realiza una limpieza

1. Ve a Cloud Shell, asegúrate de estar en el directorio terraform-build cd terraform-build y ejecuta el siguiente comando terraform destroy y escribe yes. Se quitarán todos los recursos que creaste en tu proyecto con Terraform.

11. Felicitaciones

¡Felicitaciones! Te conectaste correctamente al chat de Vertex Gemini con la dirección pública de la API y de forma privada con el extremo de Private Service Connect para las APIs de Google. Esta funcionalidad puede extender la conectividad de la API privada a tu entorno local o de otra nube que esté conectado a través de (Interconnect, Cross-Cloud Interconnect y VPC).

Próximos pasos y más información

Puedes obtener más información sobre las redes de Vertex AI.

Codelab: Accede a Anthropic Claude en Vertex AI con el SDK de Python a través del extremo de Private Service Connect

Realiza tu próximo lab

Continúa tu Quest con Google Cloud y consulta estos otros labs de Google Cloud Skills Boost:

• Conceptos básicos de redes en Google Cloud
• Explorador de IA generativa: Vertex AI