Antarmuka Private Service Connect Vertex AI Pipelines

1. Pengantar

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

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.

Yang akan Anda build

Vertex AI Pipelines, yang di-deploy di project tenant yang dikelola Google, akan memanfaatkan Lampiran Jaringan PSC untuk membuat instance multi-nic antara jaringan produsen dan konsumen. Karena Lampiran Jaringan PSC di-deploy dengan multi-nic dari jaringan konsumen, Vertex AI Pipelines dapat menjangkau rute yang tersedia dari jaringan konsumen.

Dalam tutorial ini, Anda akan membuat arsitektur Antarmuka Private Service Connect (PSC) yang komprehensif untuk Vertex AI Pipelines yang menggunakan aturan Cloud Firewall untuk mengizinkan, atau menolak, konektivitas dari produsen ke instance pengujian konsumen seperti yang diilustrasikan dalam Gambar 1.

Gambar 1

12714b6f0f8fa411.png

Anda akan membuat satu psc-network-attachment di VPC konsumen yang menghasilkan kasus penggunaan berikut:

  1. Buat aturan Firewall Masuk di consumer-vpc yang mengizinkan subnet Vertex AI Pipeline (192.168.10.0/28) ke test-svc-1. Mengonfirmasi PING yang berhasil dihasilkan dari Tugas Pipeline ke test-svc-1 menggunakan TCPDUMP
  2. Buat aturan Firewall Masuk di consumer-vpc yang menolak subnet Vertex AI Pipeline (192.168.10.0/28) ke test-svc-2. Konfirmasi kegagalan PING berdasarkan log Firewall yang dihasilkan oleh Log Explorer.

Yang akan Anda pelajari

  • Cara membuat lampiran jaringan
  • Cara Vertex AI Pipelines dapat menggunakan lampiran jaringan untuk membuat Antarmuka PSC
  • Cara membangun komunikasi dari produsen ke konsumen
  • Cara mengizinkan akses dari Vertex AI Pipelines ke VM konsumen, test-svc-1
  • Cara menolak akses dari Vertex AI Pipelines ke VM konsumen, test-svc-2 menggunakan Cloud Firewall

Yang Anda butuhkan

2. Sebelum memulai

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

Memperbarui project untuk mendukung tutorial

Di dalam Cloud Shell, lakukan hal berikut:

gcloud services enable notebooks.googleapis.com
gcloud services enable aiplatform.googleapis.com
gcloud services enable compute.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

3. Penyiapan Konsumen

Membuat VPC konsumen

Di dalam Cloud Shell, lakukan hal berikut:

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

Membuat subnet konsumen

Di dalam Cloud Shell, lakukan hal berikut:

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

Di dalam Cloud Shell, lakukan hal berikut:

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

Di dalam Cloud Shell, lakukan hal berikut:

gcloud compute networks subnets create workbench-subnet --project=$projectid --range=192.168.40.0/28 --network=consumer-vpc --region=us-central1 --enable-private-ip-google-access

Konfigurasi Cloud Router dan NAT

Penafsiran Alamat Jaringan (NAT) Cloud digunakan dalam tutorial untuk download paket software notebook karena instance notebook tidak memiliki alamat IP eksternal. Cloud NAT menawarkan kemampuan NAT keluar, yang berarti bahwa host internet tidak diizinkan untuk memulai komunikasi dengan notebook yang dikelola pengguna, sehingga lebih aman.

Di dalam Cloud Shell, buat cloud router regional.

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

Di dalam Cloud Shell, buat gateway cloud NAT regional.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1 --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1

Membuat subnet Lampiran Jaringan Private Service Connect

Di dalam Cloud Shell, buat subnet Lampiran Jaringan yang digunakan oleh Vertex AI Pipelines.

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

4. Mengaktifkan Identity Aware Proxy (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 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, test-svc-1.

gcloud compute instances create test-svc-1 \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=test-subnet-1 \
    --shielded-secure-boot

Di dalam Cloud Shell, buat instance VM konsumen, test-svc-2.

gcloud compute instances create test-svc-2 \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=test-subnet-2 \
    --shielded-secure-boot

Dapatkan dan simpan Alamat IP instance:

Di dalam Cloud Shell, lakukan deskripsi terhadap instance VM pengujian.

gcloud compute instances describe test-svc-1 --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe test-svc-2 --zone=us-central1-a | grep  networkIP:

Contoh:

user@cloudshell(psc-vertex)$ gcloud compute instances describe test-svc-1 --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe test-svc-2 --zone=us-central1-a | grep  networkIP:
  networkIP: 192.168.20.2
  networkIP: 192.168.30.2

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 (Vertex AI Pipelines) menetapkan IP ke antarmuka Private Service Connect.

Membuat 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

Mencantumkan lampiran jaringan

Di dalam Cloud Shell, cantumkan lampiran jaringan.

gcloud compute network-attachments list

Menjelaskan lampiran jaringan

Di dalam Cloud Shell, deskripsikan lampiran jaringan.

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

Catat URI psc-network-attachment yang akan digunakan oleh produsen saat membuat Antarmuka Private Service Connect.

Pada contoh di bawah, URI lampiran jaringan psc adalah sebagai berikut:

projects/psc-vertex/regions/us-central1/networkAttachments/psc-network-attachment

user@cloudshell$ gcloud compute network-attachments describe psc-network-attachment --region=us-central1
connectionPreference: ACCEPT_MANUAL
creationTimestamp: '2025-01-21T12:25:25.385-08:00'
fingerprint: m9bHc9qnosY=
id: '56224423547354202'
kind: compute#networkAttachment
name: psc-network-attachment
network: https://www.googleapis.com/compute/v1/projects/psc-vertex/global/networks/consumer-vpc
region: https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1
selfLink: https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1/networkAttachments/psc-network-attachment
subnetworks:
- https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1/subnetworks/intf-subnet

7. Penyiapan Vertex AI Workbench

Bagian berikut akan memandu Anda membuat Notebook Jupyter. Notebook ini akan digunakan untuk men-deploy Tugas Pipelines yang mengirim PING dari Vertex AI Pipelines ke instance pengujian. Jalur Data antara Vertex AI Pipelines dan jaringan konsumen yang berisi instance menggunakan Antarmuka Jaringan 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:

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, izinkan akun layanan notebook menggunakan akun layanan default Compute Engine untuk membuat instance Tugas Pipeline.

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"

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=deeplearning-platform-release --vm-image-family=common-cpu-notebooks --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=workbench-subnet --disable-public-ip --shielded-secure-boot=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

8. Vertex AI Pipelines untuk menguji konektivitas svc-1

Buka tab Cloud Shell baru dan perbarui setelan project Anda.

Di dalam Cloud Shell, lakukan hal berikut:

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

Untuk mengizinkan konektivitas dari Vertex AI Pipelines ke test-svc-1, buat aturan firewall masuk yang menentukan Lampiran Jaringan PSC sebagai sumber (192.168.10.0/28) dan Alamat IP test-svc-1 sebagai tujuan.

Di dalam Cloud Shell, perbarui rentang-tujuan agar cocok dengan alamat IP test-svc-1 Anda.

gcloud compute --project=$projectid firewall-rules create allow-icmp-vertex-pipelines-to-test-svc1-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=ALLOW  --source-ranges=192.168.10.0/28 --destination-ranges=<your-test-svc-1-vm-ip> --rules=icmp

Contoh:

gcloud compute --project=$projectid firewall-rules create allow-icmp-vertex-pipelines-to-test-svc1-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=ALLOW  --source-ranges=192.168.10.0/28 --destination-ranges=192.168.20.2 --rules=icmp

Login ke instance test-svc-1 menggunakan IAP di Cloud Shell.

gcloud compute ssh test-svc-1 --project=$projectid --zone=us-central1-a --tunnel-through-iap

Di OS, jalankan tcpdump untuk menangkap traffic icmp. Sesi OS ini akan digunakan untuk memvalidasi komunikasi antara Vertex AI Pipeline dan VM.

sudo tcpdump -i any icmp -nn

9. Update Agen Layanan Vertex AI

Vertex AI Pipelines bertindak atas nama Anda untuk melakukan operasi seperti mendapatkan Alamat IP dari subnet Lampiran Jaringan PSC yang digunakan untuk membuat Antarmuka PSC. Untuk melakukannya, Vertex AI Pipelines menggunakan agen layanan (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

Contoh:

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

Di dalam Cloud Shell, perbarui akun agen layanan dengan peran compute.networkAdmin.

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

Contoh:

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

10. 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:<your-projectnumber>-compute@developer.gserviceaccount.com" \
    --role="roles/aiplatform.user"

Contoh:

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

11. Men-deploy Tugas Vertex AI Pipelines

Di bagian berikut, Anda akan membuat notebook untuk melakukan PING yang berhasil ke instance test-svc-1 konsumen.

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 akan terbuka di JupyterLab.
  3. Pilih File > New > Notebook
  4. Pilih Kernel > Python 3
  5. Di sel notebook baru, jalankan perintah berikut untuk memastikan Anda memiliki pip versi terbaru:
! pip3 install --upgrade --quiet google-cloud-aiplatform \
  kfp \
  google-cloud-pipeline-components
  1. Menetapkan variabel project di sel notebook baru
PROJECT_ID = "<your-projectid>" 
REGION = "<your-region>"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

Contoh:

PROJECT_ID = "psc-vertex" 
REGION = "us-central1"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"
  1. Menentukan nama bucket yang unik secara global sebagai variabel di sel notebook baru
BUCKET_URI = f"gs://<your-bucket-name>"

Contoh:

BUCKET_URI = f"gs://psc-vertex-bucket"
  1. Di sel notebook baru, buat bucket
! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

Di bagian berikut, Anda akan menentukan akun layanan compute engine default yang akan digunakan untuk menjalankan tugas pipeline, serta memberikan izin yang tepat untuk akun tersebut.

shell_output = ! gcloud projects describe $PROJECT_ID
PROJECT_NUMBER = shell_output[-1].split(":")[1].strip().replace("'", "")
SERVICE_ACCOUNT = f"{PROJECT_NUMBER}-compute@developer.gserviceaccount.com"

print(f"Project Number: {PROJECT_NUMBER}")
print(f"Service Account: {SERVICE_ACCOUNT}")

Untuk mengonfirmasi bahwa eksekusi berhasil, Akun Layanan dan Nomor Project Anda akan dicetak

  1. Di sel notebook baru, berikan izin akun layanan Anda untuk membaca dan menulis artefak pipeline di bucket yang dibuat pada langkah sebelumnya.
! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectCreator {BUCKET_URI}

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectViewer {BUCKET_URI}
  1. Di sel notebook baru, tentukan parameter pipeline. Perhatikan bahwa NETWORK_ATTACHMENT_NAME adalah Lampiran Jaringan PSC, sehingga harus cocok.
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/psc_test"
NETWORK_ATTACHMENT_URI = f"projects/{PROJECT_NUMBER}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}"
  1. Di sel notebook baru, lakukan inisialisasi Vertex AI SDK
from kfp import dsl
from google.cloud import aiplatform, aiplatform_v1beta1
import time
from google.cloud.aiplatform_v1.types import pipeline_state
import yaml
from datetime import datetime
import logging
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
  1. Di sel notebook baru, tentukan komponen pengujian
@dsl.container_component
def ping_check(network_address: str):
    """Pings a network address

    Args:
        network_address: The IP address to ping
    """

    return dsl.ContainerSpec(
        image="ubuntu:22.04",
        command=["sh", "-c"],
        args=[
            f"""
            
            # Use sed for regex replacement, cleaner than bash parameter expansion for this
            cleaned_address=$(echo "{network_address}" | sed 's/[^0-9.]//g')
            apt-get update && apt-get install inetutils-traceroute inetutils-ping -y
            
            echo "Will ping $cleaned_address"
            if ! ping -c 3 $cleaned_address; then
                echo "Ping failed"
                traceroute -w 1 -m 7 $cleaned_address
                exit 1
            fi
            """
        ],
    )
  1. Di sel notebook baru, tentukan pipeline
@dsl.pipeline(name="check-connectivity")
def pipeline(ip_address: str):
    """Pings an IP address. Facilitated by a Private Service Connect Interface

    Args:
        ip_address: The IP address to ping
    """
    ping_check(network_address=ip_address).set_caching_options(False)
    return
  1. Di sel notebook baru, jalankan fungsi utilitas, tunggu hingga pipeline selesai
def wait_for_pipeline(
    project_id: str,
    region: str,
    pipeline_job_resource_name: str,
    timeout: int = 20 * 60,  # Default timeout of 20 minutes (in seconds)
) -> bool:
    """
    Waits for a Vertex AI pipeline to finish, with a timeout.

    Args:
        project_id (str): The Google Cloud project ID.
        region (str): The region where the pipeline is running.
        pipeline_job_resource_name (str): The resource name of the pipeline job.
        timeout (int): The maximum time to wait for the pipeline to finish, in seconds.
                       Defaults to 20 minutes (1200 seconds).

    Returns:
        bool: True if the pipeline succeeded, False otherwise.

    Raises:
        TimeoutError: If the pipeline does not finish within the specified timeout.
    """

    # Initialize the AIPlatform client
    aiplatform.init(project=project_id, location=region)

    # Get the pipeline job
    pipeline_job = aiplatform.PipelineJob.get(resource_name=pipeline_job_resource_name)
    logging.info(
        f"Vertex AI Console Link: https://console.cloud.google.com/vertex-ai/pipelines/locations/{region}/runs/{pipeline_job.resource_name.split('/')[-1]}?project={project_id}"
    )

    start_time = time.time()
    while True:
        status = pipeline_job.state
        logging.info(f"Pipeline Job status: {status.name}")

        if status in [
            pipeline_state.PipelineState.PIPELINE_STATE_SUCCEEDED,
            pipeline_state.PipelineState.PIPELINE_STATE_FAILED,
            pipeline_state.PipelineState.PIPELINE_STATE_CANCELLED,
        ]:
            break  # Exit the loop if the job is finished

        if time.time() - start_time > timeout:
            logging.error(f"Pipeline timed out after {timeout} seconds.")
            raise TimeoutError(f"Pipeline timed out after {timeout} seconds.")
        
        # Wait for a short time before checking again
        time.sleep(10)  # Adjust the wait time as needed

    # Do something based on the final status
    if status == pipeline_state.PipelineState.PIPELINE_STATE_SUCCEEDED:
        logging.info("Pipeline succeeded")
        return True
    elif status == pipeline_state.PipelineState.PIPELINE_STATE_CANCELLED:
        logging.error("Pipeline cancelled")
        raise Exception("Pipeline cancelled")
    elif status == pipeline_state.PipelineState.PIPELINE_STATE_FAILED:
        logging.error("Pipeline failed")
        raise Exception("Pipeline failed")
  1. Di sel notebook baru, jalankan fungsi utilitas untuk menjalankan pipeline
def run_job_with_psc_interface_config(
    project_id: str,
    region: str,
    pipeline_root: str,
    network_attachment_name: str,
    ip_address: str,
    local_pipeline_file: str = "pipeline.yaml",
):
    """
    Compiles, submits, and monitors a Vertex AI pipeline.
    """

    parameter_values = {"ip_address": ip_address}
    pipeline_root = f"{pipeline_root}/{datetime.now().strftime('%Y%m%d%H%M%S')}"
    logging.info("Compiling pipeline")

    try:
        with open(local_pipeline_file, "r") as stream:
            pipeline_spec = yaml.safe_load(stream)
            logging.info(f"Pipeline Spec: {pipeline_spec}")
    except yaml.YAMLError as exc:
        logging.error(f"Error loading pipeline yaml file: {exc}")
        raise
    
    logging.info(f"Will use pipeline root: {pipeline_root}")
    # Initialize the Vertex SDK using PROJECT_ID and LOCATION
    aiplatform.init(project=project_id, location=region)

    # Create the API endpoint
    client_options = {"api_endpoint": f"{region}-aiplatform.googleapis.com"}

    # Initialize the PipelineServiceClient
    client = aiplatform_v1beta1.PipelineServiceClient(client_options=client_options)

    # Construct the request
    request = aiplatform_v1beta1.CreatePipelineJobRequest(
        parent=f"projects/{project_id}/locations/{region}",
        pipeline_job=aiplatform_v1beta1.PipelineJob(
            display_name="pipeline-with-psc-interface-config",
            pipeline_spec=pipeline_spec,
            runtime_config=aiplatform_v1beta1.PipelineJob.RuntimeConfig(
                gcs_output_directory=pipeline_root, parameter_values=parameter_values
            ),
            psc_interface_config=aiplatform_v1beta1.PscInterfaceConfig(
                network_attachment=network_attachment_name
            ),
        ),
    )

    # Make the API call
    response = client.create_pipeline_job(request=request)

    # Print the response
    logging.info(f"Pipeline job created: {response.name}")

    return response.name
  1. Di sel notebook baru, kompilasi pipeline
from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')
  1. Di sel notebook baru, perbarui TARGET_IP_ADDRESS untuk mencerminkan Alamat IP yang diperoleh pada langkah sebelumnya untuk test-svc-1 dan amati status tugas pipeline
TARGET_IP_ADDRESS = "<your-test-svc-1-ip>"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Contoh:

TARGET_IP_ADDRESS = "192.168.20.2"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Setelah langkah 17 dieksekusi, pipeline akan memerlukan waktu ~8 menit untuk diselesaikan.

12. Memvalidasi konektivitas ke test-svc-1

Di sel yang digunakan untuk menjalankan langkah 17, amati transisi Status Tugas Pipeline dari PIPELINE_STATE_PENDING ke PIPELINE_STATE_RUNNING dan akhirnya PIPELINE_STATE_SUCCEEDED yang menunjukkan ping yang berhasil dari Vertex AI Pipelines dan respons dari test-svc-1.

Untuk memvalidasi traffic ICMP antara Vertex AI Pipeline dan test-svc-1, lihat sesi tcpdump yang dibuat sebelumnya dan dijalankan di OS test-svc-1 yang menyediakan log yang menunjukkan traffic dua arah.

Dalam contoh tcpdump, Vertex AI Pipelines mengambil Alamat IP 192.168.10.3 dari subnet 192.168.10.0/28, 192.168.20.2 adalah Alamat IP test-svc-1. Perhatikan bahwa di lingkungan Anda, Alamat IP mungkin berbeda.

user@test-svc-1:~$ sudo tcpdump -i any icmp -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
18:57:54.737490 ens4  In  IP 192.168.10.3 > 192.168.20.2: ICMP echo request, id 257, seq 0, length 64
18:57:54.737523 ens4  Out IP 192.168.20.2 > 192.168.10.3: ICMP echo reply, id 257, seq 0, length 64

13. Konektivitas AI Vertex AI Pipelines ke test-svc-2

Di bagian berikut, Anda akan membuat aturan firewall masuk untuk menolak traffic dari subnet Vertex AI Pipelines (192.168.10.0/28) ke test-svc-2, diikuti dengan memperbarui Notebook untuk mencerminkan Alamat IP test-svc-2, lalu akhirnya menjalankan Pipelines Jobs.

Di sel Notebook, Status Tugas Pipeline akan menunjukkan Error - Pipeline Gagal, selain itu logging Firewall akan memberikan insight tentang koneksi yang gagal.

Membuat aturan firewall masuk tolak

Untuk menolak konektivitas dari Vertex AI Pipelines ke test-svc-2, buat aturan firewall masuk yang menentukan Lampiran Jaringan PSC sebagai sumber (192.168.10.0/28) dan Alamat IP test-svc-2 sebagai tujuan.

Di dalam Cloud Shell, perbarui rentang-tujuan agar cocok dengan alamat IP test-svc-2 Anda.

gcloud compute --project=$projectid firewall-rules create deny-icmp-vertex-pipelines-to-test-svc2-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=DENY  --source-ranges=192.168.10.0/28 --rules=ALL --destination-ranges=<your-test-svc-2-vm-ip> --rules=icmp --enable-logging

Contoh:

gcloud compute --project=$projectid firewall-rules create deny-icmp-vertex-pipelines-to-test-svc2-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=DENY  --source-ranges=192.168.10.0/28 --rules=ALL --destination-ranges=192.168.30.2 --enable-logging

Menjalankan tugas pipeline dari Sel Notebook

Di sel notebook baru, perbarui TARGET_IP_ADDRESS untuk mencerminkan Alamat IP yang diperoleh di langkah sebelumnya untuk test-svc-2 dan amati Status Tugas Pipelines.

TARGET_IP_ADDRESS = "<your-test-svc-2-ip>"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Contoh:

TARGET_IP_ADDRESS = "192.168.30.2"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Setelah dieksekusi, tugas pipeline akan memerlukan waktu ~8 menit untuk diselesaikan.

14. Memvalidasi konektivitas yang gagal ke test-svc-2

Di sel yang digunakan untuk menjalankan Tugas Pipelines, perhatikan transisi status dari PIPELINE_STATE_PENDING ke PIPELINE_STATE_FAILED yang menunjukkan ping yang tidak berhasil dari Vertex AI Pipelines dan respons dari test-svc-2.

Dengan menggunakan Log Explorer, Anda dapat melihat entri Logging Firewall yang cocok dengan aturan Ingress Deny yang terdiri dari subnet Vertex AI Pipelines (192.168.10.0/28) dan Alamat IP test-svc-2.

Pilih Tampilkan Kueri dan masukkan filter di bawah, 15 menit terakhir, lalu klik Jalankan Kueri.

jsonPayload.rule_details.reference:("network:consumer-vpc/firewall:deny-icmp-vertex-pipelines-to-test-svc2-vm")

20e072f26d9a113b.png

5fb3d2de0a85e3c6.png

Pilih entri log, lalu luaskan kolom bertingkat untuk menampilkan elemen informasi yang terdiri dari Vertex AI Pipelines dan Alamat IP test-svc-2 yang memvalidasi aturan firewall masuk yang ditolak.

903aaf2c10d07460.png

15. Pembersihan

Dari Cloud Shell, hapus komponen tutorial.

gcloud compute instances delete test-svc-1 test-svc-2 --zone=us-central1-a --quiet

gcloud workbench instances delete workbench-tutorial --location=us-central1-a --quiet

gcloud compute firewall-rules delete deny-icmp-vertex-pipelines-to-test-svc2-vm allow-icmp-vertex-pipelines-to-test-svc1-vm ssh-iap-consumer --quiet

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

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

16. Selamat

Selamat, Anda telah berhasil mengonfigurasi dan memvalidasi Antarmuka Private Service Connect serta konektivitas konsumen dan produsen dengan menerapkan firewall izin masuk dan tolak masuk.

Anda telah membuat infrastruktur konsumen, dan menambahkan lampiran jaringan yang memungkinkan layanan Vertex AI Pipelines membuat VM Antarmuka PSC untuk menjembatani komunikasi konsumen dan produsen. Anda telah mempelajari cara membuat aturan firewall di jaringan VPC konsumen yang mengizinkan dan menolak konektivitas ke instance di jaringan konsumen.

Cosmopup menganggap tutorial itu luar biasa.

c911c127bffdee57.jpeg

Apa selanjutnya?

Bacaan lebih lanjut & Video

Dokumen referensi