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 module zaczniesz korzystać z interfejsu Vertex Gemini Chat API za pomocą pakietu SDK Pythona uruchomionego 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 module utworzysz następujący wzorzec.

Rysunek1.

8b283cc5684283c2.png

2. Cel

Z tego modułu nauczysz się, jak:

  • Konfigurowanie maszyny wirtualnej do korzystania z pakietu SDK Pythona
  • Połącz się z czatem z Gemini za pomocą skryptu Pythona
  • Skonfiguruj punkt końcowy PSC, aby połączyć się z Googleapis
  • Sprawdzanie ścieżki łączności z Googleais
  • Konfigurowanie ręcznych wpisów DNS

Konfiguracja środowiska w samodzielnym tempie

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

fbef9caa1602edd0.png

a99b7ace416376c4.png

5e3ff691252acf41.png

  • Nazwa projektu jest wyświetlaną nazwą 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 unikalny we wszystkich projektach Google Cloud i nie można go zmienić (po jego ustawieniu nie można go zmienić). 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 trzeba 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ć własnych sił i sprawdzić, czy jest dostępna. Po wykonaniu tej czynności nie można jej już zmienić. Pozostanie ona przez cały czas trwania 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.
  1. Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Cloud/interfejsów API. Przejście przez ten samouczek nie będzie wiązać się z wielkimi kosztami, jeśli w ogóle będą jakieś. 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 programu bezpłatnego okresu próbnego o wartości 300 USD.

Uruchom 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:

55efc1aaa7a4d3ad.png

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:

7ffe5cbb04455448.png

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 ramach tego ćwiczenia z programowania można wykonywać w przeglądarce. Nie musisz niczego instalować.

3. Zadanie 1. Skonfiguruj środowisko z 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 u góry konsoli po prawej stronie. Sprawdź, czy w Cloud Shell wyświetla się prawidłowy identyfikator projektu. Jeśli wyświetli się prośba o zezwolenie na dostęp, potwierdź, że go nie widzisz. 4261e776f64ea978.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 Edytor Cloud Shell. Wybierz Edytor i potwierdź wyświetlone prompty, aby umożliwić wczytanie interfejsu.
  2. 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. 78f5eb9f2f82f1b0.png
  3. Wybierz plik variable.tf i dodaj te informacje. Zastąp tekst your-project-id-here swoim 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 wykonywać różne działania zgodnie z poniższym opisem.

Włączanie interfejsów API

resource "google_project_service" "default"

Utworzenie sieci VPC o nazwie python-net

resource "google_compute_network" "default"

Dodawanie podsieci

resource "google_compute_subnetwork" "default"

Dodawanie 2 reguł zapory sieciowej

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

  1. 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"]
}
  1. 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. Ten krok umożliwia pobranie dostawców wymaganych w przypadku danej konfiguracji.

terraform plan

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

  1. Teraz, 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 zewnętrzny dostęp do internetu, aby umożliwić utworzenie i podłączenie bramy Cloud NAT.

  1. Otwórz Cloud Shell, przejdź do folderu terraform-build i utwórz wymienione poniżej pliki (łącznie 3 pliki). Będziemy je później zmieniać.
touch nat-vm.tf psc.tf dns.tf
  1. Przejdź do widoku edytora Cloud Shell i wybierz plik nat-vm.tf, a następnie dodaj podany niżej kod Terraform. Spowoduje to utworzenie bramy NAT i dwóch 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
}
  1. Przełącz się na terminal Cloud Shell, sprawdź, czy jesteś w folderze terraform-build, a następnie uruchom polecenie terraform plan. Spowoduje to dodanie 4 elementów. 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

  1. Przejdź do instancji maszyn wirtualnych. Wybierz maszynę wirtualną rozpoczynający się od py-vm1. Wybierz SSH.
  2. Po połączeniu SSH z py-vm1 włącz roota,wpisując sudo -i
  3. Aktywuj środowisko venv:
cd py-gem-env
source env/bin/activate
  1. 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
  1. 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świetlone instrukcje.
  2. 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ć.

c29615cdf9324209.png

  1. Wykonajmy teraz krótki test, aby sprawdzić, czy uda się połączyć z interfejsem Vertex Gemini API. Korzysta on z us-central1-aiplatform.googleapis.com, więc użyjemy do niego dig, aby sprawdzić, jak ruch jest kierowany.
dig us-central1-aiplatform.googleapis.com
  1. 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
  1. Teraz użyjmy Pythona. Wpisz ipython, aby aktywować interfejs ipythona.
ipython

4685b31f13df54e1.png

  1. Skopiuj i wklej ten tekst. Gemini zapyta: „Jakie są wszystkie kolory logo Google” i „Jaki jest kolor nieba”. Zastąp enter-your-project-id-here identyfikatorem projektu w cudzysłowach
import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "What color is the sky?"
print(get_chat_response(chat_session, prompt))
  1. Naciśnij Enter, aby uruchomić test i zobaczyć wynik.
  2. To żądanie uzyskało dostęp do Vertex za pomocą publicznego interfejsu API.
  3. Zamknij sesję SSH i kontynuuj.

Teraz skonfiguruj py-vm2 z tymi samymi konfiguracjami

  1. Przejdź do instancji maszyn wirtualnych. Wybierz maszynę wirtualną, której nazwa zaczyna się od py-vm2. Wybierz SSH.
  2. Po nawiązaniu połączenia SSH z py-vm2 włącz root, wpisując **sudo -i**
  3. Aktywuj środowisko venv:
cd py-gem-env
source env/bin/activate
  1. Uwierzytelnijmy to, by przeprowadzić trochę testów później. Uruchom to polecenie w maszynie wirtualnej
gcloud auth application-default login
  1. 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świetlone instrukcje.
  2. 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ć.

c29615cdf9324209.png

  1. Wykonajmy teraz krótki test, aby sprawdzić, czy uda się połączyć 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
  1. Wrócimy później, aby przetestować tę maszynę wirtualną. Zamknij sesję SSH i kontynuuj.

6. Zadanie 4. Tworzenie punktu końcowego PSC dla 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.

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

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

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. 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. W ten sposób zobaczysz, że zostaną dodane 2 elementy.
    Następnie uruchom terraform apply i wpisz yes, aby utworzyć punkt końcowy interfejsu IP i PSC Google.
  2. 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

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

  1. Otwórz maszynę wirtualną py-vm1. Wybierz SSH i połącz się z maszyną wirtualną za pomocą SSH
  2. Aby uzyskać dostęp na poziomie roota, wpisz sudo -i.
  3. 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
  1. 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 podanego w plikach hosta. To jest punkt końcowy PSC, więc pingi nie będą działać.
ping -c 2 us-central1-aiplatform.googleapis.com
  1. Wróć do konsoli i otwórz kolejną instancję instancji maszyny wirtualnej py-vm1. Wybierz SSH i połącz się z maszyną wirtualną przez SSH
  2. Aby uzyskać dostęp do roota, wpisz sudo -i
  3. Aby sprawdzić łączność w zbiorze danych TCP, uruchom to polecenie:
sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com
  1. Wróć do pierwszego połączenia SSH z instancją maszyny wirtualnej py-vm1.
  2. Aktywuj środowisko za pomocą:
cd py-gem-env
source env/bin/activate
  1. Teraz przetestujmy Pythona. Aby aktywować interfejs ipython, wpisz ipython. Ruch w tym czasie będzie przepływał przez punkt końcowy PSC.
ipython
  1. 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))
  1. Naciśnij Enter, aby uruchomić zapytanie i zobaczyć wynik.
  2. Wróć do drugiej instancji maszyny wirtualnej py-vm1. Powinien pojawić się wynik polecenia TCPDUMP. Zwróć uwagę na ruch przychodzący i wychodzący z adresami IP maszyny wirtualnej oraz adresem IP punktu końcowego PSC, który łą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
  1. 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.

  1. Przejdź do Usług sieciowych i wybierz Cloud DNS.
  2. W strefach powinna być widoczna automatycznie utworzona strefa dla usługi Private Service Connect dla interfejsów API Google z katalogiem usług typu strefy. 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
  3. W takim przypadku chcemy ręcznie utworzyć prywatny wpis DNS. Konfiguracja będzie wyglądać tak:
  • Utwórz prywatną strefę DNS o nazwie „googleapis-private” dla usługi „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) do domeny „googleapis.com”.
  1. Otwórz Cloud Shell w widoku edytora, jeśli jeszcze nie jest otwarty. Otwórz plik dns.tf w folderze terraform-build. Dodaj poniższy kod do pliku.

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. 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ć wpis DNS prywatnego.
  2. Zobaczysz konfigurację z rekordem A i rekordem CNAME podobną do tej: b7f122f0d1fd2850.png.
  3. Następnie weryfikujemy połączenie z tymi zmianami w 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.

  1. Otwórz instancję maszyny wirtualnej py-vm2. Wybierz SSH i SSH do maszyny wirtualnej
  2. Aby uzyskać dostęp do roota, wpisz sudo -i
  3. Sprawdź ścieżkę połączenia z us-central1-aiplatform.googleapis.com za pomocą polecenia ping. Spowoduje to wysłanie pinga do adresu IP w prywatnym DNS, rekordu A dla googleapis. Ten adres IP to punkt końcowy PSC i Twoje pingi zakończą się niepowodzeniem.
ping -c 2 us-central1-aiplatform.googleapis.com
  1. Sprawdź ścieżkę połączenia z ping za pomocą automatycznie utworzonego wpisu DNS dla interfejsów PSC API Google z aiplatform-pscvertexgemini.p.googleapis.com. Wskazuje adres IP punktu końcowego PSC i pingi nie będą udane.
ping -c 2 aiplatform-pscvertexgemini.p.googleapis.com
  1. Sprawdź ścieżkę połączenia z us-central1-aiplatform.googleapis.com za pomocą polecenia dig. Powinien to być adres IP punktu końcowego PSC.
dig us-central1-aiplatform.googleapis.com
  1. Wróć do konsoli i otwórz kolejną instancję maszyny wirtualnej py-vm2. Wybierz SSH i połącz się z maszyną wirtualną przez SSH
  2. Aby uzyskać dostęp na poziomie roota, wpisz sudo -i.
  3. Uruchom polecenie zgodne z instrukcjami, aby wyświetlić połączenie w zrzucie TCP
sudo tcpdump -i any port 53 -n or host us-central1-aiplatform.googleapis.com
  1. Teraz przełącz się z powrotem na pierwszą instancję SSH instancji maszyny wirtualnej py-vm2
  2. Aktywuj środowisko za pomocą
cd py-gem-env
source env/bin/activate
  1. Teraz przetestujmy Pythona. Wpisz ipython, aby aktywować interfejs ipythona.
ipython
  1. 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łowach
import vertexai
from vertexai.generative_models import GenerativeModel, ChatSession

project_id = "enter-your-project-id-here" 
location = "us-central1" 

vertexai.init(project=project_id, location=location)
model = GenerativeModel("gemini-1.5-pro")
chat_session = model.start_chat()  # Corrected line

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat_session, prompt)) 

prompt = "What are all the colors of the Google logo?"
print(get_chat_response(chat_session, prompt)) 

prompt = "What are two features of Gemini pro"
print(get_chat_response(chat_session, prompt))
  1. Naciśnij Enter, aby uruchomić polecenie i zobaczyć wynik.
  2. Wróć do drugiej instancji maszyny wirtualnej py-vm2. Powinien wyświetlić się wynik działania protokołu TCPDUMP. Zauważysz, że do połączenia z us-central1-aiplatform.googleapis.com adres IP maszyny wirtualnej używa adresu IP punktu końcowego PSC.

Zamknij wszystkie sesje SSH w instancji maszyny wirtualnej py-vm2

10. Czyszczenie

  1. Otwórz Cloud Shell, sprawdź, czy jesteś w katalogu terraform-build cd terraform-build, a następnie uruchom następujące polecenie terraform destroy i wpisz yes. Wszystkie zasoby utworzone w projekcie za pomocą Terraform zostaną usunięte.

11. Gratulacje

Gratulujemy. Udało Ci się połączyć z czatem w Vertex Gemini przy użyciu publicznego adresu interfejsu API i prywatnego przy użyciu punktu końcowego usługi Private Service Connect dla interfejsów API Google. 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

Dowiedz się więcej o sieciach Vertex AI.

Ćwiczenia z programowania: Uzyskiwanie dostępu do aplikacji Anthropic Claude w Vertex AI przy użyciu pakietu SDK Pythona 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: