Proxy Eksplisit Antarmuka PSC Vertex AI Pipelines

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.

Pertimbangan aksesibilitas PSC-Interface Vertex AI

  • PSC-Interface dapat merutekan traffic ke tujuan berbasis 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 merepresentasikan proxy eksplisit yang dikonfigurasi di VPC pelanggan untuk memfasilitasi perutean ke CIDR non-RFC-1918 berikut:

[1] 240.0.0.0/4

[2] 203.0.113.0/2

[3]10.10.20.0/28 tidak memerlukan proxy, termasuk dalam rentang rfc1918.

  • 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 aman dan dikelola Google.

476f87a96f153b95.png

Pertimbangan VPC-SC antarmuka PSC Vertex AI

  • 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. Cara yang direkomendasikan untuk melakukannya adalah dengan menyiapkan server proxy di dalam perimeter VPC Anda dengan alamat RFC1918 dan membuat gateway Cloud NAT untuk mengizinkan VM proxy mengakses internet.

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

Gambar 2

782ba8f1f3c3f522.png

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:

  1. Deploy Vertex AI Pipelines dan konfigurasi VM proxy agar bertindak sebagai 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 komunikasi dari produsen ke konsumen menggunakan Peering DNS
  • Cara membuat komunikasi ke ruang Alamat IP non-rfc1918 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-NAME]
projectid=YOUR-PROJECT-NAME
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"

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

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

Konfigurasi Cloud Router dan NAT

Dalam tutorial ini, Cloud NAT digunakan untuk menyediakan akses internet bagi VM proxy, yang tidak memiliki alamat IP publik. Cloud NAT memungkinkan VM yang hanya memiliki alamat IP pribadi terhubung ke internet, sehingga dapat melakukan tugas seperti menginstal paket software.

Di dalam Cloud Shell, buat router cloud.

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

Di dalam Cloud Shell, buat gateway 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. Aktifkan IAP

Untuk mengizinkan IAP 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 \
    --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"

Dalam Cloud Shell, buat instance VM konsumen, proxy-vm, yang akan berfungsi sebagai proxy eksplisit untuk Vertex AI Pipelines. Kita akan menggunakan tinyproxy sebagai aplikasi untuk memproksi traffic HTTP, meskipun HTTPS juga didukung.

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

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 psc-network-attachment, 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

e191e54a103d2222.png

7. 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, lakukan deskripsi terhadap instance VM untuk mendapatkan Alamat IP masing-masing.

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:

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 VM, proxy-vm, pastikan untuk memperbarui Alamat IP berdasarkan output lingkungan Anda.

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

Membuat aturan Cloud Firewall untuk mengizinkan akses dari Antarmuka PSC

Di bagian berikut, buat aturan firewall yang mengizinkan traffic yang berasal dari Lampiran Jaringan PSC mengakses resource komputasi RFC1918 di VPC konsumen.

Di Cloud Shell, buat aturan firewall ingress yang mengizinkan akses dari subnet PSC Network Attachment ke proxy-vm.

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

Di Cloud Shell, buat aturan firewall ingress yang mengizinkan akses dari subnet proxy-vm ke subnet 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. Memperbarui proxy eksplisit

Di bagian berikut, Anda harus melakukan SSH ke proxy eksplisit dan memperbarui file konfigurasi tinyproxy.conf, lalu melakukan reset.

Dari Cloud Shell

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

Buka file konfigurasi tinyproxy, perbarui menggunakan editor pilihan Anda. Berikut adalah contoh menggunakan 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. 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. Datapath antara Vertex AI Pipelines dan jaringan konsumen yang berisi instance menggunakan Antarmuka Jaringan Private Service Connect.

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

Di dalam Cloud Shell, buat akun layanan.

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

Di dalam Cloud Shell, 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"

Di dalam Cloud Shell, perbarui akun layanan dengan peran Vertex AI User.

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

Di dalam Cloud Shell, 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"

Di dalam Cloud Shell, 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"

Di dalam Cloud Shell, 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 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. 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 (yang tercantum di bawah) yang memerlukan izin Admin Jaringan.

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

Di dalam Cloud Shell, dapatkan nomor project Anda.

gcloud projects describe $projectid | grep projectNumber

Di dalam Cloud Shell, dapatkan nomor project Anda.

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

Di dalam Cloud Shell, tetapkan nomor project Anda.

projectnumber=YOUR-PROJECT-Number

Di dalam Cloud Shell, 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

Di dalam Cloud Shell, 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"

Di dalam Cloud Shell, 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.

Di dalam Cloud Shell, 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"

Di dalam Cloud Shell, 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"

Di dalam Cloud Shell, perbarui akun layanan default dengan peran storage.admin

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

12. Aktifkan Tcpdump

Untuk memvalidasi konektivitas IP dari Vertex AI Pipelines, kita dapat menggunakan TCPDUMP. Hal ini akan memungkinkan kita mengamati komunikasi yang berasal dari subnet PSC Network Attachment, 192.168.10.0/28 saat memanggil permintaan get dari Vertex AI Pipelines ke VM, class-e-vm.demo.com (240.0.0.0/4).

Dari Cloud Shell, lakukan SSH ke VM proxy.

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

Dari OS proxy-vm, jalankan pemfilteran tcpdump pada class-e-vm dan subnet lampiran jaringan PSC.

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

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

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

sudo tcpdump -i any net 10.10.10.0/28 -nn

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 (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, buat sel baru dan jalankan kode berikut.

# 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

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 Anda, buat sel baru dan jalankan konfigurasi di bawah, perhatikan poin-poin berikut:

  • proxy_server = "http://proxy-vm.demo.com:8888" 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 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)

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.
  • Proxy eksplisit, yang ditentukan sebagai variabel PROXY_VM_IP, adalah proxy-vm.demo.com. Resolusi ditangani melalui peering DNS dalam VPC konsumen.
  • Port 8888 adalah port pendengar (default) yang dikonfigurasi di tinyproxy
  • 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 = "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))

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 berakhiran -tp)

f47150235fedb8ce.png

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

39e7b251aeb4f191.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, lakukan hal berikut:

Buka Vertex AI → Training → Custom jobs

Pilih tugas kustom yang dijalankan

a9be0395c842aa6f.png

Pilih Lihat Log

53e30765ba5827f3.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.

f2c5d9fdf5cc8bed.png

3b3788603bb433ee.png

16. Validasi TCPDump

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

Dari proxy-vm, amati HTTP GET dan 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

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

Dari Cloud Shell, hapus komponen tutorial.

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

Selamat, Anda telah berhasil mengonfigurasi dan memvalidasi Antarmuka Private Service Connect dengan Vertex AI Pipelines.

Anda 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 langsung dari Vertex.

Cosmopup menganggap tutorial itu luar biasa!!

c911c127bffdee57.jpeg

Apa selanjutnya?

Bacaan lebih lanjut & Video

Dokumen referensi