Vertex AI Pipelines PSC Interface Explicit Proxy

1. Wprowadzenie

Interfejs Private Service Connect to zasób, który umożliwia sieci VPC producenta inicjowanie połączeń z różnymi miejscami docelowymi w sieci VPC konsumenta. Sieci producenta i odbiorcy mogą znajdować się w różnych projektach i organizacjach.

Jeśli przyłącze sieci zaakceptuje połączenie z interfejsu Private Service Connect, Google Cloud przydzieli interfejsowi adres IP z podsieci konsumenta określonej przez przyłącze sieci. Sieci konsumenta i producenta są połączone i mogą komunikować się za pomocą wewnętrznych adresów IP.

Połączenie między przyłączem sieci a interfejsem Private Service Connect jest podobne do połączenia między punktem końcowym Private Service Connect a przyłączem usługi, ale ma 2 kluczowe różnice:

  • Przyłącze sieci umożliwia sieci producenta inicjowanie połączeń z siecią konsumenta (ruch wychodzący usługi zarządzanej), a punkt końcowy umożliwia sieci konsumenta inicjowanie połączeń z siecią producenta (ruch przychodzący usługi zarządzanej).
  • Połączenie interfejsu Private Service Connect jest przechodnie. Oznacza to, że sieć producenta może komunikować się z innymi sieciami połączonymi z siecią konsumenta.

Wskazówki dotyczące dostępności interfejsu PSC Vertex AI

  • Interfejs PSC może kierować ruch do miejsc docelowych w sieci VPC lub lokalnych w bloku adresów RFC1918.
  • Kierowanie na interfejs PSC na bloki adresów inne niż rfc-1918 wymaga wdrożenia w sieci VPC konsumenta jawnego serwera proxy z adresem rfc-1918. W ramach wdrożenia Vertex AI serwer proxy musi być zdefiniowany wraz z w pełni kwalifikowaną nazwą domeny docelowego punktu końcowego. Na rysunku 1 przedstawiono serwer proxy skonfigurowany w sieciach VPC klientów, aby ułatwić kierowanie do tych zakresów CIDR, które nie są zgodne z RFC-1918:

[1] 240.0.0.0/4

[2] 203.0.113.0/2

[3]10.10.20.0/28 nie wymaga serwera proxy, mieści się w zakresie rfc1918.

  • Jeśli skonfigurujesz wdrożenie tylko za pomocą interfejsu PSC, zachowa ono domyślny dostęp do internetu. Ten ruch wychodzący jest kierowany bezpośrednio z zabezpieczonej sieci najemcy zarządzanej przez Google.

476f87a96f153b95.png

Wskazówki dotyczące interfejsu VPC-SC usługi Vertex AI PSC

  • Gdy Twój projekt jest częścią granicy ustawień usługi VPC, domyślny dostęp do internetu w dzierżawach zarządzanych przez Google jest blokowany przez tę granicę, aby zapobiec wydobywaniu danych.
  • Aby umożliwić wdrożeniu dostęp do publicznego internetu w tym scenariuszu, musisz wyraźnie skonfigurować bezpieczną ścieżkę ruchu wychodzącego, która kieruje ruch przez sieć VPC. Zalecany sposób to skonfigurowanie serwera proxy wewnątrz granicy sieci VPC z adresem RFC1918 i utworzenie bramy Cloud NAT, aby umożliwić maszynie wirtualnej proxy dostęp do internetu.

Więcej informacji znajdziesz w tych materiałach:

Konfigurowanie interfejsu Private Service Connect dla zasobów Vertex AI | Google Cloud

Co utworzysz

W tym samouczku utworzysz kompleksowe wdrożenie Vertex AI Pipelines z interfejsem Private Service Connect (PSC), aby umożliwić połączenie z zasobami obliczeniowymi konsumenta, jak pokazano na rysunku 1, z punktami końcowymi innymi niż rfc-1928.

Rysunek 2

782ba8f1f3c3f522.png

W konsumenckim środowisku VPC utworzysz pojedynczy obiekt psc-network-attachment, który będzie korzystać z równorzędnego połączenia DNS, aby rozwiązywać adresy IP maszyn wirtualnych konsumenta w projekcie klienta hostującym Vertex AI Training. Umożliwi to realizację tych przypadków użycia:

  1. wdrożyć Vertex AI Pipelines i skonfigurować maszynę wirtualną proxy jako proxy jawne, co umożliwi jej wykonanie polecenia wget na maszynie wirtualnej w podsieci klasy E;

Czego się nauczysz

  • Tworzenie przyłącza sieci
  • Jak producent może użyć przyłącza sieci do utworzenia interfejsu PSC
  • Jak nawiązać komunikację między producentem a konsumentem za pomocą połączenia równorzędnego DNS
  • Jak nawiązać komunikację z przestrzenią adresów IP innych niż RFC1918 z Vertex AI Pipelines

Czego potrzebujesz

Projekt Google Cloud

Uprawnienia

2. Zanim zaczniesz

Aktualizowanie projektu na potrzeby samouczka

W tym samouczku używamy zmiennych $variables, aby ułatwić implementację konfiguracji gcloud w Cloud Shell.

W Cloud Shell wykonaj te czynności:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

Włączanie interfejsu API

W Cloud Shell wykonaj te czynności:

gcloud services enable "compute.googleapis.com"
gcloud services enable "aiplatform.googleapis.com"
gcloud services enable "dns.googleapis.com"
gcloud services enable "notebooks.googleapis.com"
gcloud services enable "storage.googleapis.com"
gcloud services enable "cloudresourcemanager.googleapis.com"
gcloud services enable "artifactregistry.googleapis.com"
gcloud services enable "cloudbuild.googleapis.com"

3. Konfiguracja dla konsumentów

Utwórz VPC klienta

W Cloud Shell wykonaj te czynności:

gcloud compute networks create consumer-vpc --project=$projectid --subnet-mode=custom

Tworzenie podsieci konsumenckich

W Cloud Shell wykonaj te czynności:

gcloud compute networks subnets create class-e-subnet --project=$projectid --range=240.0.0.0/4 --network=consumer-vpc --region=us-central1

W Cloud Shell wykonaj te czynności:

gcloud compute networks subnets create rfc1918-subnet1 --project=$projectid --range=10.10.10.0/28 --network=consumer-vpc --region=us-central1

Utwórz podsieć przyłącza sieci Private Service Connect

W Cloud Shell wykonaj te czynności:

gcloud compute networks subnets create intf-subnet --project=$projectid --range=192.168.10.0/28 --network=consumer-vpc --region=us-central1

Konfiguracja routera Cloud Router i NAT

W tym samouczku Cloud NAT służy do zapewnienia dostępu do internetu maszynie wirtualnej proxy, która nie ma publicznego adresu IP. Cloud NAT umożliwia maszynom wirtualnym, które mają tylko prywatne adresy IP, łączenie się z internetem, co pozwala im wykonywać zadania takie jak instalowanie pakietów oprogramowania.

W Cloud Shell utwórz router Cloud Router.

gcloud compute routers create cloud-router-for-nat --network consumer-vpc --region us-central1

W Cloud Shell utwórz bramę NAT.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-for-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1 --enable-logging --log-filter=ALL

4. Włączanie IAP

Aby umożliwić IAP połączenie z instancjami maszyn wirtualnych, utwórz regułę zapory sieciowej, która:

  • Dotyczy wszystkich instancji maszyn wirtualnych, które mają być dostępne przez IAP.
  • Zezwala na ruch przychodzący z zakresu adresów IP 35.235.240.0/20. Ten zakres zawiera wszystkie adresy IP, których IAP używa do przekierowywania TCP.

W Cloud Shell utwórz regułę zapory sieciowej IAP.

gcloud compute firewall-rules create ssh-iap-consumer \
    --network consumer-vpc \
    --allow tcp:22 \
    --source-ranges=35.235.240.0/20

5. Tworzenie instancji maszyn wirtualnych konsumentów

W Cloud Shell utwórz instancję maszyny wirtualnej klienta, class-e-vm.

gcloud compute instances create class-e-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=class-e-subnet \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'Class-e server !!' | tee /var/www/html/index.html
      EOF"

W Cloud Shell utwórz instancję maszyny wirtualnej klienta, proxy-vm, która będzie służyć jako jawny serwer proxy dla Vertex AI Pipelines. Do przekierowywania ruchu HTTP będziemy używać aplikacji tinyproxy, chociaż obsługiwany jest też protokół HTTPS.

gcloud compute instances create proxy-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --can-ip-forward \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=rfc1918-subnet1 \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install tinyproxy -y
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'proxy server !!' | tee /var/www/html/index.html
      EOF"

6. Przyłącze sieci Private Service Connect

Przyłącza sieci to zasoby regionalne, które reprezentują stronę konsumenta interfejsu Private Service Connect. Z przyłączem sieci możesz powiązać jedną podsieć, a producent przypisuje adresy IP do interfejsu Private Service Connect z tej podsieci. Podsieć musi znajdować się w tym samym regionie co przyłącze sieci. Przyłącze sieci musi znajdować się w tym samym regionie co usługa producenta.

Tworzenie przyłącza sieci

W Cloud Shell utwórz przyłącze sieci.

gcloud compute network-attachments create psc-network-attachment \
    --region=us-central1 \
    --connection-preference=ACCEPT_AUTOMATIC \
    --subnets=intf-subnet

Wyświetlanie listy przyłączy sieci

W Cloud Shell wyświetl listę przyłączy sieci.

gcloud compute network-attachments list

Opisz przyłącza sieci

W Cloud Shell opisz przyłącze sieci.

gcloud compute network-attachments describe psc-network-attachment --region=us-central1

Zanotuj nazwę psc-network-attachment, psc-network-attachment, która będzie używana przez producenta podczas tworzenia interfejsu Private Service Connect.

Aby wyświetlić adres URL przyłączenia sieci PSC w konsoli Google Cloud, otwórz:

Usługi sieciowe → Private Service Connect → Przyłącze sieci → psc-network-attachment

e191e54a103d2222.png

7. Prywatna strefa DNS

Utworzysz strefę Cloud DNS dla domeny demo.com i wypełnisz ją rekordami A, które będą kierować na adresy IP Twoich maszyn wirtualnych. Później w zadaniu potoków Vertex AI zostanie wdrożona komunikacja równorzędna DNS, która umożliwi dostęp do rekordów DNS konsumenta.

W Cloud Shell wykonaj te czynności:

gcloud dns --project=$projectid managed-zones create private-dns-codelab --description="" --dns-name="demo.com." --visibility="private" --networks="https://compute.googleapis.com/compute/v1/projects/$projectid/global/networks/consumer-vpc"

W Cloud Shell wykonaj polecenie describe na instancjach maszyn wirtualnych, aby uzyskać odpowiednie adresy IP.

gcloud compute instances describe class-e-vm --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe proxy-vm --zone=us-central1-a | grep  networkIP:

W Cloud Shell utwórz zestaw rekordów dla maszyny wirtualnej class-e-vm. Pamiętaj, aby zaktualizować adres IP na podstawie danych wyjściowych środowiska.

gcloud dns --project=$projectid record-sets create class-e-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="240.0.0.2"

W Cloud Shell utwórz zestaw rekordów dla maszyny wirtualnej proxy-vm. Pamiętaj, aby zaktualizować adres IP na podstawie danych wyjściowych środowiska.

gcloud dns --project=$projectid record-sets create proxy-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.2"

Tworzenie reguły zapory sieciowej Cloud Firewall, która zezwala na dostęp z interfejsu PSC

W sekcji poniżej utwórz regułę zapory sieciowej, która zezwala na ruch pochodzący z sieciowego połączenia PSC, aby uzyskiwać dostęp do zasobów obliczeniowych RFC1918 w sieci VPC klienta.

W Cloud Shell utwórz regułę zapory sieciowej ruchu przychodzącego, która zezwala na dostęp z podsieci przyłączenia sieci PSC do maszyny wirtualnej proxy.

gcloud compute firewall-rules create allow-access-to-proxy \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="192.168.10.0/28" \
    --destination-ranges="10.10.0.0/19" \
    --enable-logging

W Cloud Shell utwórz regułę zapory sieciowej zezwalającą na ruch przychodzący, która zezwala na dostęp z podsieci proxy-vm do podsieci class-e.

gcloud compute firewall-rules create allow-access-to-class-e \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="10.10.10.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

8. Aktualizowanie serwera proxy

W następnej sekcji musisz połączyć się z serwerem proxy za pomocą protokołu SSH i zaktualizować plik konfiguracyjny tinyproxy.conf, a następnie zresetować serwer.

Z Cloud Shell

gcloud compute ssh --zone us-central1-a "proxy-vm" --tunnel-through-iap --project $projectid

Otwórz plik konfiguracyjny tinyproxy i zaktualizuj go w wybranym edytorze. Poniżej znajdziesz przykład użycia VIM.

sudo vim /etc/tinyproxy/tinyproxy.conf

# Locate the "Listen" configuration line to restrict listening to only its private IP address of the Proxy-VM, rather than all interfaces. 

Listen 10.10.10.2

# Locate the "Allow" configuration line to allow requests ONLY from the PSC Network Attachment Subnet

Allow 192.168.10.0/24

Save the configs by the following steps:
1. Press the `ESC` key to enter Command Mode.
2. Type `:wq` to save (w) and quit (q).
3. Press `Enter`

Restart the tinyproxy service to apply the changes:
sudo systemctl restart tinyproxy

Validate the tinyproxy service is running:
sudo systemctl status tinyproxy

Perform an exit returning to cloud shell
exit

9. Tworzenie notatnika Jupyter

W sekcji poniżej znajdziesz instrukcje tworzenia notatnika Jupyter. Ten notatnik zostanie użyty do wdrożenia zadania Vertex AI Pipelines, które wysyła polecenie wget z Vertex AI Pipelines do instancji testowych. Ścieżka danych między Vertex AI Pipelines a siecią konsumenta zawierającą instancje korzysta z interfejsu sieciowego Private Service Connect.

Tworzenie konta usługi zarządzanego przez użytkownika

W następnej sekcji utworzysz konto usługi, które będzie powiązane z instancją Vertex AI Workbench używaną w tym samouczku.

W tym samouczku do konta usługi zostaną przypisane te role:

W Cloud Shell utwórz konto usługi.

gcloud iam service-accounts create notebook-sa \
    --display-name="notebook-sa"

W Cloud Shell zaktualizuj konto usługi, przypisując mu rolę Administrator miejsca na dane.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"

W Cloud Shell zaktualizuj konto usługi, przypisując mu rolę Użytkownik Vertex AI.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"

W Cloud Shell zaktualizuj konto usługi, przypisując mu rolę Administrator Artifact Registry.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"

W Cloud Shell zaktualizuj konto usługi, przypisując mu rolę Edytujący Cloud Build.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/cloudbuild.builds.editor"

W Cloud Shell zezwól kontu usługi notatnika na używanie domyślnego konta usługi Compute Engine.

gcloud iam service-accounts add-iam-policy-binding \
    $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')-compute@developer.gserviceaccount.com \
    --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

10. Tworzenie instancji Vertex AI Workbench

W sekcji poniżej utwórz instancję Vertex AI Workbench, która zawiera utworzone wcześniej konto usługi notebook-sa.

W Cloud Shell utwórz instancję private-client.

gcloud workbench instances create workbench-tutorial --vm-image-project=cloud-notebooks-managed --vm-image-family=workbench-instances --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=rfc1918-subnet1 --disable-public-ip --shielded-secure-boot=true --shielded-integrity-monitoring=true --shielded-vtpm=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

11. Aktualizacja agenta usługi Vertex AI

Vertex AI działa w Twoim imieniu, wykonując operacje takie jak uzyskiwanie adresu IP z podsieci przyłącza sieci PSC używanej do tworzenia interfejsu PSC. W tym celu Vertex AI używa agenta usługi (wymienionego poniżej), który wymaga uprawnień administratora sieci.

service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com

W Cloud Shell uzyskaj numer projektu.

gcloud projects describe $projectid | grep projectNumber

W Cloud Shell uzyskaj numer projektu.

gcloud projects describe $projectid | grep projectNumber
projectNumber: '234086459238'

W Cloud Shell ustaw numer projektu.

projectnumber=YOUR-PROJECT-Number

W Cloud Shell utwórz konto usługi dla AI Platform. Pomiń ten krok, jeśli w projekcie masz już konto usługi.

gcloud beta services identity create --service=aiplatform.googleapis.com --project=$projectnumber

W Cloud Shell zaktualizuj konto agenta usługi, przypisując mu rolę compute.networkAdmin.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/compute.networkAdmin"

W Cloud Shell zaktualizuj konto agenta usługi, nadając mu rolę dns.peer.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/dns.peer"

Aktualizacja domyślnego konta usługi

Włącz interfejs Compute Engine API i przyznaj domyślnemu kontu usługi dostęp do Vertex AI. Pamiętaj, że zanim zmiana dostępu zostanie zastosowana, może minąć trochę czasu.

W Cloud Shell zaktualizuj domyślne konto usługi, przypisując mu rolę aiplatform.user.

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:$projectnumber-compute@developer.gserviceaccount.com" \
    --role="roles/aiplatform.user"

W Cloud Shell zaktualizuj domyślne konto usługi, nadając mu rolę storage.admin.

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:$projectnumber-compute@developer.gserviceaccount.com" \
    --role="roles/storage.admin"

W Cloud Shell zaktualizuj domyślne konto usługi, nadając mu rolę storage.admin.

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:$projectnumber-compute@developer.gserviceaccount.com" \
    --role="roles/artifactregistry.admin"

12. Włączanie narzędzia Tcpdump

Aby sprawdzić łączność IP z Vertex AI Pipelines, możemy użyć narzędzia TCPDUMP. Dzięki temu będziemy mogli obserwować komunikację pochodzącą z podsieci PSC Network Attachment, 192.168.10.0/28, podczas wywoływania żądania GET z Vertex AI Pipelines do maszyny wirtualnej class-e-vm.demo.com (240.0.0.0/4).

Połącz się z maszyną wirtualną serwera proxy przez SSH w Cloud Shell.

gcloud compute ssh --zone us-central1-a "proxy-vm" --tunnel-through-iap --project $projectid

W systemie operacyjnym maszyny wirtualnej proxy wykonaj filtrowanie tcpdump na podsieci przyłączenia do sieci maszyny wirtualnej klasy E i PSC.

sudo tcpdump -i any net 240.0.0.0/4 or 192.168.10.0/28 -nn

Otwórz nową kartę Cloud Shell, zaktualizuj zmienną projektu i połącz się z maszyną wirtualną class-e-vm za pomocą SSH.

gcloud compute ssh --zone us-central1-a "class-e-vm" --tunnel-through-iap --project $projectid

Z systemu operacyjnego maszyny wirtualnej klasy E wykonaj filtrowanie tcpdump w podsieci proxy-vm.

sudo tcpdump -i any net 10.10.10.0/28 -nn

13. Wdrażanie zadania potoku Vertex AI

W następnej sekcji utworzysz notatnik, aby wykonać polecenie wget z potoków Vertex AI do jawnego serwera proxy. Dzięki temu możesz uzyskać dostęp do maszyn wirtualnych innych niż RFC 1918, np. class-e-vm. W przypadku dostępu do rfc1918-vm przez Vertex AI Pipelines nie jest wymagany jawny serwer proxy, ponieważ jego celem jest adres IP RFC 1918.

Uruchom zadanie trenowania w instancji Vertex AI Workbench.

  1. W konsoli Google Cloud otwórz kartę instancji na stronie Vertex AI Workbench.
  2. Obok nazwy instancji Vertex AI Workbench (workbench-tutorial) kliknij Otwórz JupyterLab. Instancja Vertex AI Workbench otworzy się w JupyterLab.
  3. Wybierz Plik > Nowy > Notatnik.
  4. Wybierz Jądro > Python 3.

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

# Install gcloud
!pip install google-cloud

# Install the pipeline required packages
!pip install --upgrade google-cloud-aiplatform \
                         google-cloud-storage \
                         kfp \
                         google-cloud-pipeline-components

# Import libraries
from time import gmtime, strftime
import json
import requests

W notatniku JupyterLab utwórz nową komórkę, zaktualizuj i uruchom poniższy kod. Pamiętaj, aby zastąpić PROJECT_ID szczegółami środowiska.

import json
import requests
import pprint

PROJECT_ID = 'YOUR-PROJECT-ID' #Enter your project ID
PROJECT_NUMBER=!gcloud projects list --filter="project_id:$PROJECT_ID" --format="value(PROJECT_NUMBER)"
PROJECT_NUMBER=str(PROJECT_NUMBER).strip('[').strip(']').strip("'")
print(PROJECT_NUMBER)

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

# us-central1 is used for the codelab
REGION = "us-central1" #@param {type:"string"}
SERVICE_NAME = "aiplatform" #@param {type:"string"}
SERVICE ="{}.googleapis.com".format(SERVICE_NAME)
ENDPOINT="{}-{}.googleapis.com".format(REGION, SERVICE_NAME)
API_VERSION = "v1" # @param {type: "string"}

LOCATION = REGION

W notatniku JupyterLab utwórz nową komórkę i uruchom poniższą konfigurację. Zwróć uwagę na te elementy:

  • proxy_server = "http://proxy-vm.demo.com:8888" FQDN jest powiązana z maszyną wirtualną serwera proxy wdrożoną w sieci VPC konsumenta. W kolejnym kroku użyjemy komunikacji równorzędnej DNS, aby rozpoznać w pełni kwalifikowaną nazwę domeny.
%%writefile main.py

import logging
import socket
import sys
import os

def make_api_request(url: str, proxy_vm_ip: str, proxy_vm_port: str):
    """
    Makes a GET request to a non-rfc1918 API and saves the response.

    Args:
        url: The URL of the API to send the request to.
    """
    import requests

    try:
        # response = requests.get(url)
        proxy_server = f"http://proxy-vm.demo.com:8888" # replace with you VM's IP and proxy port.

        proxies = {
          "http": proxy_server,
          "https": proxy_server,
        }

        response = requests.get(url, proxies=proxies)
        logging.info(response.text)

        response.raise_for_status()  # Raise an exception for bad status codes
        logging.info(f"Successfully fetched data from {url}")
    except requests.exceptions.RequestException as e:
        logging.error(f"An error occurred: {e}")
        raise e

if __name__ == '__main__':
  # Configure logging to print clearly to the console
  logging.basicConfig(
      level=logging.INFO,
      format='%(levelname)s: %(message)s',
      stream=sys.stdout
  )
  url_to_test = os.environ['NONRFC_URL']
  proxy_vm_ip = os.environ['PROXY_VM_IP']
  proxy_vm_port = os.environ['PROXY_VM_PORT']

  logging.info(f"url_to_test: {url_to_test}")
  logging.info(f"proxy_vm_ip: {proxy_vm_ip}")
  logging.info(f"proxy_vm_port: {proxy_vm_port}")
  make_api_request(url_to_test, proxy_vm_ip, proxy_vm_port)

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

%%writefile Dockerfile
FROM python:3.9-slim

RUN apt-get update && \
  apt-get install -y iputils-ping && \
  apt-get install -y wget

RUN pip install cloudml-hypertune requests kfp

COPY main.py /main.py

ENTRYPOINT ["python3", "/main.py"]

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

!gcloud artifacts repositories create pipelines-test-repo-psc --repository-format=docker --location=us-central1

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

IMAGE_PROJECT = PROJECT_ID
IMAGE_REPO = 'pipelines-test-repo-psc' 
IMAGE_NAME = 'nonrfc-ip-call'
TAG = 'v1'

IMAGE_URI= f'us-central1-docker.pkg.dev/{IMAGE_PROJECT}/{IMAGE_REPO}/{IMAGE_NAME}:{TAG}'
IMAGE_URI

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

!gcloud auth configure-docker us-docker.pkg.dev --quiet

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie: Zignoruj błąd (gcloud.builds.submit), jeśli występuje.

!gcloud builds submit --tag {IMAGE_URI} --region=us-central1

W notatniku JupyterLab utwórz i uruchom komórkę poniżej. Zwróć uwagę na te elementy:

  • DNS Peering do sieci VPC konsumenta jest konfigurowany za pomocą dnsPeeringConfigs (dnsPeeringConfigs) dla nazwy domeny demo.com.
  • Serwer proxy zdefiniowany jako zmienna PROXY_VM_IP to proxy-vm.demo.com. Rozpoznawanie jest obsługiwane przez połączenie równorzędne DNS w sieci VPC konsumenta.
  • Port 8888 to port nasłuchiwania (domyślny) skonfigurowany w tinyproxy.
  • Wget do class-e-vm-demo.com jest rozpoznawany przez połączenie równorzędne DNS
  • Kod określa „psc-network-attachment” dla Vertex AI, co umożliwia wykorzystanie podsieci przyłącza sieci do wdrożenia 2 instancji interfejsu PSC.
import json
from datetime import datetime


JOB_ID_PREFIX='test_psci-nonRFC' #@param {type:"string"}
JOB_ID = '{}_{}'.format(JOB_ID_PREFIX, datetime.now().strftime("%Y%m%d%H%M%S"))

# PSC-I configs

PRODUCER_PROJECT_ID = PROJECT_ID
DNS_DOMAIN = 'class-e-vm.demo.com' #@param {type:"string"}
NON_RFC_URL = f"http://{DNS_DOMAIN}"

PROXY_VM_IP = "proxy-vm.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8888" #@param {type:"string"}

CUSTOM_JOB = {
  "display_name": JOB_ID,
  "job_spec": {
      "worker_pool_specs": [
          {
           "machine_spec": {
             "machine_type": "n1-standard-4",
           },
           "replica_count": 1,
           "container_spec": {
             "image_uri": IMAGE_URI,
             "env": [{
               "name": "NONRFC_URL",
               "value": NON_RFC_URL
             },
             {
               "name": "PROXY_VM_IP",
               "value": PROXY_VM_IP
             },
             {
               "name": "PROXY_VM_PORT",
               "value": PROXY_VM_PORT
             }]
           },
         },
      ],
      "enable_web_access": True,
      "psc_interface_config": {
        "network_attachment": "psc-network-attachment",
        "dns_peering_configs": [
          {
            "domain": "demo.com.",
            "target_project": PROJECT_ID,
            "target_network": "consumer-vpc"
          },
        ]
      },
  }
}

print(json.dumps(CUSTOM_JOB, indent=2))

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

import requests
bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/customJobs/"

print("request_uri: ", request_uri)

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

response_autopush = requests.post(request_uri, json=CUSTOM_JOB, headers=headers)
response = response_autopush
print("response:", response)
if response.reason == 'OK':
  job_name = response.json()['name']
  job_id = job_name.split('/')[-1]
  print("Created Job: ", response.json()['name'])
else:
  print(response.text)

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

# Print KFP SDK version (should be >= 1.6)
! python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

# Print AI Platform version
! python3 -c "from google.cloud import aiplatform; print('AI Platform version: {}'.format(aiplatform.__version__))"

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

BUCKET_URI = "your-unique-bucket" # Provide a globally unique bucket name

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

!gcloud storage buckets create gs://{BUCKET_URI}

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

# pipeline parameters
CACHE_PIPELINE = False # @param {type: "string"}
_DEFAULT_IMAGE = IMAGE_URI
BUCKET_URI = "gs://{BUCKET_URI}"  # @param {type: "string"}
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/intro"
PIPELINE_DISPLAY_NAME = "pipeline_nonRFCIP" # @param {type: "string"}

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

from re import S
import kfp
from kfp import dsl
from kfp.dsl import container_component, ContainerSpec
from kfp import compiler
from google.cloud import aiplatform


# ==== Component with env variable ====

@container_component
def dns_peering_test_op(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    return ContainerSpec(
        image=_DEFAULT_IMAGE,
        command=["bash", "-c"],
        args=[
            """
            apt-get update && apt-get install inetutils-traceroute inetutils-ping netcat-openbsd curl -y

            echo "Local IP(s): $(hostname -I)"

            echo "Attempting to trace route to %s"
            traceroute -w 1 -m 7 "%s"

            echo "Sending curl requests to http://%s via proxy %s:%s and recording trace..."
            if curl -L -v --trace-ascii /dev/stdout -x http://%s:%s "http://%s"; then
                echo "Curl request succeeded!"
            else
                echo "Curl request failed!"
                exit 1
            fi
            """ % (dns_domain, dns_domain, dns_domain, proxy_vm_ip, proxy_vm_port, proxy_vm_ip, proxy_vm_port, dns_domain)

        ]
    )

# ==== Pipeline ====
@dsl.pipeline(
    name="dns-peering-test-pipeline",
    description="Test DNS Peering using env variable",
    pipeline_root=PIPELINE_ROOT,
)
def dns_peering_test_pipeline(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    dns_test_task = dns_peering_test_op(dns_domain=dns_domain, proxy_vm_ip=proxy_vm_ip, proxy_vm_port=proxy_vm_port)
    dns_test_task.set_caching_options(enable_caching=CACHE_PIPELINE)

# ==== Compile pipeline ====
if __name__ == "__main__":
    aiplatform.init(project=PROJECT_ID, location=LOCATION)

    compiler.Compiler().compile(
        pipeline_func=dns_peering_test_pipeline,
        package_path="dns_peering_test_pipeline.yaml",
    )
    print("✅ Pipeline compiled to dns_peering_test_pipeline.yaml")

W notatniku JupyterLab utwórz nową komórkę i uruchom to polecenie:

# Define the PipelineJob body; see API Reference https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.pipelineJobs/create

import requests, json
import datetime

bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/pipelineJobs/"

print("request_uri: ", request_uri)

14. Weryfikacja interfejsu PSC

Adresy IP dołączonych sieci używane przez potoki Vertex AI możesz też wyświetlić, wykonując te czynności:

Usługi sieciowe → Private Service Connect → Przyłącze sieci → psc-network-attachment

Wybierz projekt najemcy (nazwa projektu kończy się na -tp).

f47150235fedb8ce.png

Wyróżnione pole oznacza adres IP używany przez Vertex AI Pipelines z załącznika sieci PSC.

39e7b251aeb4f191.png

15. Weryfikacja Cloud Logging

Pierwsze uruchomienie zadania Vertex AI Pipelines zajmie około 14 minut, a kolejne będą znacznie krótsze. Aby sprawdzić, czy operacja się powiodła, wykonaj te czynności:

Otwórz kolejno Vertex AI → Trenowanie → Zadania niestandardowe.

Wybieranie wykonanego zadania niestandardowego

a9be0395c842aa6f.png

Kliknij Wyświetl logi.

53e30765ba5827f3.png

Gdy Cloud Logging będzie dostępny, wybierz Uruchom zapytanie, które generuje wyróżniony wybór poniżej, potwierdzający udane pobranie za pomocą polecenia wget z Vertex AI Pipelines na maszynę wirtualną klasy E.

f2c5d9fdf5cc8bed.png

3b3788603bb433ee.png

16. Weryfikacja za pomocą narzędzia TCPDump

Sprawdźmy dane wyjściowe TCPDUMP, które dodatkowo potwierdzają łączność z instancjami obliczeniowymi:

Z proxy-vm obserwuj HTTP GET i 200 OK.

03:05:34.778574 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778946 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.778974 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781999 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906678 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

Na maszynie wirtualnej class-e-vm sprawdź, czy pojawiły się żądanie HTTP GET i odpowiedź 200 OK.

03:05:34.778768 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778819 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.781815 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781856 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906503 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

17. Czyszczenie danych

W Cloud Shell usuń komponenty samouczka.

gcloud compute instances delete proxy-vm --zone=us-central1-a --quiet

gcloud compute instances delete workbench-tutorial --zone=us-central1-a --quiet

gcloud compute routers delete cloud-router-for-nat --region=us-central1 --quiet

gcloud compute network-attachments delete psc-network-attachment --region=us-central1 --quiet

gcloud compute networks subnets delete intf-subnet rfc1918-subnet1 --region=us-central1 --quiet

gcloud dns record-sets delete class-e-vm.demo.com --zone=private-dns-codelab  --type=A
gcloud dns record-sets delete proxy-vm.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab
gcloud compute networks delete consumer-vpc --quiet

18. Gratulacje

Gratulujemy. Udało Ci się skonfigurować i zweryfikować interfejs Private Service Connect z Vertex AI Pipelines.

Infrastruktura konsumenta została utworzona, a do niej dodano przyłącze sieci, które umożliwiło producentowi utworzenie maszyny wirtualnej z wieloma interfejsami sieciowymi, aby połączyć komunikację konsumenta i producenta. Dowiedzieliśmy się, jak utworzyć połączenie równorzędne DNS podczas wdrażania serwera proxy jawnego w sieci VPC konsumenta, co umożliwiło połączenie z instancją maszyny wirtualnej klasy E, która nie jest bezpośrednio kierowana z Vertex.

Cosmopup uważa, że samouczki są świetne!!

c911c127bffdee57.jpeg

Co dalej?

Więcej informacji i filmy

Dokumentacja