Ta strona została przetłumaczona przez Cloud Translation API.

Dostęp do czatu z Gemini za pomocą pakietu SDK Pythona przez punkt końcowy Private Service Connect

1. Omówienie

Do interfejsu Vertex AI API można uzyskać dostęp przez internet, ale w Twojej firmie możesz chcieć uzyskać dostęp do interfejsu Vertex AI API prywatnie, bez korzystania z internetu. W tym laboratorium najpierw uzyskasz dostęp do interfejsu API czatu Vertex Gemini za pomocą pakietu sterownika Pythona działającego w instancji maszyny wirtualnej przez publiczny internet.

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

W tym laboratorium utworzysz ten wzór.

Rysunek 1.

2. Cel

Z tego modułu dowiesz się, jak wykonać te czynności:

Konfigurowanie maszyny wirtualnej do korzystania z pakietu SDK Pythona
Łączenie z Gemini Chat za pomocą skryptu Pythona
Konfigurowanie punktu końcowego PSC do połączenia z Googleapis
Sprawdzanie ścieżki łączności z Googleais
Konfigurowanie ręcznych wpisów DNS

Konfiguracja środowiska w samodzielnym tempie

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ć.

Nazwa projektu to wyświetlana nazwa uczestników tego projektu. Jest to ciąg znaków, którego nie używają interfejsy API Google. Zawsze możesz ją zaktualizować.
Identyfikator projektu jest niepowtarzalny w ramach wszystkich projektów Google Cloud i nie można go zmienić (po ustawieniu). Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie ma znaczenia, jaki to ciąg. W większości laboratoriów z kodem musisz podać identyfikator projektu (zwykle oznaczony jako PROJECT_ID). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować inny losowy. Możesz też spróbować użyć własnego adresu e-mail, aby sprawdzić, czy jest on dostępny. Nie można go zmienić po wykonaniu tego kroku. Pozostanie on do końca projektu.
Informacyjnie: istnieje jeszcze 3 wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.

Następnie musisz włączyć rozliczenia w konsoli Cloud, aby korzystać z zasobów i interfejsów API Cloud. Przejście przez ten samouczek nie będzie kosztowne, a być może nawet bezpłatne. Aby wyłączyć zasoby i uniknąć obciążenia opłatami po zakończeniu samouczka, możesz usunąć utworzone zasoby lub usunąć 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

Google Cloud można obsługiwać zdalnie z laptopa, ale w tym ćwiczeniu 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:

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

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 poprawia wydajność sieci i uwierzytelnianie. Wszystkie zadania w tym CodeLab 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ć.

Otwórz Cloud Shell, który znajduje się u góry konsoli po prawej stronie. Upewnij się, że w Cloud Shell jest widoczny prawidłowy identyfikator projektu. Potwierdź wyświetlone prośby o dostęp.
Utwórz folder o nazwie terraform-build i przenieś go do folderu

mkdir terraform-build  && cd terraform-build

Utwórz pliki main.tf i variable.tf.

touch main.tf variable.tf

Przełącz się na widok Edytor Cloud Shell. Wybierz Edytor i potwierdź wszystkie wymagane prompty, aby umożliwić wczytanie interfejsu.
Po załadowaniu przejdź do Plik > Otwórz folder, przejdź do folderu /home/nazwa_użytkownika/terraform-build i kliknij OK, aby otworzyć folder w edytorze.
Wybierz plik variable.tf i dodaj 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"
}

Następnie otwórz plik main.tf. Dodamy kod terraform, aby wykonać różne działania, jak wyjaśniono 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"`
*Dodaj podsieć*	`resource` `"google_compute_subnetwork"` `"default"`
*Dodaj 2 reguły zapory sieciowej*	`resource` `"google_compute_firewall"` `"allow_icmp"resource` `"google_compute_firewall"` `"allow_ssh"`

Skopiuj i wklej ten kod do głównego pliku .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"]
}

Wróć do terminala Cloud Shell i upewnij się, że jesteś w katalogu cd terraform-build terraform-build. Następnie uruchom te polecenia.

terraform init

Inicjuje katalog roboczy. Na tym etapie pobierani są dostawcy wymagani w danej konfiguracji.

terraform plan

Tworzy plan wykonania, który pokazuje, jakie działania Terraform wykona, aby wdrożyć Twoją infrastrukturę.

Aby utworzyć zasoby, uruchom polecenie terraform apply i wpisz yes, aby je uruchomić.

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

Musimy przyznać zewnętrzny dostęp do internetu, więc utwórzmy bramę Cloud NAT i dodaj ją.

Otwórz Cloud Shell, przejdź do folderu terraform-build i utwórz te pliki (łącznie 3 pliki). Zmienimy je później.

touch nat-vm.tf psc.tf dns.tf

Przełącz się na widok Edytor 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

 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
}

Przejdź do terminala Cloud Shell, upewnij się, że jesteś w folderze terraform-build, i uruchom polecenie terraform plan. W ten sposób zobaczysz, że zostaną dodane 4 elementy. Następnie uruchom polecenie terraform apply i wpisz yes, aby utworzyć bramę NAT i 2 maszyny wirtualne.

5. Zadanie 3. Konfigurowanie maszyn wirtualnych i testowanie

Przejdź do instancji maszyn wirtualnych. Wybierz maszynę wirtualną, której nazwa zaczyna się od py-vm1. Wybierz SSH.
Po połączeniu się przez SSH z py-vm1 włącz root,wpisując sudo -i.
Aktywuj środowisko venv:

cd py-gem-env
source env/bin/activate

Teraz zweryfikuj to, aby później przeprowadzić testy. Uruchom to polecenie w maszynie wirtualnej i w razie potrzeby naciśnij y.

gcloud auth application-default login

Następnie skopiuj adres URL, który zaczyna się od https://, otwórz nową kartę w oknie przeglądarki laboratorium i wklej adres URL. Zaakceptuj wyświetlane prompty.
Gdy zobaczysz ten fragment kodu, przełącz się z powrotem do sesji vm py-vm1 i w miejscu Wpisz kod autoryzacji wklej skopiowany kod i naciśnij Enter, aby uwierzytelnić.

Teraz przeprowadzimy krótki test, aby sprawdzić, czy możemy połączyć się z interfejsem Vertex Gemini API. Używa on adresu us-central1-aiplatform.googleapis.com, więc spróbujemy wysłać do niego żądanie dig, aby zobaczyć, jak jest kierowany ruch.

dig us-central1-aiplatform.googleapis.com

Powinien pojawić się podobny ekran (adres będzie inny). Pamiętaj, że ścieżka prowadzi przez publiczne adresy IP, ponieważ interfejs API jest publicznym interfejsem API. NIE KOPIUJ

; <<>> 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

Teraz użyjemy Pythona. Aby aktywować interfejs ipython, wpisz ipython.

ipython

Teraz skopiuj i wklej ten fragment kodu. Pyta Gemini „Jakie są wszystkie kolory logo Google” i „Jaki jest kolor nieba”. Zastąp enter-your-project-id-here identyfikatorem projektu w cudzysłowie.

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))

Naciśnij klawisz Enter, aby uruchomić i zobaczyć wynik.
To żądanie uzyskało dostęp do Vertex za pomocą publicznego interfejsu API.
Zamknij sesję SSH i przejdź dalej.

Teraz skonfiguruj maszynę wirtualną py-vm2 z tymi samymi konfiguracjami

Przejdź do instancji maszyn wirtualnych. Wybierz maszynę wirtualną, której nazwa zaczyna się od py-vm2. Wybierz SSH.
Po nawiązaniu połączenia SSH z py-vm2 włącz root, wpisując **sudo -i**
Aktywuj środowisko venv:

cd py-gem-env
source env/bin/activate

Teraz zweryfikuj to, aby później przeprowadzić testy. Uruchom to polecenie na maszynie wirtualnej:

gcloud auth application-default login

Następnie skopiuj adres URL, który zaczyna się od https://, otwórz nową kartę w oknie przeglądarki laboratorium i wklej adres URL. Zaakceptuj wyświetlane prompty.
Gdy zobaczysz ten fragment kodu, przełącz się z powrotem do sesji vm py-vm2 i w miejscu Wpisz kod autoryzacji wklej skopiowany kod i naciśnij Enter, aby uwierzytelnić.

Przeprowadźmy teraz krótki test, aby sprawdzić, czy możemy połączyć się z interfejsem Vertex Gemini API. To polecenie użyje 4 pingów do adresu us-central1-aiplatform.googleapis.com, więc otrzymamy odpowiedź z publicznego adresu interfejsu API.

ping -c 4 us-central1-aiplatform.googleapis.com

Wrócimy do testowania tej maszyny wirtualnej w późniejszym czasie. Zamknij sesję SSH i kontynuuj.

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

Aby umożliwić prywatne połączenie z punktem końcowym interfejsu Vertex API, utworzymy punkt końcowy Private Service Connect dla interfejsów Google API. Umożliwi nam to używanie prywatnego adresu IP, który przypiszemy do kierowania ruchu do interfejsów API Google, których potrzebujemy, w tym przypadku Vertex.

Otwórz Cloud Shell w widoku edytora, jeśli nie jest jeszcze otwarty. Utworzymy:

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 Google API (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 = ""
  }

Przełącz się na terminal Cloud Shell i sprawdź, czy jesteś w folderze terraform-build. Następnie uruchom terraform init. Następnie uruchom terraform plan. Pokaże Ci to, że zostaną dodane 2 elementy.
Następnie uruchom terraform apply i wpisz yes, aby utworzyć punkt końcowy interfejsu API Google IP i PSC.
Weryfikacja istnienia punktu końcowego

gcloud compute addresses list --filter="name=( 'vertex-ip' ...)"

gcloud compute forwarding-rules describe pscvertexgemini --global

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

Aby połączyć się z Gemini, użyj prywatnego punktu końcowego.

Otwórz maszynę wirtualną py-vm1. Wybierz SSH i połącz się z maszyną wirtualną za pomocą SSH
Aby uzyskać dostęp na poziomie roota, wpisz sudo -i.
Użyjemy tej instancji tylko do przetestowania punktu końcowego PSC, więc zmodyfikujemy plik hosta, dodając ten wpis:

echo 192.168.255.250 us-central1-aiplatform.googleapis.com >> /etc/hosts

cat /etc/hosts

Sprawdź ścieżkę łączności do adresu us-central1-aiplatform.googleapis.com, używając polecenia ping. Spowoduje to wysłanie zapytania ping do adresu IP wpisanego w pliku hosts. To jest punkt końcowy PSC, więc pingi nie będą działać.

ping -c 2 us-central1-aiplatform.googleapis.com

Wróć do konsoli i otwórz kolejną instancję maszyny wirtualnej py-vm1. Wybierz SSH i połącz się z maszyną wirtualną przez SSH
Aby uzyskać dostęp na poziomie roota, wpisz sudo -i.
Aby sprawdzić łączność w zbiorze danych TCP, uruchom to polecenie:

sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com

Wróć do pierwszego połączenia SSH z instancją maszyny wirtualnej py-vm1.
Aktywuj środowisko za pomocą

cd py-gem-env
source env/bin/activate

Teraz przetestujmy Pythona. Aby aktywować interfejs ipython, wpisz ipython. Tym razem ruch będzie przepływał przez punkt końcowy PSC.

ipython

Teraz skopiuj i wklej ten fragment kodu. Zapytaj Gemini „Jakie są wszystkie kolory logo Google” i „Opisz wodospady Niagara”. Zastąp enter-your-project-id-here identyfikatorem projektu w cudzysłowie.

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))

Naciśnij Enter, aby uruchomić zapytanie i zobaczyć wynik.
Wróć do drugiej instancji maszyny wirtualnej py-vm1. Powinien pojawić się wynik polecenia TCPDUMP. Zobaczysz połączenia przychodzące i wychodzące z adresami IP maszyny wirtualnej oraz adresem IP punktu końcowego PSC, aby połączyć się z 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

Zamknij wszystkie sesje SSH do instancji maszyny wirtualnej py-vm1.

8. Zadanie 6. Tworzenie ręcznego wpisu DNS do googleapis za pomocą Terraform (opcjonalnie)

Możesz utworzyć ręczny wpis DNS, który będzie wskazywał punkt końcowy PSC za pomocą prywatnego DNS. Ma to wpływ na wszystkie sieci, które przypiszesz do tego konta.

Przejdź do Usług sieciowych i wybierz Cloud DNS.
W sekcji „Strefa” powinna pojawić się automatycznie utworzona strefa dla usługi Private Service Connect dla interfejsów Google API z katalogiem usług typu „strefa”. Można go użyć do połączenia z punktem końcowym PSC w formacie **SERVICE-ENDPOINT.p.googleapis.com. Przykład: aiplatform-pscvertexgemini.p.googleapis.com
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 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 domenę „googleapis.com”.

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."]  
}

Przełącz się na terminal Cloud Shell i sprawdź, czy jesteś w folderze terraform-build. Następnie uruchom terraform plan, aby sprawdzić, jakie elementy zostaną dodane.
Następnie uruchom terraform apply i wpisz yes, aby utworzyć prywatny wpis DNS.
Powinieneś zobaczyć konfigurację z rekordem A i CNAME, tak jak na rysunku
Następnie sprawdzamy połączenie z tymi zmianami na py-vm2.

9. Zadanie 7. Sprawdzanie łączności punktu końcowego za pomocą adresu IP (opcjonalnie)

Aby połączyć się z Gemini, użyj prywatnego punktu końcowego.

Otwórz instancję maszyny wirtualnej py-vm2. Wybierz SSH i połącz się z maszyną wirtualną za pomocą SSH
Aby uzyskać dostęp na poziomie roota, wpisz sudo -i.
Sprawdź ścieżkę łączności do adresu us-central1-aiplatform.googleapis.com, używając polecenia ping. Spowoduje to wysłanie pinga do adresu IP w prywatnym DNS, rekordu A dla googleapis. Ten adres IP jest punktem końcowym PSC, więc pingi nie będą działać.

ping -c 2 us-central1-aiplatform.googleapis.com

Sprawdź ścieżkę łączności z ping, korzystając z automatycznie utworzonego wpisu DNS dla interfejsów PSC Google z aiplatform-pscvertexgemini.p.googleapis.com. Wskazuje on adres IP punktu końcowego PSC, więc pingi nie będą działać.

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

Sprawdź ścieżkę łączności do adresu us-central1-aiplatform.googleapis.com, używając polecenia dig. Powinien to być adres IP punktu końcowego PSC.

dig us-central1-aiplatform.googleapis.com

Wróć do konsoli i otwórz kolejną instancję maszyny wirtualnej py-vm2. Wybierz SSH i połącz się z maszyną wirtualną przez SSH
Aby uzyskać dostęp na poziomie roota, wpisz sudo -i.
Aby sprawdzić łączność w pliku z danymi TCP, uruchom to polecenie

sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com

Wróć do pierwszego połączenia SSH z instancją maszyny wirtualnej py-vm2.
Aktywuj środowisko za pomocą

cd py-gem-env
source env/bin/activate

Teraz przetestujmy Pythona. Aby aktywować interfejs ipython, wpisz ipython.

ipython

Teraz skopiuj i wklej ten fragment kodu. Zapytaj Gemini „Jakie są wszystkie kolory logo Google” i „Jakie są 2 funkcje Gemini Pro”. Zastąp enter-your-project-id-here identyfikatorem projektu w cudzysłowie.

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))

Naciśnij Enter, aby uruchomić zapytanie i zobaczyć wynik.
Wróć do drugiej instancji maszyny wirtualnej py-vm2. Powinien pojawić się wynik polecenia TCPDUMP. Zauważysz, że adres IP maszyny wirtualnej używa adresu IP punktu końcowego PSC do połączenia z adresem us-central1-aiplatform.googleapis.com.

Zamknij wszystkie sesje SSH do instancji maszyny wirtualnej py-vm2.

10. Czyszczenie

Otwórz Cloud Shell i sprawdź, czy jesteś w katalogu cd terraform-build terraform-build. Uruchom to polecenie: terraform destroy i wpisz yes. Wszystkie zasoby utworzone w projekcie za pomocą Terraform zostaną usunięte.

11. Gratulacje

Gratulacje! Pomyślnie połączono Cię z czatem Vertex Gemini przy użyciu zarówno publicznego adresu interfejsu API, jak i prywatnie przy użyciu punktu końcowego usługi Private Service Connect dla interfejsów Google API. Ta funkcja może rozszerzyć łączność prywatnego interfejsu API do środowiska lokalnego lub innego środowiska chmurowego, które są połączone za pomocą (Interconnect, Cross-Cloud Interconnect i VPC).

Kolejne kroki / Więcej informacji

Więcej informacji o sieci Vertex AI

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

Przejdź do kolejnego modułu

Możesz uczyć się dalej w ramach modułów Google Cloud i sprawdzać te moduły Google Cloud Skills Boost: