Accede al chat de Gemini 3 Pro 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 realizarás lo siguiente:

• Accede a la API de Gemini 3 Pro a través de Vertex con el SDK de Python
• Se ejecutará en una instancia de VM.
• La conexión se realizará a través de Cloud NAT a la Internet pública.

Luego, crearás un extremo de Private Service Connect para 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 la siguiente tarea:

• Configura la instancia de VM para usar el SDK de Python
• Conéctate 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 una subred. Abre la consola de Cloud y selecciona el proyecto que usarás.

1. Abre Cloud Shell, que se encuentra en la parte superior derecha de la consola, asegúrate de ver el ID del proyecto correcto en Cloud Shell y confirma cualquier mensaje 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 un archivo main.tf y un archivo variable.tf.

touch main.tf variable.tf 

4. Cambia a la vista del editor de Cloud Shell. Selecciona editor y asegúrate de permitir cualquier mensaje necesario para que se cargue la interfaz.
5. Una vez cargado, navega a File > Open Folder, 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. A continuación, 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 la 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" {
  project = var.project_id 
  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"
  project       = var.project_id
  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. Vuelve a la terminal de Cloud Shell, asegúrate de estar en el directorio terraform-build cd 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 tu configuración: Comprueba tu entorno para detectar lo siguiente:

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, por lo 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). Los editaremos 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. Esto 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
  project = var.project_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"
  project                            = var.project_id
  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"
  project      = var.project_id

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

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

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

  metadata_startup_script = <<-EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv git -y
    sudo apt-get install tcpdump dnsutils -y    
    
      mkdir -p ~/py-gem-env
      cd ~/py-gem-env
      python3 -m venv env
      source env/bin/activate
      pip install --upgrade pip
      pip install ipython google-genai
    '
  EOF
}

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

Verifica tu configuración: Comprueba tu entorno para detectar lo siguiente:

1 puerta de enlace NAT

1 Cloud Router

VM llamada py-vm1

5. Tarea 3: Configura VMs y realiza pruebas

1. Navega a Instancias de VM. Selecciona la VM que comienza con py-vm1. Elige SSH.
2. Una vez que establezcas la conexión SSH con py-vm1, habilita el usuario raíz escribiendo sudo -i.
3. Activa tu entorno de 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 y 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. Para ello, usaremos *-aiplatform.googleapis.com y haremos un dig a esa dirección para ver cómo se enruta el tráfico.

dig *-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 COPIAR

; <<>> DiG 9.18.41-1~deb12u1-Debian <<>> *-aiplatform.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 60947
;; flags: qr rd ra; QUERY: 1, ANSWER: 16, AUTHORITY: 0, ADDITIONAL: 1

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

;; ANSWER SECTION:
*-aiplatform.googleapis.com. 300 IN     A       173.194.216.95
*-aiplatform.googleapis.com. 300 IN     A       108.177.11.95
*-aiplatform.googleapis.com. 300 IN     A       192.178.219.95
*-aiplatform.googleapis.com. 300 IN     A       74.125.134.95
*-aiplatform.googleapis.com. 300 IN     A       74.125.139.95
*-aiplatform.googleapis.com. 300 IN     A       108.177.12.95
*-aiplatform.googleapis.com. 300 IN     A       173.194.210.95
*-aiplatform.googleapis.com. 300 IN     A       74.125.26.95
*-aiplatform.googleapis.com. 300 IN     A       173.194.212.95
*-aiplatform.googleapis.com. 300 IN     A       172.217.204.95

9. Ahora, usemos Python. Escribe ipython para activar la interfaz de 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 "¿Cuál es el color del cielo" .

from google import genai
from google.genai import types
import os
import sys

LOCATION = "global"
MODEL_ID = "gemini-3-pro-preview" 

try:
    client = genai.Client(vertexai=True, location=LOCATION)
    print(f"Successfully initialized Google Gen AI Client (Vertex AI mode) in {LOCATION}")
except Exception as e:
    print(f"Error initializing client: {e}")
    print("Ensure you have installed the library: `pip install google-genai`")
    print("And authenticated: `gcloud auth application-default login`")
    sys.exit(1)

class SimpleChatSession:
    def __init__(self, model_id):
        self.model_id = model_id
        self.history = [] 

    def send_message(self, prompt, stream=True):
        user_content = types.Content(
            role="user",
            parts=[types.Part(text=prompt)]
        )
        self.history.append(user_content)

        try:
            response_stream = client.models.generate_content_stream(
                model=self.model_id,
                contents=self.history,
                config=types.GenerateContentConfig(
                    temperature=0.7 
                )
            )

            accumulated_text = ""
            
            for chunk in response_stream:
                if chunk.text:
                    yield chunk.text
                    accumulated_text += chunk.text
            
            model_content = types.Content(
                role="model",
                parts=[types.Part(text=accumulated_text)]
            )
            self.history.append(model_content)

        except Exception as e:
            print(f"\n[Error during generation: {e}]")

def get_chat_response(session: SimpleChatSession, prompt: str):
    print(f"\n--- User: {prompt} ---")
    print("--- Model: ", end="")
    
    stream_generator = session.send_message(prompt)
    
    full_text = ""
    for chunk_text in stream_generator:
        full_text += chunk_text
        print(chunk_text, end="", flush=True)

    print() 
    return full_text

if __name__ == "__main__":
    chat_session = SimpleChatSession(MODEL_ID)

    get_chat_response(chat_session, "Hello.")
    get_chat_response(chat_session, "What are all the colors of the Google logo?")
    get_chat_response(chat_session, "What color is the sky?")

11. Presiona Intro dos veces para ejecutar 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.

6. Tarea 4: Crea el extremo de PSC para 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 asignemos para enrutar el tráfico a las APIs de Google que necesitamos, en este caso, Vertex.

1. Si aún no está abierto, abre Cloud Shell en la vista del editor. Crearemos lo siguiente:

• Crea una IP para el extremo de 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 estar en la carpeta terraform-build. Luego, ejecuta terraform init y terraform plan. Verás 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: Crea una entrada de DNS manual para googleapis con Terraform

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

1. Navega a Servicios de red y selecciona Cloud DNS.
2. En las zonas, deberías ver una zona creada automáticamente para Private Service Connect para las APIs de Google, con el tipo de zona de directorio de servicios. Se puede usar para conectarse al extremo de PSC con el formato **SERVICE-ENDPOINT.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 restrínsela 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. Si aún no está abierto, abre Cloud Shell en la vista del editor. 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 estar en la carpeta terraform-build. Luego, ejecuta terraform plan. Esto 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 un CNAME como este: consulta
7. A continuación, verificamos la conectividad con estos cambios en py-vm1.

8. Tarea 6: Verifica la conectividad del extremo a través de la dirección IP

Conectémonos a Gemini a través del extremo privado.

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

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. Verifica la ruta de conectividad a aiplatform.googleapis.com con el comando ping. Esto hará ping a la dirección IP en el DNS privado, registro A para googleapis. Esta IP es un extremo de PSC, y tus pings no se realizarán correctamente.

ping -c 2 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 tendrán éxito.

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

5. Verifica la ruta de conectividad a aiplatform.googleapis.com con el comando dig. Debe ser la dirección IP del extremo de PSC.

dig aiplatform.googleapis.com

6. Regresa a la consola y abre otra instancia de VM py-vm1. Selecciona SSH y establece una conexión SSH con 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 aiplatform.googleapis.com

9. Ahora, vuelve a la primera instancia de SSH de la instancia de VM py-vm1.
10. Activa el entorno con el siguiente comando:

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. Aquí se le pide a Gemini que responda "En una oración breve, resume qué es un tokenizador en el contexto de la IA" y "¿Las ballenas son increíbles o no?".

from google import genai
from google.genai import types
import os
import sys

LOCATION = "global"
MODEL_ID = "gemini-3-pro-preview" 

try:
    client = genai.Client(vertexai=True, location=LOCATION)
    print(f"Successfully initialized Google Gen AI Client (Vertex AI mode) in {LOCATION}")
except Exception as e:
    print(f"Error initializing client: {e}")
    print("Ensure you have installed the library: `pip install google-genai`")
    print("And authenticated: `gcloud auth application-default login`")
    sys.exit(1)

class SimpleChatSession:
    def __init__(self, model_id):
        self.model_id = model_id
        self.history = [] 

    def send_message(self, prompt, stream=True):
        user_content = types.Content(
            role="user",
            parts=[types.Part(text=prompt)]
        )
        self.history.append(user_content)

        try:
            response_stream = client.models.generate_content_stream(
                model=self.model_id,
                contents=self.history,
                config=types.GenerateContentConfig(
                    temperature=0.7 
                )
            )

            accumulated_text = ""
            
            for chunk in response_stream:
                if chunk.text:
                    yield chunk.text
                    accumulated_text += chunk.text
            
            model_content = types.Content(
                role="model",
                parts=[types.Part(text=accumulated_text)]
            )
            self.history.append(model_content)

        except Exception as e:
            print(f"\n[Error during generation: {e}]")

def get_chat_response(session: SimpleChatSession, prompt: str):
    print(f"\n--- User: {prompt} ---")
    print("--- Model: ", end="")
    
    stream_generator = session.send_message(prompt)
    
    full_text = ""
    for chunk_text in stream_generator:
        full_text += chunk_text
        print(chunk_text, end="", flush=True)

    print() 
    return full_text

if __name__ == "__main__":
    chat_session = SimpleChatSession(MODEL_ID)

    get_chat_response(chat_session, "Hello.")
    get_chat_response(chat_session, "In one short sentence summarize what is a tokenizer in the context of AI?")
    get_chat_response(chat_session, "Are whales awesome or not?")

13. Presiona Intro dos veces para ejecutar y ver el resultado.
14. Vuelve a la segunda instancia de VM Instance py-vm1. Deberías ver el resultado de TCPDUMP. Observarás que la dirección IP de la VM usa la dirección IP del extremo de PSC para conectarse a aiplatform.googleapis.com.

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

9. Limpieza

1. Ve a Cloud Shell y asegúrate de estar en el directorio terraform-build cd terraform-build.
2. Ejecuta terraform plan destroy para ver todos los cambios que se realizarán.

terraform plan -destroy

3. Luego, ejecuta el comando terraform destroy y, luego, escribe yes para quitar todos los recursos que creaste en tu proyecto con Terraform.

terraform destroy 

10. Felicitaciones

¡Felicitaciones! Te conectaste correctamente a Vertex y usaste Gemini 3 Pro a través de la dirección de la API pública 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én conectados 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 Claude de Anthropic 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 las redes en Google Cloud
• Explorador de IA generativa - Vertex AI
• IA agentiva en Google Cloud