Acessar o chat do Gemini com o SDK Python pelo endpoint do Private Service Connect

Acessar o chat do Gemini com o SDK Python pelo endpoint do Private Service Connect

Sobre este codelab

subjectÚltimo out. 29, 2024 atualizado
account_circleEscrito por Ammett Williams & Sampath Kumar Maddula

1. Visão geral

A API Vertex AI pode ser acessada pela Internet. No entanto, na sua empresa, talvez você queira acessar a API Vertex AI de forma particular, sem passar pela Internet. Neste laboratório, você vai acessar a API de chat Vertex Gemini usando o SDK Python em execução em uma instância de VM pela Internet pública.

Em seguida, você vai criar um endpoint do Private Service Connect para as APIs do Google e mudar o fluxo de tráfego para usar o endpoint privado e se conectar à API de chat Gemini. As configurações serão uma combinação do Terraform, da gcloud e do console.

Neste laboratório, você vai criar o seguinte padrão.

Figura 1.

8b283cc5684283c2.png

2. Objetivo

Neste laboratório, você vai aprender a fazer o seguinte:

  • Configurar a instância de VM para usar o SDK do Python
  • Conectar-se ao Gemini Chat usando um script Python
  • Configurar o endpoint do PSC para se conectar ao Googleapis
  • Verificar o caminho de conectividade para o Googleais
  • Configurar entradas DNS manuais

Configuração de ambiente autoguiada

  1. Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

fbef9caa1602edd0.png

a99b7ace416376c4.png

5e3ff691252acf41.png

  • O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
  • O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
  • Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.
  1. Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.

No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:

55efc1aaa7a4d3ad.png

O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:

7ffe5cbb04455448.png

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.

3. Tarefa 1: Configurar o ambiente com o Terraform

Vamos criar uma VPC personalizada com regras de firewall e sub-rede. Abra o console do Cloud e selecione o projeto que você vai usar.

  1. Abra o Cloud Shell, localizado na parte de cima do console, à direita. Verifique se o ID do projeto correto aparece no Cloud Shell e confirme as solicitações para permitir o acesso. 4261e776f64ea978.png
  2. Crie uma pasta chamada terraform-build e mova para a pasta
mkdir terraform-build  && cd terraform-build
  1. Crie um arquivo main.tf e variable.tf.
touch main.tf variable.tf 
  1. Mude para a visualização do editor do Cloud Shell. Selecione editor e permita todas as solicitações necessárias para que a interface possa ser carregada.
  2. Depois de carregar, navegue até File > Open Folder e acesse /home/your-user-name/terraform-build e selecione Ok para abrir a pasta no editor. 78f5eb9f2f82f1b0.png
  3. Selecione o arquivo variable.tf e adicione o seguinte. Substitua o texto your-project-id-here pelo ID do seu projeto real entre aspas
variable "project_id" {
  type = string
  default = "your-project-id-here"
}

variable "network_id" {
  type = string
  default = "python-net"
}
  1. Em seguida, abra o arquivo main.tf. Vamos adicionar um código do Terraform para realizar várias ações, conforme explicado abaixo.

Ativar as APIs

resource "google_project_service" "default"

Criar VPC chamada python-net

resource "google_compute_network" "default"

Adicionar uma sub-rede

resource "google_compute_subnetwork" "default"

Adicionar duas regras de firewall

resource "google_compute_firewall" "allow_icmp"resource "google_compute_firewall" "allow_ssh"

  1. Copie e cole o seguinte no arquivo 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"]
}
  1. Volte para o terminal do Cloud Shell, verifique se você está no diretório cd terraform-build terraform-build e execute os comandos a seguir.

terraform init

Inicializa o diretório de trabalho. Esta etapa faz o download dos provedores necessários para a configuração.

terraform plan

Gera um plano de execução, mostrando quais ações o Terraform vai realizar para implantar sua infraestrutura.

  1. Agora, para criar os recursos, execute o comando terraform apply e digite yes para executar.

4. Tarefa 2: Criar gateway NAT e VMs com o Terraform

Precisamos conceder acesso externo de saída à Internet. Portanto, vamos criar um gateway do Cloud NAT e anexá-lo.

  1. Abra o Cloud Shell, navegue até a pasta terraform-build e crie os seguintes arquivos (total de três arquivos). Vamos editar isso mais tarde.
touch nat-vm.tf psc.tf dns.tf
  1. Mude para a visualização do editor do Cloud Shell, selecione o arquivo nat-vm.tf e adicione o código do Terraform a seguir. Isso vai criar um gateway NAT e duas 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
}
  1. Mude para o terminal do Cloud Shell, verifique se você está na pasta terraform-build e execute terraform plan. Isso vai mostrar que quatro itens serão adicionados. Em seguida, execute terraform apply e digite yes para criar o gateway NAT e duas VMs.

5. Tarefa 3: Configurar VMs e testar

  1. Acesse as instâncias de VM. Selecione a VM que começa com py-vm1. Escolha SSH.
  2. Depois de usar o SSH para acessar py-vm1,ative o root digitando sudo -i.
  3. Ative o ambiente venv:
cd py-gem-env
source env
/bin/activate
  1. Agora vamos autenticar isso para fazer alguns testes mais tarde. Execute o comando a seguir na VM e pressione y quando solicitado.
gcloud auth application-default login
  1. Em seguida, copie o URL que aparece começando com https://, abra uma nova guia na janela do navegador do laboratório e cole o URL. Aceite as solicitações.
  2. Quando você receber a mensagem de seleção de cópia, volte para a sessão de vm py-vm1 e, em Inserir código de autorização, cole o código copiado e pressione Enter para autenticar.

c29615cdf9324209.png

  1. Agora vamos fazer um teste rápido para saber se podemos nos conectar à API Vertex Gemini, que usa us-central1-aiplatform.googleapis.com. Vamos fazer uma dig para esse endereço e conferir como o tráfego é roteado.
dig us-central1-aiplatform.googleapis.com
  1. Você vai encontrar algo semelhante (o endereço será diferente). Observe que o caminho é por endereços IP públicos, já que a API é pública. NÃO COPIAR
; <<>> 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
  1. Agora vamos usar o Python. Digite ipython para ativar a interface ipython.
ipython

4685b31f13df54e1.png

  1. Agora copie e cole o seguinte. Isso faz com que o Gemini pergunte Qual é a cor do céu e Quais são todas as cores do logotipo do Google. Substitua enter-your-project-id-here pelo ID do projeto nas aspas.
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))
  1. Pressione Enter para executar e conferir o resultado.
  2. Essa solicitação acessou a Vertex pela API pública.
  3. Feche a sessão SSH e vamos continuar.

Agora configure o py-vm2 com as mesmas configurações

  1. Acesse as instâncias de VM. Selecione a VM que começa com py-vm2. Escolha SSH.
  2. Depois de usar SSH para acessar py-vm2-****, ative o root digitando **sudo -i**
  3. Ative o ambiente venv:
cd py-gem-env
source env
/bin/activate
  1. Agora vamos autenticar isso para fazer alguns testes mais tarde. Execute o seguinte comando na VM:
gcloud auth application-default login
  1. Em seguida, copie o URL que aparece começando com https://, abra uma nova guia na janela do navegador do laboratório e cole o URL. Aceite as solicitações.
  2. Quando você receber a mensagem de seleção de cópia a seguir, volte para a sessão de VM py-vm2 e, em Inserir código de autorização, cole o código copiado e pressione Enter para autenticar.

c29615cdf9324209.png

  1. Agora vamos fazer um teste rápido para saber se podemos nos conectar à API Vertex Gemini. Esse comando vai usar quatro pings para us-central1-aiplatform.googleapis.com, para que possamos receber uma resposta do endereço público da API.
ping -c 4 us-central1-aiplatform.googleapis.com
  1. Vamos testar essa VM mais tarde. Feche a sessão SSH e vamos continuar.

6. Tarefa 4: Criar o endpoint do PSC para googleapis com o Terraform

Para ativar a conectividade particular com o endpoint da API Vertex, vamos criar um endpoint do Private Service Connect para as APIs do Google. Isso nos permite usar um endereço IP particular que atribuímos para rotear o tráfego para as APIs do Google necessárias, neste caso, a Vertex.

  1. Abra o Cloud Shell na visualização do editor, se ainda não estiver aberto. Vamos criar o seguinte:
  • Crie um IP para o endpoint do PSC 192.168.255.250 (resource "google_compute_global_address" "default")
  • Criar um endpoint do PSC para APIs do Google (resource "google_compute_global_forwarding_rule" "default")

Abra o arquivo psc.tf na pasta terraform-build. Adicione o seguinte código ao arquivo.

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
= ""
 
}
  1. Mude para o terminal do Cloud Shell e verifique se você está na pasta terraform-build. Em seguida, execute terraform init. Em seguida, execute terraform plan. Isso vai mostrar que dois itens serão adicionados.
    Em seguida, execute terraform apply e digite yes para criar o endpoint das APIs do Google para IP e PSC.
  2. Verificar se o endpoint existe
gcloud compute addresses list --filter="name=( 'vertex-ip' ...)"
gcloud compute forwarding-rules describe pscvertexgemini --global

7. Tarefa 5: Verificar a conectividade do endpoint pelo endereço IP

Vamos nos conectar usando o endpoint particular para se conectar ao Gemini.

  1. Acesse a instância de VM py-vm1. Selecione SSH e SSH na VM
  2. Tenha acesso raiz digitando sudo -i
  3. Vamos usar essa instância individual para testar o endpoint do PSC, então vamos modificar o arquivo de host com a seguinte entrada:
echo 192.168.255.250 us-central1-aiplatform.googleapis.com >> /etc/hosts

cat
/etc/hosts
  1. Verifique o caminho de conectividade para us-central1-aiplatform.googleapis.com usando o comando ping. Isso vai fazer um ping no endereço IP que você inseriu nos arquivos de host. Este é um endpoint do PSC, e seus pings não vão ser bem-sucedidos.
ping -c 2 us-central1-aiplatform.googleapis.com
  1. Volte ao console e abra outra instância de VM py-vm1. Selecione SSH e use o SSH na VM.
  2. Tenha acesso raiz digitando sudo -i
  3. Execute o comando de acompanhamento para conferir a conectividade em um dump TCP.
sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com
  1. Agora volte para a primeira instância SSH da instância de VM py-vm1.
  2. Ativar o ambiente usando
cd py-gem-env
source env
/bin/activate
  1. Agora vamos testar o Python. Digite ipython para ativar a interface do ipython. Dessa vez, o tráfego vai passar pelo endpoint do PSC.
ipython
  1. Agora copie e cole o seguinte. Isso faz com que o Gemini pergunte Quais são todas as cores do logotipo do Google? e Descreva as Cataratas do Niágara. Substitua enter-your-project-id-here pelo ID do projeto nas aspas.
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))
  1. Pressione Enter para executar e conferir o resultado.
  2. Volte para a segunda instância da VM py-vm1. Você vai ver o resultado do TCPDUMP. Você vai notar a entrada e a saída com os endereços IP da VM e também o endereço IP do endpoint do PSC para se conectar 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
  1. Feche todas as sessões SSH para a instância de VM py-vm1.

8. Tarefa 6: Criar uma entrada DNS manual para googleapis com o Terraform (opcional)

É possível criar uma entrada DNS manual para apontar para o endpoint do PSC usando o DNS particular. Isso afetaria todas as redes que você atribui a ele.

  1. Acesse "Serviços de rede" e selecione "Cloud DNS".
  2. Nas zonas, você vai encontrar uma zona criada automaticamente para o Private Service Connect para APIs do Google, com o tipo de zona "diretório de serviços". Ele pode ser usado para se conectar ao endpoint do PSC com o formato **SERVICE-ENDPOINT.p.googleapis.com Exemplo: aiplatform-pscvertexgemini.p.googleapis.com
  3. Neste caso, queremos criar manualmente uma entrada de DNS particular. A configuração será a seguinte:
  • Crie uma zona de DNS particular chamada "googleapis-private" para "googleapis.com" e restrinja-a à rede "python-net".
  • Adicione um registro A para mapear "googleapis.com" ao endereço IP "192.168.255.250".
  • Adicione um registro CNAME para redirecionar todos os subdomínios de "googleapis.com" (por exemplo, www.googleapis.com) para "googleapis.com".
  1. Abra o Cloud Shell na visualização do editor, se ainda não estiver aberto. Abra o arquivo dns.tf na pasta terraform-build. Adicione o seguinte código ao arquivo.

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."]  
}
  1. Mude para o terminal do Cloud Shell e verifique se você está na pasta terraform-build. Em seguida, execute terraform plan para mostrar quais itens serão adicionados.
    Em seguida, execute terraform apply e digite yes para criar a entrada DNS particular.
  2. Você vai encontrar uma configuração com um registro A e CNAME como este: b7f122f0d1fd2850.png
  3. Em seguida, verificamos a conectividade com essas mudanças no py-vm2.

9. Tarefa 7: Verificar a conectividade do endpoint pelo endereço IP (opcional)

Vamos nos conectar usando o endpoint particular para se conectar ao Gemini.

  1. Acesse a instância de VM py-vm2. Selecione SSH e SSH na VM
  2. Tenha acesso raiz digitando sudo -i
  3. Verifique o caminho de conectividade para us-central1-aiplatform.googleapis.com usando o comando ping. Isso vai fazer um ping no endereço IP no DNS particular, registro A para googleapis. Esse IP é um endpoint do PSC, e seus pings não vão ser bem-sucedidos.
ping -c 2 us-central1-aiplatform.googleapis.com
  1. Verifique o caminho de conectividade com um ping usando a entrada DNS criada automaticamente para as APIs do Google PSC com aiplatform-pscvertexgemini.p.googleapis.com. Isso aponta para o endereço IP do endpoint do PSC, e seus pings não vão ser bem-sucedidos.
ping -c 2 aiplatform-pscvertexgemini.p.googleapis.com
  1. Verifique o caminho de conectividade para us-central1-aiplatform.googleapis.com usando o comando dig. Esse deve ser o endereço IP do endpoint do PSC.
dig us-central1-aiplatform.googleapis.com
  1. Volte ao console e abra outra instância de VM py-vm2. Selecione SSH e use o SSH na VM.
  2. Tenha acesso raiz digitando sudo -i
  3. Execute o comando de acompanhamento para conferir a conectividade em um despejo TCP.
sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com
  1. Agora volte para a primeira instância SSH da instância de VM py-vm2.
  2. Ativar o ambiente usando
cd py-gem-env
source env
/bin/activate
  1. Agora vamos testar o Python. Digite ipython para ativar a interface do ipython.
ipython
  1. Agora copie e cole o seguinte. Isso faz com que o Gemini pergunte Quais são todas as cores do logotipo do Google? e Quais são dois recursos do Gemini Pro?. Substitua enter-your-project-id-here pelo ID do projeto nas aspas.
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))
  1. Pressione Enter para executar e conferir o resultado.
  2. Volte para a segunda instância da VM py-vm2. Você vai ver o resultado do TCPDUMP. Você vai notar que o endereço IP da VM está usando o endereço IP do endpoint do PSC para se conectar a us-central1-aiplatform.googleapis.com.

Feche todas as sessões SSH para a instância de VM py-vm2.

10. Limpeza

  1. Acesse o Cloud Shell, verifique se você está no diretório terraform-build cd terraform-build e execute o seguinte comando terraform destroy e digite yes. Todos os recursos que você criou no projeto com o Terraform serão removidos.

11. Parabéns

Parabéns! Você se conectou ao chat do Vertex Gemini usando o endereço da API pública e o endpoint do Private Service Connect para APIs do Google. Essa funcionalidade pode estender a conectividade de API privada ao seu ambiente local/outra nuvem conectado por (Interconnect, Cross-Cloud Interconnect e VPC).

Próximas etapas / Saiba mais

Saiba mais sobre a rede da Vertex AI.

Codelab: Acessar o Anthropic Claude na Vertex AI com o SDK do Python pelo endpoint do Private Service Connect

Comece o próximo laboratório

Continue sua jornada com o Google Cloud e confira estes outros laboratórios do Google Cloud Ensina: