Interfejs wiersza poleceń Antigravity w GCE z punktem końcowym Private Service Connect

1. Przegląd

Interfejsu wiersza poleceń Antigravity możesz używać zarówno w środowisku lokalnym, jak i wirtualnym. Antigravity udostępnia możliwości Gemini bezpośrednio w terminalu. Z punktu widzenia sieci, gdy używasz interfejsu wiersza poleceń Antigravity, wywołuje on interfejs Gemini API za pomocą adresu IP interfejsu API, który jest dostępny publicznie.

Co się stanie, jeśli chcesz używać interfejsu Antigravity CLI na maszynie Google Compute Engine, ale chcesz połączyć się z interfejsem API prywatnie? W tym laboratorium dowiesz się, jak skonfigurować punkt końcowy usługi Private Service Connect dla interfejsów API Google, aby kierować ruch do określonego przez Ciebie wewnętrznego adresu IP.

Konfiguracje będą połączeniem Terraform, gcloud i konsoli.

Z tego modułu dowiesz się, jak:

• Konfigurowanie instancji maszyny wirtualnej i Cloud NAT
• Instalowanie interfejsu wiersza poleceń Antigravity i uwierzytelnianie
• Konfigurowanie punktu końcowego Private Service Connect do łączenia się z Googleapis
• Sprawdzanie ścieżki połączenia z *.googleapis
• Konfigurowanie ręcznych wpisów DNS

W tym module utworzysz ten wzór.

Rysunek 1.

2. Konfigurowanie usług Google Cloud

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

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

Ostrzeżenie: identyfikator projektu jest unikalny globalnie i po jego wybraniu nie może być używany przez nikogo innego. Jesteś jedynym użytkownikiem tego identyfikatora. Nawet po usunięciu projektu nie można ponownie użyć jego identyfikatora.

Uwaga: jeśli używasz konta Gmail, możesz pozostawić domyślną lokalizację ustawioną na Brak organizacji. Jeśli używasz konta Google Workspace, wybierz lokalizację odpowiednią dla Twojej organizacji.

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

Z Google Cloud można korzystać zdalnie na laptopie, ale w tym ćwiczeniu użyjesz 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 zakończeniu powinno wyświetlić się coś takiego:

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. 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.
2. Utwórz folder o nazwie terraform-build i przejdź do niego.

mkdir terraform-build && cd terraform-build 

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

touch main.tf variable.tf 

4. Przełącz się na widok edytora Cloud Shell. Kliknij edytor i zaakceptuj wszystkie niezbędne prośby, aby interfejs mógł się załadować.
5. 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.
6. 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 = "antigravity-vpc-net"
}

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

8. Skopiuj poniższy kod i wklej go do pliku main .tf.

resource "google_project_service" "default" {
  for_each = toset([
    "dns.googleapis.com",
    "aiplatform.googleapis.com",
    "servicedirectory.googleapis.com"
  ])

  service            = each.value
  disable_on_destroy = false
}

resource "google_compute_network" "default" {
  project                 = var.project_id
  name                    = var.network_id
  auto_create_subnetworks = false
  mtu                     = 1460
  routing_mode            = "GLOBAL"
}

resource "google_compute_subnetwork" "default" {
  name          = "vm1-subnet"
  ip_cidr_range = "192.168.100.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"]
}

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

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

Sprawdź konfigurację: sprawdź w swoim środowisku

• VPC o nazwie antigravity-vpc-net
• podsieć
• firewall-rules

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

2. 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    = "outbound-nat"
  region  = "us-east1"
  network = google_compute_network.default.id

 bgp {
  asn = 64514
  }
}

resource "google_compute_router_nat" "default" {
  name                               = "outbound-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         = "cli-vm"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  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
    sudo apt-get update    
  EOF
}

resource "google_compute_instance" "vm2" {
  name         = "monitor-vm"
  zone         = "us-east1-b"
  machine_type = "n2-standard-2"

  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
    sudo apt-get update
    sudo apt-get install python3 python3-dev python3-venv -y
    sudo apt-get install tcpdump dnsutils -y
  EOF
}

3. 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 2 maszyny wirtualne.

Sprawdź konfigurację: sprawdź w swoim środowisku

1 brama NAT

1 router Cloud Router

Maszyna wirtualna o nazwie cli-vm

Maszyna wirtualna o nazwie monitor-vm

5. Zadanie 3. Konfigurowanie maszyn wirtualnych interfejsu wiersza poleceń i testowanie

1. Otwórz Instancje maszyn wirtualnych. Wybierz maszynę wirtualną zaczynającą się od cli-vm. Wybierz SSH.
2. Po połączeniu się przez SSH powinna być dostępna maszyna wirtualna. Utwórzmy folder, w którym będziemy uruchamiać interfejs wiersza poleceń Gemini.

mkdir antigravitycli && cd antigravitycli

3. Aby zainstalować interfejs wiersza poleceń Antigravity, użyj tego polecenia:

curl -fsSL https://antigravity.google/cli/install.sh | bash && source ~/.bashrc

Sprawdzanie wersji

agy --version

4. Zalogujmy się i uwierzytelnijmy to, aby później przeprowadzić testy.

agy

5. Wybierz opcję 1 Google OAuth . Teraz się uwierzytelnimy.
6. 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 prompty.

7. Gdy zobaczysz poniższy komunikat, kliknij „Kopiuj do schowka”, wróć do sesji maszyny wirtualnej cli-vm i w sekcji Enter authorization code: (Wpisz kod autoryzacji:) wklej skopiowany kod i naciśnij Enter, aby się uwierzytelnić.

8. Wróć do sesji maszyny wirtualnej cli-vm i w odpowiedzi na pytanie Enter authorization code: (Wpisz kod autoryzacji:) wklej skopiowany kod i naciśnij Enter, aby się uwierzytelnić.

9. Powinien pojawić się ekran, na którym możesz dostosować i zaakceptować umowę oraz przejść do katalogu domowego. Wybierz odpowiednie opcje, aby dokończyć proces.

10. Po zakończeniu tego procesu możesz zacząć korzystać z interfejsu Antigravity CLI.

Uwaga: możesz zmienić pytanie w prompcie.

Monitorowanie trasy ruchu do Gemini za pomocą monitorowania maszyny wirtualnej

1. Otwórz Instancje maszyn wirtualnych. Wybierz maszynę wirtualną zaczynającą się od monitor-vm. Wybierz SSH.
2. Po połączeniu się z monitor-vm przez SSH uzyskasz dostęp.
3. Użyjemy polecenia dig, aby przetestować ścieżkę połączenia z interfejsem Gemini API. Użyjemy us-east1-aiplatform.googleapis.com

dig us-east1-aiplatform.googleapis.com

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.33-1~deb12u2-Debian <<>> us-east1-aiplatform.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 58905
;; flags: qr rd ra; QUERY: 1, ANSWER: 14, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;us-east1-aiplatform.googleapis.com. IN A

;; ANSWER SECTION:
us-east1-aiplatform.googleapis.com. 300 IN A    216.239.38.223
us-east1-aiplatform.googleapis.com. 300 IN A    216.239.34.223
us-east1-aiplatform.googleapis.com. 300 IN A    216.239.36.223
us-east1-aiplatform.googleapis.com. 300 IN A    216.239.32.223

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

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

5. W późniejszym czasie wrócimy do testowania tej maszyny wirtualnej. Zamknij sesję SSH i przejdźmy 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. Umożliwi nam to używanie 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 otwarta. Utworzymy te elementy:

• Utwórz adres IP dla punktu końcowego PSC 10.10.100.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         = "gemini-ip"
  purpose      = "PRIVATE_SERVICE_CONNECT"
  network      = google_compute_network.default.id
  address_type = "INTERNAL"
  address      = "10.10.100.250" 
}

resource "google_compute_global_forwarding_rule" "default" {  
  name                  = "pscgemini"
  target                = "all-apis"
  network               = google_compute_network.default.id
  ip_address            = google_compute_global_address.default.id 
  load_balancing_scheme = ""
  
  service_directory_registrations {
    namespace                = "googleapis"
    service_directory_region = "us-east1"
  }
}

2. Przejdź do terminala Cloud Shell i upewnij się, że jesteś w folderze terraform-build. Następnie uruchom terraform init Następnie uruchom terraform plan, co pokaże, ż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.
3. Sprawdzanie, czy punkt końcowy istnieje

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

gcloud compute forwarding-rules describe pscgemini --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-pscgemini.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 „antigravity-vpc-net”.
• Dodaj rekord A, aby przypisać „googleapis.com” do adresu IP „10.10.100.250”.
• Dodaj rekord CNAME, aby przekierować wszystkie subdomeny domeny „googleapis.com” (np. www.googleapis.com) na „googleapis.com”.

4. Otwórz Cloud Shell w widoku edytora, jeśli nie jest jeszcze otwarta. 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 = ["10.10.100.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."]  
}

5. Przejdź do terminala Cloud Shell i upewnij się, że jesteś w folderze terraform-build. Następnie uruchom terraform plan – wyświetli to listę elementów, które zostaną dodane.
   Następnie uruchom terraform apply i wpisz yes, aby utworzyć prywatny wpis DNS.
6. Powinna pojawić się konfiguracja z rekordem A i CNAME, jak pokazano poniżej:

7. Następnie sprawdzamy połączenie po wprowadzeniu tych zmian na maszynie monitor-vm.

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

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

Uwaga: na maszynie wirtualnej nie trzeba wprowadzać żadnych konfiguracji ręcznych. Używamy monitor-vm

1. Otwórz instancję maszyny wirtualnej monitor-vm. Wybierz SSH i połącz się z maszyną wirtualną przez SSH
2. Sprawdź ścieżkę połączenia z adresem us-east1-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 us-east1-aiplatform.googleapis.com

3. Sprawdź ścieżkę połączenia z adresem us-east1-aiplatform.googleapis.com za pomocą polecenia dig. Powinien to być adres IP punktu końcowego PSC (10.10.100.250).

dig us-east1-aiplatform.googleapis.com

4. Po zakończeniu możesz zamknąć sesję SSH monitor-vm.

Przechodzimy na**cli-vm**

5. Otwórz instancję maszyny wirtualnej cli-vm. Wybierz SSH i połącz się z maszyną wirtualną przez SSH
6. Teraz możemy uruchomić zrzut TCP na maszynie wirtualnej cli-vm. Musimy otworzyć 2 sesje SSH na tej samej maszynie wirtualnej. W jednej sesji uruchomimy polecenie tcpdump, a w drugiej użyjemy interfejsu wiersza poleceń Gemini.
7. Aby sprawdzić łączność w tcpdump, wpisz to polecenie:

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

8. Teraz połącz się przez SSH z następną sesją na maszynie cli-vm.
9. Przejdź do folderu antigravitycli cd antigravitycli
10. Aktywuj interfejs wiersza poleceń Antigravity, wpisując agy
11. Zadaj to pytanie: what color is the sky?, aby wygenerować wywołanie interfejsu Gemini API.

12. Naciśnij Enter, aby uruchomić zapytanie i zobaczyć wynik.
13. Wróć do pierwszej sesji na cli-vm. 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 interfejsem Gemini API.

Zamknij wszystkie sesje SSH na instancjach maszyn wirtualnych.

9. Czyszczenie

1. Otwórz Cloud Shell i upewnij się, że jesteś w katalogu terraform-build cd terraform-build. Uruchom to polecenie terraform destroy i wpisz yes wszystkie zasoby utworzone w projekcie za pomocą Terraform. Zostaną one usunięte.

10. Gratulacje

Gratulacje. Udało Ci się połączyć z interfejsem Antigravity CLI przy użyciu publicznego interfejsu API i prywatnie za pomocą 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 międzysieciowego, połączenia międzychmurowego i sieci VPC.

Kolejne kroki / Więcej informacji

Więcej informacji znajdziesz w dokumentacji interfejsu wiersza poleceń Antigravity.

Przejdź do kolejnego modułu

Kontynuuj naukę w Google Cloud i zapoznaj się z tymi laboratoriami Google Cloud:

• Podstawy sieci w Google Cloud
• Explorator generatywnej AI – Vertex AI
• Prezentacja Cloud Networking