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 API Google i zmienisz przepływ ruchu, aby używać prywatnego punktu końcowego do łączenia się z interfejsem API rozmowy z Gemini. 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 rozmową z Gemini za pomocą skryptu w Pythonie
  • Konfigurowanie punktu końcowego PSC w celu połączenia z Googleapis
  • Sprawdzanie ś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 ani 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ę tym 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 bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Uruchamianie Cloud Shell

Z Google Cloud można korzystać zdalnie na laptopie, 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

Uzyskanie dostępu do środowiska i połączenie się z nim powinno zająć tylko kilka chwil. Po zakończeniu powinno wyświetlić się coś takiego:

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 również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces 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 bramę Cloud NAT i dołączmy ją.

  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 uprawnienia 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. Zaakceptuj prompty.
  2. Gdy zobaczysz poniższy komunikat, wybierz kopiowanie, 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 przeprowadzimy 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 jest kierowany 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 języka Python. 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 naszym 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 katalog usług. 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ć prywatny wpis 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 przypisać „googleapis.com” do adresu 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
    . Potem 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 ze 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ą przez 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 to 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ć połączenie 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ą fajne?”.
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ć i wyświetlić wynik.
  2. Wróć do drugiej instancji maszyny wirtualnej py-vm1. Powinien się wyświetlić wynik polecenia 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 i 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 przez połączenie międzysieciowe, połączenie międzychmurowe i 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: