Vertex AI Pipelines PSC Interface SWP

1. Pengantar

Antarmuka Private Service Connect adalah resource yang memungkinkan jaringan Virtual Private Cloud (VPC) produsen memulai koneksi ke berbagai tujuan dalam jaringan VPC konsumen. Jaringan produsen dan konsumen dapat berada dalam project dan organisasi yang berbeda.

Jika lampiran jaringan menerima koneksi dari antarmuka Private Service Connect, Google Cloud akan mengalokasikan alamat IP ke antarmuka dari subnet konsumen yang ditentukan oleh lampiran jaringan. Jaringan konsumen dan produsen terhubung dan dapat berkomunikasi menggunakan alamat IP internal.

Koneksi antara lampiran jaringan dan antarmuka Private Service Connect mirip dengan koneksi antara endpoint Private Service Connect dan lampiran layanan, tetapi memiliki dua perbedaan utama:

  • Lampiran jaringan memungkinkan jaringan produsen memulai koneksi ke jaringan konsumen (traffic keluar layanan terkelola), sedangkan endpoint memungkinkan jaringan konsumen memulai koneksi ke jaringan produsen (traffic masuk layanan terkelola).
  • Koneksi antarmuka Private Service Connect bersifat transitif. Artinya, jaringan produsen dapat berkomunikasi dengan jaringan lain yang terhubung ke jaringan konsumen.

d7dc28d6567e6283.pngGambar:1

Pertimbangan aksesibilitas Antarmuka PSC Vertex AI

  • Antarmuka PSC Vertex AI dapat merutekan traffic ke tujuan di VPC atau lokal dalam blok alamat RFC1918.
  • Penargetan PSC-Interface ke blok alamat non-RFC-1918 memerlukan proxy eksplisit yang di-deploy di VPC konsumen dengan alamat RFC-1918. Dalam deployment Vertex AI, proxy harus ditentukan bersama dengan FQDN endpoint target. Lihat gambar 1 yang menunjukkan proxy web Aman (SWP) mode proxy eksplisit yang dikonfigurasi di VPC konsumen untuk memfasilitasi perutean ke CIDR non-RFC-1918 berikut:
  1. 240.0.0.0/4
  2. 203.0.113.0/24
  3. 10.10.20.0/28 tidak memerlukan proxy, termasuk dalam rentang RFC-1918.
  4. Traffic Keluar Internet

Koneksi ke Internet untuk Jaringan Tenant yang Dikelola Google:

Antarmuka PSC Vertex AI tanpa VPC-SC

  • Saat Anda mengonfigurasi deployment hanya dengan Antarmuka PSC, deployment tersebut akan mempertahankan akses internet default-nya. Traffic keluar ini keluar langsung dari jaringan tenant yang dikelola Google.

Antarmuka PSC Vertex AI dengan VPC-SC

  • Jika project Anda adalah bagian dari perimeter Kontrol Layanan VPC, akses internet default tenant yang dikelola Google akan diblokir oleh perimeter untuk mencegah pemindahan data yang tidak sah.
  • Untuk mengizinkan akses deployment ke internet publik dalam skenario ini, Anda harus mengonfigurasi jalur keluar yang aman secara eksplisit yang merutekan traffic melalui VPC Anda yang terhubung ke Vertex AI. Men-deploy Server Proxy di dalam jaringan VPC dengan alamat RFC 1918, yang dipasangkan dengan gateway Cloud NAT adalah salah satu cara untuk mencapainya. Perhatikan bahwa Anda juga dapat menggunakan Secure Web Proxy untuk meneruskan traffic ke Internet. Pembuatan Secure Web Proxy, yang secara otomatis membuat gateway Cloud NAT.

Untuk informasi tambahan, lihat referensi berikut:

Menyiapkan antarmuka Private Service Connect untuk resource Vertex AI | Google Cloud

Yang akan Anda build

Dalam tutorial ini, Anda akan membangun deployment Vertex AI Pipelines yang komprehensif dengan Antarmuka Private Service Connect (PSC) untuk memungkinkan konektivitas dari produsen ke komputasi konsumen seperti yang diilustrasikan pada Gambar 1 yang menargetkan endpoint non-RFC 1918 di class-e-subnet.

2d095dc2f4de6b4b.pngGambar 2

Anda akan membuat satu psc-network-attachment di VPC konsumen yang memanfaatkan peering DNS untuk menyelesaikan VM konsumen di project tenant yang menghosting Vertex AI Training sehingga menghasilkan kasus penggunaan berikut:

Deploy Vertex AI Pipelines dan konfigurasi Secure Web Proxy dalam mode proxy eksplisit, sehingga dapat melakukan wget terhadap VM di subnet Class E.

Yang akan Anda pelajari

  • Cara membuat lampiran jaringan
  • Cara produsen dapat menggunakan lampiran jaringan untuk membuat antarmuka PSC
  • Cara membuat Peering DNS untuk menyelesaikan domain pribadi yang dikonfigurasi di Jaringan VPC Konsumen dari Jaringan VPC Terkelola Google
  • Cara meneruskan traffic dari Antarmuka PSC Vertex AI ke Secure Web Proxy
  • Cara membuat komunikasi ke ruang Alamat IP non-RFC-1918 dari Vertex AI Pipelines

Yang Anda butuhkan

Project Google Cloud

Izin IAM

2. Sebelum memulai

Mengupdate project untuk mendukung tutorial

Tutorial ini menggunakan $variables untuk membantu penerapan konfigurasi gcloud di Cloud Shell.

Di dalam Cloud Shell, lakukan hal berikut:

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

Pengaktifan API

Di dalam Cloud Shell, lakukan hal berikut:

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. Penyiapan Konsumen

Buat VPC Konsumen

Di dalam Cloud Shell, lakukan hal berikut:

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

Buat subnet konsumen

Di dalam Cloud Shell, lakukan hal berikut:

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

Di dalam Cloud Shell, lakukan hal berikut:

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

Buat subnet khusus 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

Buat subnet Lampiran Jaringan Private Service Connect

Di dalam Cloud Shell, lakukan hal berikut:

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

Konfigurasi Cloud Router dan NAT

Secure Web Proxy Google Cloud secara otomatis menyediakan dan mengelola gateway Cloud NAT serta Cloud Router terkait di region tempat gateway tersebut di-deploy.

4. Mengaktifkan IAP

Untuk mengizinkan IAP (Identity Aware proxy) terhubung ke instance VM Anda, buat aturan firewall yang:

  • Berlaku untuk semua instance VM yang ingin Anda akses menggunakan IAP.
  • Mengizinkan traffic masuk dari rentang IP 35.235.240.0/20. Rentang ini berisi semua alamat IP yang digunakan IAP untuk penerusan TCP.

Di dalam Cloud Shell, buat aturan firewall IAP.

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

5. Membuat instance VM konsumen

Di dalam Cloud Shell, buat instance VM konsumen, 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. Secure Web Proxy

Mode Eksplisit Secure Web Proxy (atau Mode Perutean Proxy Eksplisit) adalah metode deployment yang mengharuskan beban kerja klien dikonfigurasi secara eksplisit untuk menggunakan alamat IP internal atau Nama Domain yang Sepenuhnya Memenuhi Syarat dan port SWP sebagai proxy penerusan.

Pada langkah-langkah di bawah, pastikan untuk mengubah YOUR-PROJECT-ID menjadi Project ID Anda

Buat proxy Web:

Di Cloud Shell, Buat file policy.yaml menggunakan editor teks:

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

Di Cloud Shell, buat kebijakan Secure Web Proxy:

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

Di bagian berikut, buat aturan untuk mengizinkan akses ke class-e-vm berdasarkan host sessionMatcher.

Di Cloud Shell, Buat file rule1.yaml menggunakan editor teks:

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

Di bagian berikut, buat aturan untuk mengizinkan akses notebook Jupyter agar penginstalan apache2 di VM "class-e" dapat dilakukan.

Di Cloud Shell, Buat file rule2.yaml menggunakan editor teks:

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

Di Cloud Shell, buat aturan kebijakan keamanan1:

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

Di Cloud Shell, buat aturan kebijakan keamanan2:

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

Untuk mendukung Vertex AI Training, konfigurasi gateway Secure Web Proxy dengan setelan berikut:

  • Port Pendengar: Gunakan port yang sama yang dikonfigurasi di setelan proxy eksplisit kode aplikasi Vertex AI (misalnya, 8080).
  • Alamat: Tetapkan alamat IP pribadi dari rentang RFC 1918.
  • Mode Perutean: Tetapkan ini ke EXPLICIT_ROUTING_MODE

Di Cloud Shell, buat file gateway.yaml untuk menentukan gateway 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

Di Cloud Shell, buat instance Secure Web Proxy:

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

Secure Web Proxy dapat memerlukan waktu beberapa menit untuk di-deploy.

e8a4cf23bfc63030.png

7. Lampiran jaringan Private Service Connect

Lampiran jaringan adalah resource regional yang mewakili sisi konsumen antarmuka Private Service Connect. Anda mengaitkan satu subnet dengan lampiran jaringan, dan produsen akan menetapkan IP ke antarmuka Private Service Connect dari subnet tersebut. Subnet harus berada di region yang sama dengan lampiran jaringan. Lampiran jaringan harus berada di region yang sama dengan layanan produsen.

Buat lampiran jaringan

Di dalam Cloud Shell, buat lampiran jaringan.

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

Catatan: Anda tidak perlu menyebutkan ID project yang diterima secara eksplisit dalam lampiran ini. Jika project tenant yang Dikelola Google dikonfigurasi, project tersebut akan otomatis ditambahkan seolah-olah dikonfigurasi "Terima Otomatis"

Mencantumkan lampiran jaringan

Di dalam Cloud Shell, cantumkan lampiran jaringan.

gcloud compute network-attachments list

Mendeskripsikan lampiran jaringan

Di dalam Cloud Shell, deskripsikan lampiran jaringan.

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

Catat nama lampiran jaringan PSC, psc-network-attachment, yang akan digunakan oleh produsen saat membuat Antarmuka Private Service Connect.

Untuk melihat URL Lampiran Jaringan PSC di Konsol Cloud, buka:

Network Services → Private Service Connect → Network Attachment → psc-network-attachment

b969cca5242d9c8a.png

8. Zona DNS Pribadi

Anda akan membuat Zona Cloud DNS untuk demo.com dan mengisinya dengan data A yang mengarah ke alamat IP VM Anda. Selanjutnya, peering DNS akan di-deploy di tugas Vertex AI Pipelines, yang akan memungkinkannya mengakses data DNS konsumen.

Di dalam Cloud Shell, lakukan hal berikut:

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"

Di dalam Cloud Shell, buat set data untuk VM, class-e-vm, pastikan untuk memperbarui Alamat IP berdasarkan output lingkungan Anda.

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"

Di dalam Cloud Shell, buat set data untuk Secure Web Proxy, pastikan untuk memperbarui Alamat IP berdasarkan output lingkungan Anda.

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

Membuat aturan Cloud Firewall untuk mengizinkan akses dari Antarmuka PSC

Di bagian berikut, buat aturan firewall yang mengizinkan traffic yang berasal dari akses Lampiran Jaringan PSC ke resource komputasi RFC 1918 di VPC konsumen.

Di Cloud Shell, buat aturan firewall ingress yang mengizinkan akses dari subnet khusus proxy ke subnet class-e. Karena SWP memulai koneksi dengan subnet khusus proxy sebagai alamat sumber.

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. Membuat Notebook Jupyter

Bagian berikut akan memandu Anda membuat Notebook Jupyter. Notebook ini akan digunakan untuk men-deploy Tugas Vertex AI Pipelines yang mengirim wget dari Vertex AI Pipelines ke instance pengujian. Jalur data antara Vertex AI Pipelines dan jaringan konsumen yang berisi instance menggunakan antarmuka Private Service Connect.

Membuat akun layanan yang dikelola pengguna

Di bagian berikut, Anda akan membuat akun layanan yang akan dikaitkan dengan instance Vertex AI Workbench yang digunakan dalam tutorial.

Dalam tutorial ini, akun layanan akan memiliki peran berikut yang diterapkan:

Login ke Cloud Shell dan lakukan hal berikut;

Buat akun layanan.

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

Perbarui akun layanan dengan peran Storage Admin.

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

Perbarui akun layanan dengan peran AI Platform User.

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

Perbarui akun layanan dengan peran Artifact Registry Admin.

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

Perbarui akun layanan dengan peran Cloud Build Editor.

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

Izinkan akun layanan notebook menggunakan akun layanan default 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. Membuat Instance Vertex AI Workbench

Di bagian berikut, buat instance Vertex AI Workbench yang menggabungkan akun layanan yang dibuat sebelumnya, notebook-sa.

Di dalam Cloud Shell, buat instance klien pribadi.

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. Pembaruan Agen Layanan Vertex AI

Vertex AI bertindak atas nama Anda untuk melakukan operasi seperti mendapatkan alamat IP dari subnet PSC Network Attachment yang digunakan untuk membuat Antarmuka PSC. Untuk melakukannya, Vertex AI menggunakan agen layanan (tercantum di bawah) yang memerlukan izin Network Admin.

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

Catatan: Sebelum memperbarui izin agen layanan, buka Vertex AI di Konsol Cloud untuk memastikan Vertex AI API diaktifkan.

Di dalam Cloud Shell:

Dapatkan nomor project Anda.

gcloud projects describe $projectid | grep projectNumber

Tetapkan nomor project Anda.

projectnumber=YOUR-PROJECT-NUMBER

Buat akun layanan untuk AI Platform. Lewati langkah ini jika Anda sudah memiliki akun layanan di project Anda.

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

Perbarui akun agen layanan dengan peran compute.networkAdmin.

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

Perbarui akun agen layanan dengan peran dns.peer

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

Pembaruan Akun Layanan Default

Aktifkan Compute Engine API dan beri akun layanan default Anda akses ke Vertex AI. Perhatikan bahwa mungkin perlu beberapa saat agar perubahan akses diterapkan.

Gunakan Cloud Shell untuk memperbarui akun layanan default sebagai berikut:

Perbarui akun layanan default dengan peran aiplatform.user

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

Perbarui akun layanan default dengan peran storage.admin

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

Perbarui akun layanan default dengan peran artifactregistry.admin

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

12. Instal Apache2 dan Aktifkan Tcpdump di 'class-e-vm':

Dari class-e-vm, instal apache2 melalui Secure Web Proxy:

Buka tab Cloud Shell baru, perbarui variabel project Anda, dan lakukan SSH ke class-e-vm

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

Lakukan pemfilteran tcpdump di subnet khusus proxy, yang digunakan oleh Secure Web Proxy untuk meneruskan traffic ke target.

Dari OS class-e-vm, jalankan pemfilteran tcpdump di subnet proxy-vm.

sudo tcpdump -i any net 10.10.100.0/24 -nn

Catatan: Pastikan Anda mengaktifkan Akses Google Pribadi di subnet instance workbench-tutorial agar Sesi JupyterLab dapat dibuka.

13. Men-deploy Tugas Vertex AI Pipelines

Di bagian berikut, Anda akan membuat notebook untuk melakukan wget yang berhasil dari Vertex AI Pipelines ke proxy eksplisit. Hal ini memungkinkan Anda menjangkau VM non-RFC 1918, seperti class-e-vm. Proxy eksplisit tidak diperlukan agar Vertex AI Pipelines dapat mengakses rfc1918-vm, karena targetnya adalah alamat IP RFC 1918.

Jalankan tugas pelatihan di instance Vertex AI Workbench.

  1. Di konsol Google Cloud, buka tab instance di halaman Vertex AI Workbench.
  2. Di samping nama instance Vertex AI Workbench Anda (workbench-tutorial), klik Open JupyterLab. Instance Vertex AI Workbench Anda akan terbuka di JupyterLab.
  3. Pilih File > New > Notebook
  4. Pilih Kernel > Python 3

Di notebook JupyterLab Anda, buat sel baru, perbarui, lalu jalankan yang berikut. Pastikan untuk memperbarui PROJECT_ID dengan detail lingkungan Anda.

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)

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

# 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

Di notebook JupyterLab, buat sel baru dan jalankan konfigurasi di bawah, perhatikan poin-poin berikut:

  • proxy_server = "http://explicit-swp.demo.com:8080"
  • FQDN dikaitkan dengan VM proxy yang di-deploy di VPC konsumen. Kita menggunakan peering DNS untuk me-resolve FQDN pada langkah selanjutnya.
%%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)

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

%%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"]

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut. Abaikan error (gcloud.builds.submit) jika ada.

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

Di notebook JupyterLab Anda, buat dan jalankan sel di bawah, perhatikan poin-poin penting berikut:

  • Peering DNS ke VPC konsumen dikonfigurasi menggunakan dnsPeeringConfigs (dnsPeeringConfigs) untuk demo nama domain demo.com.
  • Di sini, proxy web mode perutean eksplisit adalah explicit-swp.demo.com. Resolusi ditangani melalui peering DNS dalam VPC konsumen.
  • Port 8080 adalah port pendengar (default) yang dikonfigurasi di Secure Web Proxy
  • wget ke class-e-vm-demo.com diselesaikan melalui peering DNS
  • Kode ini menentukan "psc-network-attachment" untuk Vertex, sehingga Vertex dapat menggunakan subnet lampiran jaringan untuk men-deploy dua instance Antarmuka 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))

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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)

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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)

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

# 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__))"

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

# 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"}

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

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

Di notebook JupyterLab, buat sel baru dan jalankan kode berikut.

# 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. Validasi Antarmuka PSC

Anda juga dapat melihat IP Lampiran Jaringan yang digunakan oleh Vertex AI Pipelines dengan membuka:

Network Services → Private Service Connect → Network Attachment → psc-network-attachment

Pilih project tenant (nama project yang diakhiri dengan -tp)

a2e0b6d6243f26f1.png

Kolom yang ditandai menunjukkan alamat IP yang digunakan oleh Vertex AI Pipelines dari Lampiran Jaringan PSC.

11e411ea919d3bad.png

15. Validasi Cloud Logging

Tugas Vertex AI Pipelines akan memerlukan waktu sekitar 14 menit untuk dijalankan pertama kali, dan selanjutnya akan berjalan lebih singkat. Untuk memvalidasi keberhasilan hasil, lakukan hal berikut:

Buka Vertex AI → Training → Custom jobs

Pilih tugas kustom yang dijalankan

2f467254aa0c2e3a.png

Pilih Lihat Log

8d525d3b152bcc61.png

Setelah Cloud Logging tersedia, pilih Run Query yang menghasilkan pilihan yang ditandai di bawah yang mengonfirmasi keberhasilan wget dari Vertex AI Pipelines ke class-e-vm.

a4f9e9167f4ce1ae.png

38972f834aa2bd1d.png

16. Validasi TCPDump

Mari kita tinjau output TCPDUMP yang selanjutnya memvalidasi konektivitas ke instance komputasi:

Dari class-e-vm, amati HTTP GET dan 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. Pembersihan

Dari Cloud Shell, hapus komponen tutorial.

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

Selamat, Anda telah berhasil mengonfigurasi dan memvalidasi koneksi antara Antarmuka Private Service Connect Vertex AI Pipelines ke rentang IP non-RFC melalui Secure Web Proxy.

Anda telah membuat infrastruktur konsumen, dan menambahkan lampiran jaringan yang memungkinkan produsen membuat VM multi-NIC untuk menjembatani komunikasi konsumen dan produsen. Anda telah mempelajari cara membuat peering DNS saat men-deploy proxy eksplisit di jaringan VPC konsumen yang memungkinkan konektivitas ke instance class-e-vm yang tidak dapat dirutekan secara langsung dari Vertex.

678ba30d64a76795.png

Apa selanjutnya?

Bacaan lebih lanjut & Video

Dokumen referensi