Sobre este codelab
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.
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
- 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.
- 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.
- 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:
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:
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.
- 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.
- Crie uma pasta chamada terraform-build e mova para a pasta
mkdir terraform-build && cd terraform-build
- Crie um arquivo main.tf e variable.tf.
touch main.tf variable.tf
- 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.
- 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.
- 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" }
- 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 |
|
Criar VPC chamada python-net |
|
Adicionar uma sub-rede |
|
Adicionar duas regras de firewall |
|
- 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"] }
- 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.
- Agora, para criar os recursos, execute o comando
terraform apply
e digiteyes
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.
- 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
- 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
}
- 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, executeterraform apply
e digiteyes
para criar o gateway NAT e duas VMs.
5. Tarefa 3: Configurar VMs e testar
- Acesse as instâncias de VM. Selecione a VM que começa com py-vm1. Escolha SSH.
- Depois de usar o SSH para acessar py-vm1,ative o root digitando
sudo -i
. - Ative o ambiente venv:
cd py-gem-env
source env/bin/activate
- 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
- 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.
- 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.
- 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
- 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
- Agora vamos usar o Python. Digite
ipython
para ativar a interface ipython.
ipython
- 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))
- Pressione Enter para executar e conferir o resultado.
- Essa solicitação acessou a Vertex pela API pública.
- Feche a sessão SSH e vamos continuar.
Agora configure o py-vm2 com as mesmas configurações
- Acesse as instâncias de VM. Selecione a VM que começa com py-vm2. Escolha SSH.
- Depois de usar SSH para acessar py-vm2-****, ative o root digitando **
sudo -i
** - Ative o ambiente venv:
cd py-gem-env
source env/bin/activate
- Agora vamos autenticar isso para fazer alguns testes mais tarde. Execute o seguinte comando na VM:
gcloud auth application-default login
- 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.
- 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.
- 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
- 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.
- 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 = ""
}
- Mude para o terminal do Cloud Shell e verifique se você está na pasta
terraform-build
. Em seguida, executeterraform init
. Em seguida, executeterraform plan
. Isso vai mostrar que dois itens serão adicionados.
Em seguida, executeterraform apply
e digiteyes
para criar o endpoint das APIs do Google para IP e PSC. - 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.
- Acesse a instância de VM py-vm1. Selecione SSH e SSH na VM
- Tenha acesso raiz digitando
sudo -i
- 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
- 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
- Volte ao console e abra outra instância de VM py-vm1. Selecione SSH e use o SSH na VM.
- Tenha acesso raiz digitando
sudo -i
- 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
- Agora volte para a primeira instância SSH da instância de VM py-vm1.
- Ativar o ambiente usando
cd py-gem-env
source env/bin/activate
- 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
- 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))
- Pressione Enter para executar e conferir o resultado.
- 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
- 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.
- Acesse "Serviços de rede" e selecione "Cloud DNS".
- 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
- 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".
- 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."]
}
- Mude para o terminal do Cloud Shell e verifique se você está na pasta
terraform-build
. Em seguida, executeterraform plan
para mostrar quais itens serão adicionados.
Em seguida, executeterraform apply
e digiteyes
para criar a entrada DNS particular. - Você vai encontrar uma configuração com um registro A e CNAME como este:
- 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.
- Acesse a instância de VM py-vm2. Selecione SSH e SSH na VM
- Tenha acesso raiz digitando
sudo -i
- 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
- Verifique o caminho de conectividade com um
ping
usando a entrada DNS criada automaticamente para as APIs do Google PSC comaiplatform-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
- 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
- Volte ao console e abra outra instância de VM py-vm2. Selecione SSH e use o SSH na VM.
- Tenha acesso raiz digitando
sudo -i
- 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
- Agora volte para a primeira instância SSH da instância de VM py-vm2.
- Ativar o ambiente usando
cd py-gem-env
source env/bin/activate
- Agora vamos testar o Python. Digite
ipython
para ativar a interface do ipython.
ipython
- 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))
- Pressione Enter para executar e conferir o resultado.
- 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
- Acesse o Cloud Shell, verifique se você está no diretório terraform-build
cd terraform-build
e execute o seguinte comandoterraform destroy
e digiteyes
. 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: