Dostęp do czatu Gemini 3 Pro za pomocą pakietu SDK w języku Python przez punkt końcowy Private Service Connect

1. Przegląd

Do interfejsu Vertex AI API można uzyskać dostęp przez internet, ale w firmie możesz chcieć korzystać z niego prywatnie, bez połączenia z internetem. W tym module najpierw:

  • Dostęp do interfejsu Gemini 3 Pro API w Vertex za pomocą pakietu SDK w Pythonie
  • Będzie on działać na instancji maszyny wirtualnej.
  • Połączenie będzie nawiązywane przez Cloud NAT z publicznym internetem.

Następnie utworzysz punkt końcowy usługi Private Service Connect dla interfejsów Google API i zmienisz przepływ ruchu, aby używać prywatnego punktu końcowego do łączenia się z interfejsem Gemini Chat API. Konfiguracje będą połączeniem Terraform, gcloud i konsoli.

W tym module utworzysz ten wzorzec.

Rysunek 1.

304c579d349aec90.png

2. Cel

Z tego modułu dowiesz się, jak:

  • Konfigurowanie instancji maszyny wirtualnej do korzystania z pakietu Python SDK
  • Łączenie się z Gemini Chat za pomocą skryptu w Pythonie
  • Skonfiguruj punkt końcowy PSC, aby połączyć się z Googleapis
  • Weryfikowanie ścieżki połączenia z Googleais
  • Konfigurowanie ręcznych wpisów DNS

Samodzielne konfigurowanie środowiska

  1. Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail lub Google Workspace, musisz je utworzyć.

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

  • Nazwa projektu to wyświetlana nazwa uczestników tego projektu. Jest to ciąg znaków, który nie jest używany przez interfejsy API Google. Zawsze możesz ją zaktualizować.
  • Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić po ustawieniu. Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie musisz się nim przejmować. W większości ćwiczeń z programowania musisz odwoływać się do identyfikatora projektu (zwykle oznaczanego jako PROJECT_ID). Jeśli wygenerowany identyfikator Ci się nie podoba, możesz wygenerować inny losowy identyfikator. Możesz też spróbować własnej nazwy i sprawdzić, czy jest dostępna. Po tym kroku nie można go zmienić i pozostaje on taki przez cały czas trwania projektu.
  • Warto wiedzieć, że istnieje też trzecia wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.
  1. Następnie musisz włączyć płatności w konsoli Cloud, aby korzystać z zasobów i interfejsów API Google Cloud. Wykonanie tego laboratorium nie będzie kosztować dużo, a może nawet nic. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub projekt. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.

Uruchamianie Cloud Shell

Google Cloud można obsługiwać zdalnie z laptopa, ale w tym module praktycznym będziesz używać Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.

W konsoli Google Cloud kliknij ikonę Cloud Shell na pasku narzędzi w prawym górnym rogu:

Aktywowanie Cloud Shell

Udostępnienie środowiska i połączenie się z nim może zająć tylko kilka chwil. Po zakończeniu powinny pojawić się dane wyjściowe podobne do tych:

Zrzut ekranu terminala Google Cloud Shell pokazujący, że środowisko zostało połączone

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelniania. Wszystkie zadania w tym laboratorium możesz wykonać w przeglądarce. Nie musisz niczego instalować.

3. Zadanie 1. Konfigurowanie środowiska za pomocą Terraform

Utworzymy niestandardową sieć VPC z regułami zapory sieciowej i podsiecią. Otwórz konsolę Google Cloud i wybierz projekt, którego będziesz używać.

  1. Otwórz Cloud Shell w prawym górnym rogu konsoli. Sprawdź, czy w Cloud Shell widzisz prawidłowy identyfikator projektu, i potwierdź wszystkie prośby o przyznanie dostępu. b51b80043d3bac90.png
  2. Utwórz folder o nazwie terraform-build i przejdź do niego.
mkdir terraform-build  && cd terraform-build
  1. Utwórz pliki main.tf i variable.tf.
touch main.tf variable.tf
  1. Przełącz się na widok edytora Cloud Shell. Wybierz edytor i zaakceptuj wszystkie niezbędne prośby, aby interfejs mógł się załadować.
  2. Po załadowaniu przejdź do Plik > Otwórz folder i otwórz folder /home/your-user-name/terraform-build. Następnie kliknij OK, aby otworzyć folder w edytorze. 39b3eb9a3e077bfd.png
  3. Wybierz plik variable.tf i dodaj do niego te informacje: Zastąp tekst your-project-id-here rzeczywistym identyfikatorem projektu w cudzysłowie.
variable "project_id" {
  type = string
  default = "your-project-id-here"
}

variable "network_id" {
  type = string
  default = "python-net"
}
  1. Następnie otwórz plik main.tf. Dodamy kod Terraform, aby wykonać różne działania opisane poniżej.

Włączanie interfejsów API

resource "google_project_service" "default"

Utwórz sieć VPC o nazwie python-net

resource "google_compute_network" "default"

Dodawanie podsieci

resource "google_compute_subnetwork" "default"

Dodaj 2 reguły zapory sieciowej

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

  1. Skopiuj poniższy kod i wklej go do pliku 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"]
}
  1. Wróć do terminala Cloud Shell i upewnij się, że jesteś w katalogu terraform-build cd terraform-build. Następnie uruchom te polecenia:

terraform init

Inicjuje katalog roboczy. Ten krok pobiera dostawców wymaganych w danej konfiguracji.

terraform plan

Generuje plan wykonania, który pokazuje, jakie działania Terraform podejmie w celu wdrożenia infrastruktury.

  1. Aby utworzyć zasoby, uruchom polecenie terraform apply i wpisz yes.

4. Zadanie 2. Tworzenie bramy NAT i maszyn wirtualnych za pomocą Terraform

Musimy przyznać wychodzący dostęp zewnętrzny do internetu, więc utwórzmy i dołączmy bramę Cloud NAT.

  1. Otwórz Cloud Shell, przejdź do folderu terraform-build i utwórz te pliki (w sumie 3 pliki). Później je edytujemy.
touch nat-vm.tf psc.tf dns.tf
  1. Przejdź do widoku edytora Cloud Shell, wybierz plik nat-vm.tf i dodaj ten kod Terraform. Spowoduje to utworzenie bramy NAT i 2 maszyn wirtualnych.

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
}
  1. Przejdź do terminala Cloud Shell, upewnij się, że jesteś w folderze terraform-build, i uruchom polecenie terraform plan. Wyświetli ono informację, że zostaną dodane 4 elementy. Następnie uruchom polecenie terraform apply i wpisz yes, aby utworzyć bramę NAT i maszynę wirtualną.

5. Zadanie 3. Konfigurowanie maszyn wirtualnych i testowanie

  1. Otwórz Instancje maszyn wirtualnych. Wybierz maszynę wirtualną zaczynającą się od py-vm1. Wybierz SSH.
  2. Po połączeniu się z instancją py-vm1 przez SSH włącz dostęp do roota,wpisując sudo -i.
  3. Aktywuj środowisko venv:
cd py-gem-env
source env/bin/activate
  1. Teraz uwierzytelnijmy to, aby później przeprowadzić testy. Uruchom w maszynie wirtualnej to polecenie i po wyświetleniu monitu naciśnij y.
gcloud auth application-default login
  1. Następnie skopiuj adres URL zaczynający się od https://, otwórz nową kartę w oknie przeglądarki laboratorium i wklej adres URL. Postępuj zgodnie z wyświetlanymi instrukcjami.
  2. Gdy zobaczysz poniższy komunikat, wybierz opcję kopiowania, wróć do sesji maszyny wirtualnej py-vm1 i w sekcji Enter authorization code: (Wpisz kod autoryzacji:) wklej skopiowany kod i naciśnij Enter, aby się uwierzytelnić.

b703db7aa2aa286a.png

  1. Teraz przeprowadźmy szybki test, aby sprawdzić, czy możemy połączyć się z interfejsem Vertex API. Używa on domeny *-aiplatform.googleapis.com, więc wykonamy polecenie dig na ten adres, aby sprawdzić, jak kierowany jest ruch.
dig *-aiplatform.googleapis.com
  1. Powinien pojawić się ekran podobny do tego (adres będzie inny). Pamiętaj, że ścieżka prowadzi przez publiczne adresy IP, ponieważ interfejs API jest publiczny. NIE KOPIUJ
; <<>> 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
  1. Teraz użyjemy Pythona. Wpisz ipython, aby aktywować interfejs ipython.
ipython

845ef4291429888a.png

  1. Teraz skopiuj i wklej poniższy tekst. W ten sposób zadajesz Gemini pytania „Jakie są wszystkie kolory logo Google” i „Jaki jest kolor nieba”.
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?")
  1. Naciśnij dwukrotnie Enter, aby uruchomić kod i zobaczyć wynik.
  2. To żądanie uzyskało dostęp do Vertex za pomocą publicznego interfejsu API.
  3. Zamknij sesję SSH i przejdź dalej.

6. Zadanie 4. Tworzenie punktu końcowego PSC dla googleapis za pomocą Terraform

Aby włączyć prywatną łączność z punktem końcowym interfejsu Vertex API, utworzymy punkt końcowy usługi Private Service Connect dla interfejsów API Google. Dzięki temu będziemy mogli używać przypisanego przez nas prywatnego adresu IP do kierowania ruchu do potrzebnych nam interfejsów API Google, w tym przypadku Vertex.

  1. Otwórz Cloud Shell w widoku edytora, jeśli nie jest jeszcze otwarty. Utworzymy te elementy:
  • Utwórz adres IP dla punktu końcowego PSC 192.168.255.250 (resource "google_compute_global_address" "default")
  • Tworzenie punktu końcowego PSC dla interfejsów API Google (resource "google_compute_global_forwarding_rule" "default")

Otwórz plik psc.tf w folderze terraform-build. Dodaj do pliku ten kod.

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. Przejdź do terminala Cloud Shell i upewnij się, że jesteś w folderze terraform-build. Następnie uruchom terraform init Następnie uruchom terraform plan, aby zobaczyć, że zostaną dodane 2 elementy,
    a potem uruchom terraform apply i wpisz yes, aby utworzyć punkt końcowy interfejsów API Google IP i PSC.
  2. Sprawdzanie, czy punkt końcowy istnieje
gcloud compute addresses list --filter="name=( 'vertex-ip' ...)"

gcloud compute forwarding-rules describe pscvertexgemini --global

7. Zadanie 5. Tworzenie ręcznego wpisu DNS do googleapis za pomocą Terraform

Możesz utworzyć ręczny wpis DNS, aby wskazywał punkt końcowy PSC przy użyciu prywatnego DNS. Będzie to miało wpływ na wszystkie sieci, które do niej przypiszesz.

  1. Przejdź do Usług sieciowych i wybierz Cloud DNS.
  2. W strefach powinna być widoczna automatycznie utworzona strefa usługi Private Service Connect dla interfejsów API Google o typie strefy Service Directory. Możesz go użyć do połączenia się z punktem końcowym PSC w formacie **SERVICE-ENDPOINT.p.googleapis.com. Przykład: aiplatform-pscvertexgemini.p.googleapis.com
  3. W tym przypadku chcemy ręcznie utworzyć wpis prywatnego serwera DNS. Konfiguracja będzie wyglądać tak:
  • Utwórz prywatną strefę DNS o nazwie „googleapis-private” dla domeny „googleapis.com” i ogranicz ją do sieci „python-net”.
  • Dodaj rekord A, aby zmapować „googleapis.com” na adres IP „192.168.255.250”.
  • Dodaj rekord CNAME, aby przekierować wszystkie subdomeny domeny „googleapis.com” (np. www.googleapis.com) na „googleapis.com”.
  1. Otwórz Cloud Shell w widoku edytora, jeśli nie jest jeszcze otwarty. Otwórz plik dns.tf w folderze terraform-build. Dodaj do pliku ten kod.

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. Przejdź do terminala Cloud Shell i upewnij się, że jesteś w folderze terraform-build. Następnie uruchom terraform plan, aby zobaczyć, które elementy zostaną dodane.
    Następnie uruchom terraform apply i wpisz yes, aby utworzyć prywatny wpis DNS.
  2. Powinna pojawić się konfiguracja z rekordem A i CNAME, jak pokazano na ilustracji 6d2fc061460cd983.png.
  3. Następnie sprawdzamy połączenie z tymi zmianami na instancji py-vm1.

8. Zadanie 6. Sprawdzanie łączności punktu końcowego za pomocą adresu IP

Połączmy się z Gemini za pomocą prywatnego punktu końcowego.

  1. Otwórz instancję maszyny wirtualnej py-vm1. Wybierz SSH i połącz się z maszyną wirtualną za pomocą SSH
  2. Uzyskaj dostęp do roota, wpisując sudo -i
  3. Sprawdź ścieżkę połączenia z adresem aiplatform.googleapis.com za pomocą polecenia ping. Spowoduje to wysłanie polecenia ping na adres IP w prywatnym DNS, rekord A dla googleapis. Ten adres IP to punkt końcowy PSC, więc pingi nie będą działać.
ping -c 2 aiplatform.googleapis.com
  1. Sprawdź ścieżkę połączenia za pomocą ping, korzystając z automatycznie utworzonego wpisu DNS dla interfejsów API Google PSC z aiplatform-pscvertexgemini.p.googleapis.com. Wskazuje on adres IP punktu końcowego PSC, a pingi będą nieudane.
ping -c 2 aiplatform-pscvertexgemini.p.googleapis.com
  1. Sprawdź ścieżkę połączenia z adresem aiplatform.googleapis.com za pomocą polecenia dig. Powinien to być adres IP punktu końcowego PSC.
dig aiplatform.googleapis.com
  1. Wróć do konsoli i otwórz kolejną instancję maszyny wirtualnej py-vm1. Wybierz SSH i połącz się z maszyną wirtualną przez SSH.
  2. Uzyskaj dostęp do roota, wpisując sudo -i
  3. Aby sprawdzić łączność w zrzucie TCP, uruchom to polecenie:
sudo tcpdump -i any port 53 -n or host aiplatform.googleapis.com
  1. Teraz wróć do pierwszej instancji SSH maszyny wirtualnej py-vm1.
  2. Aktywuj środowisko za pomocą
cd py-gem-env
source env/bin/activate
  1. Teraz przetestujmy Pythona. Wpisz ipython, aby aktywować interfejs ipython.
ipython
  1. Teraz skopiuj i wklej poniższy tekst. W tym przypadku Gemini odpowie na pytania „W jednym krótkim zdaniu podsumuj, czym jest tokenizacja w kontekście AI” i „Czy wieloryby są super?”.
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?")
  1. Naciśnij dwukrotnie Enter, aby uruchomić kod i zobaczyć wynik.
  2. Wróć do drugiej instancji maszyny wirtualnej py-vm1. Powinien się wyświetlić wynik TCPDUMP. Zauważysz, że adres IP maszyny wirtualnej używa adresu IP punktu końcowego PSC do łączenia się z aiplatform.googleapis.com.

Zamknij wszystkie sesje SSH na maszynie wirtualnej py-vm1.

9. Czyszczenie

  1. Otwórz Cloud Shell i upewnij się, że jesteś w katalogu terraform-build. cd terraform-build
  2. Uruchom polecenie terraform plan destroy, aby zobaczyć wszystkie zmiany, które zostaną wprowadzone.
terraform plan -destroy
  1. Następnie uruchom polecenie terraform destroy, a potem wpisz yes. Wszystkie zasoby utworzone w projekcie za pomocą Terraform zostaną usunięte.
terraform destroy

10. Gratulacje

Gratulacje. Udało Ci się połączyć z Vertex i użyć Gemini 3 Pro za pomocą publicznego adresu API oraz prywatnie przy użyciu punktu końcowego Private Service Connect dla interfejsów API Google. Ta funkcja może rozszerzyć łączność z prywatnymi interfejsami API na środowisko lokalne lub inne środowisko w chmurze, które są połączone za pomocą połączenia Interconnect, połączenia międzychmurowego i sieci VPC.

Kolejne kroki / Więcej informacji

Więcej informacji o sieci Vertex AI

Codelab: Uzyskiwanie dostępu do Anthropic Claude w Vertex AI za pomocą pakietu Python SDK przez punkt końcowy Private Service Connect

Przejdź do kolejnego modułu

Kontynuuj naukę o Google Cloud i zapoznaj się z tymi modułami Google Cloud Skills Boost: