Interfejs SWP usługi Vertex AI Pipelines PSC

1. Wprowadzenie

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

Jeśli przyłącze sieci akceptuje połączenie z interfejsu Private Service Connect, Google Cloud przydziela 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.

d7dc28d6567e6283.pngIlustracja 1.

Wskazówki dotyczące osiągalności interfejsu PSC Vertex AI

  • Interfejs PSC Vertex AI może kierować ruch do miejsc docelowych w sieci VPC lub lokalnie w bloku adresów RFC1918.
  • Kierowanie interfejsu PSC na bloki adresów inne niż RFC-1918 wymaga jawnego serwera proxy wdrożonego w sieci VPC klienta z adresem RFC-1918. W ramach wdrożenia Vertex AI serwer proxy musi być zdefiniowany wraz z w pełni kwalifikowaną nazwą domeny punktu końcowego. Ilustracja 1 przedstawia bezpieczny internetowy serwer proxy (SWP) w trybie proxy jawnego skonfigurowany w sieci VPC klienta, aby ułatwić routing do tych zakresów CIDR, które nie są zgodne z RFC-1918:
  1. 240.0.0.0/4
  2. 203.0.113.0/24
  3. 10.10.20.0/28 nie wymaga serwera proxy, ponieważ mieści się w zakresie RFC-1918.
  4. Ruch wychodzący z internetu

Połączenie z internetem w przypadku sieci dzierżawy zarządzanej przez Google:

Interfejs PSC Vertex AI bez Ustawień usługi VPC

  • Jeśli skonfigurujesz wdrożenie tylko za pomocą interfejsu PSC, zachowa ono domyślny dostęp do internetu. Ten ruch wychodzący opuszcza sieć najemcy zarządzaną przez Google.

Interfejs PSC Vertex AI z Ustawieniami usługi VPC

  • Gdy Twój projekt jest częścią granicy Ustawień usługi VPC, domyślny dostęp do internetu w zarządzanej przez Google instancji jest blokowany przez tę granicę, aby zapobiec wydobywaniu danych.
  • Aby w tym scenariuszu umożliwić wdrożeniu dostęp do publicznego internetu, musisz jawnie skonfigurować bezpieczną ścieżkę ruchu wychodzącego, która kieruje ruch przez sieć VPC połączoną z Vertex AI. Jednym ze sposobów na to jest wdrożenie serwera proxy w sieci VPC z adresem RFC 1918 w połączeniu z bramą Cloud NAT. Pamiętaj, że do przekierowania ruchu do internetu możesz też użyć Secure Web Proxy. Utworzenie Secure Web Proxy automatycznie tworzy bramę Cloud NAT.

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ć łączność między producentem a zasobami obliczeniowymi konsumenta, jak pokazano na rysunku 1, z punktem końcowym innym niż RFC 1918 w class-e-subnet.

2d095dc2f4de6b4b.pngRysunek 2

W sieci VPC klienta utworzysz pojedynczy psc-network-attachment, który będzie korzystać z peeringu DNS do rozpoznawania maszyn wirtualnych klienta w projekcie najemcy hostującym Vertex AI Training. Umożliwi to następujące przypadki użycia:

wdrożyć Vertex AI Pipelines i skonfigurować Secure Web Proxy w trybie jawnego serwera proxy, co umożliwi mu wykonanie wget na maszynie wirtualnej w podsieci klasy E;

Czego się nauczysz

  • Tworzenie przyłącza sieci
  • Jak producent może używać przyłącza sieci do tworzenia interfejsu PSC
  • Jak skonfigurować połączenie równorzędne DNS, aby rozpoznawać domeny prywatne skonfigurowane w sieci VPC konsumenta z sieci VPC zarządzanych przez Google
  • Jak przekierować ruch z interfejsu PSC Vertex AI do Secure Web Proxy
  • Jak nawiązać komunikację z przestrzenią adresów IP innych niż RFC-1918 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-ID]
projectid=YOUR-PROJECT-ID
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"
gcloud services enable "networkservices.googleapis.com"
gcloud services enable "networksecurity.googleapis.com"
gcloud services enable "certificatemanager.googleapis.com"

3. Konfiguracja konsumencka

Tworzenie sieci VPC konsumenta

W Cloud Shell wykonaj te czynności:

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

Tworzenie podsieci konsumenta

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 --enable-private-ip-google-access

Utwórz podsieć tylko-proxy

gcloud compute networks subnets create proxy-only-uscentral1 \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-central1 \
    --network=consumer-vpc \
    --range=10.10.100.0/26

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 \
--enable-private-ip-google-access

Konfiguracja routera Cloud Router i NAT

Secure Web Proxy Google Cloud automatycznie udostępnia bramę Cloud NAT i powiązany z nią router Cloud Router w regionie, w którym jest wdrażany, oraz zarządza nimi.

4. Włączanie IAP

Aby umożliwić IAP (Identity Aware Proxy) 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 \ 
    --private-network-ip=240.0.0.2

6. Bezpieczny internetowy serwer proxy

Tryb jawny Secure Web Proxy (lub tryb jawnego routingu serwera proxy) to metoda wdrażania, w której obciążenia klienta muszą być jawnie skonfigurowane do używania wewnętrznego adresu IP lub pełnej i jednoznacznej nazwy domeny oraz portu SWP jako serwera proxy przekazującego.

W poniższych krokach pamiętaj, aby zastąpić symbol YOUR-PROJECT-ID identyfikatorem projektu.

Utwórz internetowy serwer proxy:

W Cloud Shell utwórz plik policy.yaml za pomocą edytora tekstu:

cat > policy.yaml << EOF
description: basic Secure Web Proxy policy
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
EOF

W Cloud Shell wygeneruj zasadę Secure Web Proxy:

gcloud network-security gateway-security-policies import policy1 \
    --source=policy.yaml \
    --location=us-central1

W sekcji poniżej utwórz regułę zezwalającą na dostęp do class-e-vm na podstawie hosta sessionMatcher.

W Cloud Shell utwórz plik rule1.yaml za pomocą edytora tekstu:

cat > rule1.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-nonrfc-classe
description: Allow nonrfc class-e
enabled: true
priority: 1
basicProfile: ALLOW
sessionMatcher: host() == 'class-e-vm.demo.com'
EOF

W następnej sekcji utwórz regułę, która umożliwi notatnikowi Jupyter dostęp do instalacji apache2 na maszynie wirtualnej "class-e".

W Cloud Shell utwórz plik rule2.yaml za pomocą edytora tekstu:

cat > rule2.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-apache2
description: Allow Apache2 install on class-e VM
enabled: true
priority: 2
basicProfile: ALLOW
sessionMatcher: inIpRange(source.ip,'240.0.0.2')
EOF

W Cloud Shell wygeneruj regułę zasad zabezpieczeń 1:

gcloud network-security gateway-security-policies rules import allow-nonrfc-classe \
    --source=rule1.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

W Cloud Shell wygeneruj regułę zasady zabezpieczeń2:

gcloud network-security gateway-security-policies rules import allow-apache2 \
    --source=rule2.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Aby obsługiwać Vertex AI Training, skonfiguruj bramę Secure Web Proxy za pomocą tych ustawień:

  • Port nasłuchiwania: użyj tego samego portu, który został skonfigurowany w ustawieniach serwera proxy w kodzie aplikacji Vertex AI (np. 8080).
  • Adres: przypisz prywatny adres IP z zakresu RFC 1918.
  • Tryb routingu: ustaw wartość EXPLICIT_ROUTING_MODE.

W Cloud Shell utwórz plik gateway.yaml, aby zdefiniować bramę Secure Web Proxy:

cat > gateway.yaml << EOF
name: projects/$projectid/locations/us-central1/gateways/swp1
type: SECURE_WEB_GATEWAY
addresses: ["10.10.10.5"]
ports: [8080]
gatewaySecurityPolicy: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
network: projects/$projectid/global/networks/consumer-vpc
subnetwork: projects/$projectid/regions/us-central1/subnetworks/rfc1918-subnet1
routingMode: EXPLICIT_ROUTING_MODE
EOF

W Cloud Shell wygeneruj instancję Secure Web Proxy:

gcloud network-services gateways import swp1 \
    --source=gateway.yaml \
    --location=us-central1

Wdrożenie Secure Web Proxy może potrwać kilka minut.

e8a4cf23bfc63030.png

7. 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_MANUAL \
    --subnets=intf-subnet

Uwaga: nie musisz wyraźnie podawać identyfikatora projektu w tym załączniku. Gdy skonfigurujesz Vertex AI, projekt najemcy zarządzany przez Google zostanie automatycznie dodany tak, jakby był skonfigurowany jako „Akceptuj automatycznie”.

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ę przyłącza sieci PSC, 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

b969cca5242d9c8a.png

8. Prywatna strefa DNS

Utworzysz strefę Cloud DNS dla demo.com i wypełnisz ją rekordami A, które będą kierować na adresy IP Twoich maszyn wirtualnych. Później w zadaniu potoku Vertex AI Pipelines zostanie wdrożone połączenie równorzędne DNS, które umożliwi mu dostęp do rekordów DNS klienta.

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 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 Secure Web Proxy, pamiętając o zaktualizowaniu adresu IP na podstawie danych wyjściowych środowiska.

gcloud dns --project=$projectid record-sets create explicit-swp.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.5"

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

W następnej sekcji utwórz regułę zapory sieciowej, która zezwala na ruch pochodzący z załącznika sieci PSC do zasobów obliczeniowych RFC 1918 w sieci VPC klienta.

W Cloud Shell utwórz regułę zapory sieciowej zezwalającą na ruch przychodzący, która zezwala na dostęp z podsieci tylko dla proxy do podsieci klasy E. SWP inicjuje połączenie z podsiecią tylko-proxy jako adresem źródłowym.

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.100.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

9. Tworzenie notatnika Jupyter

W sekcji poniżej znajdziesz instrukcje tworzenia notatnika Jupyter. Ten notatnik zostanie użyty do wdrożenia zadania potoku Vertex AI, które wysyła 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 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:

Zaloguj się w Cloud Shell i wykonaj te czynności:

utworzyć konto usługi;

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

Zaktualizuj konto usługi, przypisując mu rolę administratora pamięci masowej.

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

Zaktualizuj konto usługi, przypisując mu rolę użytkownika AI Platform.

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

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"

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"

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ę klienta prywatnego.

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, aby wykonywać 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

Uwaga: zanim zaktualizujesz uprawnienia agenta usługi, otwórz Vertex AI w konsoli Cloud, aby sprawdzić, czy interfejs Vertex AI API jest włączony.

W Cloud Shell:

Uzyskaj numer projektu.

gcloud projects describe $projectid | grep projectNumber

Ustaw numer projektu.

projectnumber=YOUR-PROJECT-NUMBER

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

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"

Zaktualizuj konto agenta usługi, przypisują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.

Aby zaktualizować domyślne konto usługi, wykonaj te czynności w Cloud Shell:

Zaktualizuj domyślne konto usługi, przypisując do niego rolę aiplatform.user.

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

Zaktualizuj domyślne konto usługi, przypisując do niego rolę storage.admin.

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

Zaktualizuj domyślne konto usługi, przypisując do niego rolę artifactregistry.admin.

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

12. Zainstaluj Apache2 i włącz Tcpdump na maszynie wirtualnej „class-e-vm”:

Zainstaluj class-e-vm za pomocą Secure Web Proxy:

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

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

sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" update
sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" install apache2 -y
sudo service apache2 restart
echo 'class-e Server !!' | sudo tee /var/www/html/index.html

Wykonaj filtrowanie tcpdump w podsieci tylko-proxy używanej przez Secure Web Proxy do przekazywania ruchu do miejsc docelowych.

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

sudo tcpdump -i any net 10.10.100.0/24 -nn

Uwaga: aby otworzyć sesję JupyterLab, włącz prywatny dostęp do Google w podsieci instancji workbench-tutorial.

13. Wdrażanie zadania potoku Vertex AI

W następnej sekcji utworzysz notatnik, aby wykonać wget z Vertex AI Pipelines do jawnego serwera proxy. Dzięki temu możesz docierać do maszyn wirtualnych innych niż RFC 1918, np. class-e-vm. Aby potoki Vertex AI mogły uzyskać dostęp do rfc1918-vm, 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ę, 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://explicit-swp.demo.com:8080"
  • Z maszyną wirtualną proxy wdrożoną w sieci VPC konsumenta jest powiązana w pełni kwalifikowana nazwa domeny. 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 nonRFC-1918 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://explicit-swp.demo.com:8080" # replace it with your Secure Web proxy Ip-address and the 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.
  • Internetowy serwer proxy w trybie routingu jawnego to w tym przypadku explicit-swp.demo.com. Rozpoznawanie nazw jest obsługiwane przez połączenie równorzędne DNS w sieci VPC konsumenta.
  • Port 8080 to port nasłuchiwania (domyślny) skonfigurowany w Secure Web Proxy.
  • wget do class-e-vm-demo.com jest rozpoznawane przez połączenie równorzędne DNS.
  • Kod określa „psc-network-attachment” dla Vertex, co umożliwia mu 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 = "explicit-swp.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8080" #@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ńcząca się na -tp).

a2e0b6d6243f26f1.png

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

11e411ea919d3bad.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 wszystko się udało:

Przejdź do Vertex AI → Trenowanie → Zadania niestandardowe.

Wybieranie wykonanego zadania niestandardowego

2f467254aa0c2e3a.png

Kliknij Wyświetl logi.

8d525d3b152bcc61.png

Gdy Cloud Logging będzie dostępny, wybierz Uruchom zapytanie, które generuje wyróżniony wybór poniżej, potwierdzający pomyślne wget z Vertex AI Pipelines do class-e-vm.

a4f9e9167f4ce1ae.png

38972f834aa2bd1d.png

16. Weryfikacja za pomocą narzędzia TCPDump

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

Od class-e-vm obserwuj HTTP GET i 200 OK

XXXXXXXXX@class-e-vm:~$ sudo tcpdump -i any net 10.10.100.0/28 -nn
tcpdump: data link type LINUX_SLL2
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on any, link-type LINUX_SLL2 (Linux cooked v2), snapshot length 262144 bytes
05:51:14.173641 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [S], seq 1747181041, win 65535, options [mss 1420,sackOK,TS val 3942828403 ecr 0,nop,wscale 8], length 0
05:51:14.173668 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [S.], seq 3013226100, ack 1747181042, win 64768, options [mss 1420,sackOK,TS val 1886125065 ecr 3942828403,nop,wscale 7], length 0
05:51:14.174977 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [.], ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 0
05:51:14.175066 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [P.], seq 1:223, ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 222: HTTP: GET / HTTP/1.1
05:51:14.175096 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [.], ack 223, win 505, options [nop,nop,TS val 1886125066 ecr 3942828405], length 0
05:51:14.239042 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [P.], seq 1:246, ack 223, win 505, options [nop,nop,TS val 1886125130 ecr 3942828405], length 245: HTTP: HTTP/1.1 200 OK

17. Czyszczenie danych

W Cloud Shell usuń komponenty samouczka.

gcloud workbench instances delete workbench-tutorial --project=$projectid --location=us-central1-a

gcloud network-security gateway-security-policies rules delete allow-nonrfc-classe \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies rules delete allow-apache2 \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies delete policy1 \
    --location=us-central1
gcloud network-services gateways delete swp1 \
    --location=us-central1

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 explicit-swp.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab

gcloud computeinstances delete class-e-vm --project=$projectid --zone=us-central1-a --quiet
gcloud compute networks delete consumer-vpc --quiet

18. Gratulacje

Gratulacje. Udało Ci się skonfigurować i zweryfikować połączenie między interfejsem Private Service Connect Vertex AI Pipelines a zakresami adresów IP spoza RFC za pomocą Secure Web Proxy.

Utworzono infrastrukturę konsumenta i dodano załącznik sieciowy, który umożliwił producentowi utworzenie maszyny wirtualnej z wieloma interfejsami sieciowymi, aby połączyć komunikację konsumenta i producenta. Dowiedziałeś się, jak utworzyć połączenie równorzędne DNS podczas wdrażania w sieci VPC konsumenta serwera proxy jawnego, który umożliwiał połączenie z instancją class-e-vm, do której nie można było bezpośrednio kierować ruchu z Vertex.

678ba30d64a76795.png

Co dalej?

Więcej informacji i filmy

Dokumentacja