Private Service Connect Interface Vertex AI Pipelines

1. परिचय

Private Service Connect इंटरफ़ेस एक ऐसा संसाधन है जिसकी मदद से, प्रोड्यूसर वर्चुअल प्राइवेट क्लाउड (वीपीसी) नेटवर्क, उपभोक्ता नेटवर्क में मौजूद अलग-अलग डेस्टिनेशन से कनेक्शन शुरू कर सकता है. प्रड्यूसर और कंज्यूमर नेटवर्क, अलग-अलग प्रोजेक्ट और संगठनों में हो सकते हैं.

नेटवर्क अटैचमेंट और Private Service Connect इंटरफ़ेस के बीच कनेक्शन, Private Service Connect एंडपॉइंट और सर्विस अटैचमेंट के बीच कनेक्शन जैसा ही होता है. हालांकि, इन दोनों में दो मुख्य अंतर होते हैं:

नेटवर्क अटैचमेंट की मदद से, प्रोड्यूसर नेटवर्क, कंज्यूमर नेटवर्क (मैनेज की गई सेवा से बाहर निकलने वाला डेटा) से कनेक्शन शुरू कर सकता है. वहीं, एंडपॉइंट की मदद से, कंज्यूमर नेटवर्क, प्रोड्यूसर नेटवर्क (मैनेज की गई सेवा में आने वाला डेटा) से कनेक्शन शुरू कर सकता है.
Private Service Connect इंटरफ़ेस कनेक्शन, ट्रांज़िटिव होता है. इसका मतलब है कि प्रोड्यूसर नेटवर्क, उपभोक्ता नेटवर्क से जुड़े अन्य नेटवर्क के साथ कम्यूनिकेट कर सकता है.

आपको क्या बनाना है

Google के मैनेज किए गए किरायेदार प्रोजेक्ट में डिप्लॉय की गई Vertex AI Pipelines, पीएससी नेटवर्क अटैचमेंट का इस्तेमाल करेगी. इससे, प्रोड्यूसर और कंज्यूमर नेटवर्क के बीच मल्टी-निक इंस्टेंस बनाया जा सकेगा. पीएसए नेटवर्क अटैचमेंट को उपभोक्ता नेटवर्क से कई एनआईसी के साथ डिप्लॉय किया जाता है. इसलिए, Vertex AI Pipelines, उपभोक्ता नेटवर्क से उपलब्ध रास्तों तक पहुंच सकती हैं.

इस ट्यूटोरियल में, आपको Vertex AI Pipelines के लिए एक बेहतर Private Service Connect (PSC) इंटरफ़ेस आर्किटेक्चर बनाना है. यह Cloud Firewall के नियमों का इस्तेमाल करके, प्रोड्यूसर से उपभोक्ता के टेस्ट इंस्टेंस तक कनेक्टिविटी की अनुमति देता है या उसे अस्वीकार करता है. इसे इमेज 1 में दिखाया गया है.

इमेज 1

उपयोगकर्ता वीपीसी में एक ही psc-network-attachment बनाया जाएगा. इससे ये इस्तेमाल के उदाहरण मिलेंगे:

उपयोगकर्ता के वीपीसी में, इन्ग्रेस फ़ायरवॉल नियम बनाएं. इससे Vertex AI Pipelines के सबनेट (192.168.10.0/28) को test-svc-1 से कनेक्ट करने की अनुमति मिलेगी. TCPDUMP का इस्तेमाल करके, यह पुष्टि करें कि पाइपलाइन जॉब से जनरेट किया गया PING, test-svc-1 को भेजा गया है
उपयोगकर्ता के वीपीसी में, इन्ग्रेस फ़ायरवॉल का एक ऐसा नियम बनाएं जो Vertex AI Pipelines के सबनेट (192.168.10.0/28) को test-svc-2 से कनेक्ट होने से रोके. लॉग एक्सप्लोरर से जनरेट किए गए फ़ायरवॉल लॉग के आधार पर, पिंग फ़ेल होने की पुष्टि करें.

आपको क्या सीखने को मिलेगा

नेटवर्क अटैचमेंट बनाने का तरीका
Vertex AI Pipelines, पीएससी इंटरफ़ेस बनाने के लिए नेटवर्क अटैचमेंट का इस्तेमाल कैसे कर सकती हैं
प्रोड्यूसर से उपभोक्ता तक कम्यूनिकेशन कैसे पहुंचाया जाए
Verex AI Pipelines को उपभोक्ता वीएम, test-svc-1 से ऐक्सेस करने की अनुमति कैसे दें
Cloud Firewall का इस्तेमाल करके, Verex AI Pipelines को उपभोक्ता वीएम, test-svc-2 का ऐक्सेस देने से कैसे रोका जा सकता है

आपको इन चीज़ों की ज़रूरत होगी

Google Cloud प्रोजेक्ट
IAM अनुमतियां
कंप्यूट इंस्टेंस एडमिन (roles/compute.instanceAdmin)
Compute Network Admin (roles/compute.networkAdmin)
कंप्यूट सिक्योरिटी एडमिन (roles/compute.securityAdmin)
IAP-secured Tunnel User (roles/iap.tunnelResourceAccessor)
लॉगिंग एडमिन (roles/logging.admin)
Notebooks एडमिन (roles/notebooks.admin)
प्रोजेक्ट के लिए IAM एडमिन (roles/resourcemanager.projectIamAdmin)
कोटा एडमिन (roles/servicemanagement.quotaAdmin)
सेवा खाते का एडमिन (roles/iam.serviceAccountAdmin)
सेवा खाते का उपयोगकर्ता (roles/iam.serviceAccountUser)
Vertex AI एडमिन (roles/aiplatform.admin)

2. शुरू करने से पहले

इस ट्यूटोरियल में, Cloud Shell में gcloud कॉन्फ़िगरेशन लागू करने में मदद के लिए, $variables का इस्तेमाल किया गया है.

Cloud Shell में, यह तरीका अपनाएं:

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

ट्यूटोरियल के साथ काम करने के लिए प्रोजेक्ट को अपडेट करना

Cloud Shell में, यह तरीका अपनाएं:

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. उपयोगकर्ता का सेटअप

उपयोगकर्ता वीपीसी बनाना

Cloud Shell में, यह तरीका अपनाएं:

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

उपयोगकर्ता के सबनेट बनाना

Cloud Shell में, यह तरीका अपनाएं:

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

Cloud Shell में, यह तरीका अपनाएं:

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

Cloud Shell में, यह तरीका अपनाएं:

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

क्लाउड राऊटर और एनएटी कॉन्फ़िगरेशन

नोटबुक सॉफ़्टवेयर पैकेज डाउनलोड करने के लिए, ट्यूटोरियल में Cloud Network Address Translation (NAT) का इस्तेमाल किया जाता है. ऐसा इसलिए, क्योंकि नोटबुक इंस्टेंस के पास कोई बाहरी आईपी पता नहीं होता है. Cloud NAT, इग्रेस NAT की सुविधाएं देता है. इसका मतलब है कि इंटरनेट होस्ट को, उपयोगकर्ता के मैनेज किए गए नोटबुक से कम्यूनिकेशन शुरू करने की अनुमति नहीं है. इससे यह ज़्यादा सुरक्षित हो जाता है.

Cloud Shell में, रीजनल क्लाउड राउटर बनाएं.

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

Cloud Shell में, रीजनल क्लाउड नेट गेटवे बनाएं.

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

Private Service Connect Network Attachment सबनेट बनाना

Cloud Shell में, 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. Identity-Aware Proxy (IAP) चालू करना

आईएपी को अपने वीएम इंस्टेंस से कनेक्ट करने की अनुमति देने के लिए, फ़ायरवॉल का ऐसा नियम बनाएं जो:

यह उन सभी वीएम इंस्टेंस पर लागू होता है जिन्हें आपको आईएपी का इस्तेमाल करके ऐक्सेस करना है.
इसकी मदद से, 35.235.240.0/20 आईपी रेंज से इन्ग्रेस ट्रैफ़िक को आने की अनुमति मिलती है. इस रेंज में वे सभी आईपी पते शामिल हैं जिनका इस्तेमाल IAP, टीसीपी फ़ॉरवर्डिंग के लिए करता है.

Cloud Shell में, IAP फ़ायरवॉल नियम बनाएं.

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

5. उपयोगकर्ता वीएम इंस्टेंस बनाना

Cloud Shell में, उपभोक्ता वीएम इंस्टेंस 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

Cloud Shell में, उपभोक्ता वीएम इंस्टेंस 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

इंस्टेंस के आईपी पते पाना और उन्हें सेव करना:

Cloud Shell में, टेस्ट वीएम इंस्टेंस के बारे में जानकारी पाएं.

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:

उदाहरण:

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. Private Service Connect नेटवर्क अटैचमेंट

नेटवर्क अटैचमेंट, क्षेत्रीय संसाधन होते हैं. ये Private Service Connect इंटरफ़ेस के उपभोक्ता पक्ष को दिखाते हैं. नेटवर्क अटैचमेंट के साथ एक सबनेट को जोड़ा जाता है. इसके बाद, प्रोड्यूसर (Vertex AI Pipelines), Private Service Connect इंटरफ़ेस को आईपी असाइन करता है.

नेटवर्क अटैचमेंट बनाना

Cloud Shell में, नेटवर्क अटैचमेंट बनाएं.

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

नेटवर्क अटैचमेंट की सूची बनाना

Cloud Shell में, नेटवर्क अटैचमेंट की सूची बनाएं.

gcloud compute network-attachments list

नेटवर्क अटैचमेंट के बारे में जानकारी

Cloud Shell में, नेटवर्क अटैचमेंट के बारे में बताएं.

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

psc-network-attachment यूआरआई को नोट करें. इसका इस्तेमाल, Private Service Connect इंटरफ़ेस बनाते समय प्रोड्यूसर करेगा.

नीचे दिए गए उदाहरण में, पीएससी नेटवर्क अटैचमेंट का यूआरआई यह है:

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. Vertex AI Workbench सेटअप करना

यहां दिए गए सेक्शन में, Jupyter Notebook बनाने का तरीका बताया गया है. इस नोटबुक का इस्तेमाल, Pipelines Job को डिप्लॉय करने के लिए किया जाएगा. यह Pipelines Job, Vertex AI Pipelines से टेस्ट इंस्टेंस को पिंग करता है. Vertex AI Pipelines और इंस्टेंस वाले उपभोक्ता नेटवर्क के बीच डेटापाथ, Private Service Connect Network Interface का इस्तेमाल करता है.

उपयोगकर्ता के मैनेज किए गए सेवा खाते बनाना

इस सेक्शन में, आपको एक सेवा खाता बनाना होगा. यह खाता, ट्यूटोरियल में इस्तेमाल किए गए Vertex AI Workbench इंस्टेंस से जुड़ा होगा.

ट्यूटोरियल में, सेवा खाते पर ये भूमिकाएं लागू होंगी:

Cloud Shell में, सेवा खाता बनाएं.

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

Cloud Shell में, सेवा खाते को स्टोरेज एडमिन की भूमिका के साथ अपडेट करें.

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

Cloud Shell में, सेवा खाते को Vertex AI उपयोगकर्ता की भूमिका के साथ अपडेट करें.

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

Cloud Shell में, सेवा खाते को Artifact Registry एडमिन की भूमिका असाइन करें.

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

Cloud Shell में, नोटबुक सेवा खाते को 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"

Vertex AI Workbench इंस्टेंस बनाना

नीचे दिए गए सेक्शन में, Vertex AI Workbench का ऐसा इंस्टेंस बनाएं जिसमें पहले से बनाया गया सेवा खाता, notebook-sa शामिल हो.

Cloud Shell में, private-client इंस्टेंस बनाएं.

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. टेस्ट-svc-1 से कनेक्टिविटी के लिए Vertex AI Pipelines

Cloud Shell का नया टैब खोलें और अपने प्रोजेक्ट की सेटिंग अपडेट करें.

Cloud Shell में, यह तरीका अपनाएं:

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

Vertex AI Pipelines से test-svc-1 तक कनेक्टिविटी की अनुमति देने के लिए, इनग्रेस फ़ायरवॉल के ऐसे नियम बनाएं जिनमें पीएससी नेटवर्क अटैचमेंट को सोर्स (192.168.10.0/28) और test-svc-1 के आईपी पते को डेस्टिनेशन के तौर पर तय किया गया हो.

Cloud Shell में, डेस्टिनेशन-रेंज को अपडेट करके, उसे test-svc-1 के आईपी पते से मैच करें.

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

उदाहरण:

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

Cloud Shell में IAP का इस्तेमाल करके, test-svc-1 इंस्टेंस में लॉग इन करें.

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

ओएस में, किसी भी आईसीएमपी ट्रैफ़िक को कैप्चर करने के लिए tcpdump को एक्ज़ीक्यूट करें. इस ओएस सेशन का इस्तेमाल, Vertex AI Pipeline और वीएम के बीच कम्यूनिकेशन की पुष्टि करने के लिए किया जाएगा.

sudo tcpdump -i any icmp -nn

9. Vertex AI सेवा एजेंट को अपडेट करना

Vertex AI Pipelines, आपकी ओर से कई कार्रवाइयां करता है. जैसे, पीएससी इंटरफ़ेस बनाने के लिए इस्तेमाल किए गए पीएससी नेटवर्क अटैचमेंट सबनेट से आईपी पता पाना. इसके लिए, Vertex AI Pipelines, सेवा एजेंट (नीचे दिया गया है) का इस्तेमाल करता है. इसके लिए, नेटवर्क एडमिन की अनुमति ज़रूरी है.

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

Cloud Shell में, अपना प्रोजेक्ट नंबर पाएं.

gcloud projects describe $projectid | grep projectNumber

उदाहरण:

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

Cloud Shell में, सेवा एजेंट खाते को compute.networkAdmin की भूमिका के साथ अपडेट करें.

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

उदाहरण:

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

10. डिफ़ॉल्ट सेवा खाते को अपडेट करना

Compute Engine API चालू करें और अपने डिफ़ॉल्ट सेवा खाते को Vertex AI का ऐक्सेस दें. ध्यान दें कि ऐक्सेस में किए गए बदलावों को लागू होने में कुछ समय लग सकता है.

Cloud Shell में, डिफ़ॉल्ट सेवा खाते को aiplatform.user की भूमिका के साथ अपडेट करें

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

उदाहरण:

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

11. Vertex AI Pipelines जॉब डिप्लॉय करना

नीचे दिए गए सेक्शन में, आपको एक नोटबुक बनानी होगी. इससे उपभोक्ता के test-svc-1 इंस्टेंस को PING किया जा सकेगा.

Vertex AI Workbench इंस्टेंस में ट्रेनिंग जॉब चलाएं.

Google Cloud Console में, Vertex AI Workbench पेज पर मौजूद इंस्टेंस टैब पर जाएं.
Vertex AI Workbench इंस्टेंस के नाम (workbench-tutorial) के बगल में, JupyterLab खोलें पर क्लिक करें. आपका Vertex AI Workbench इंस्टेंस, JupyterLab में खुलता है.
फ़ाइल > नया > नोटबुक चुनें
Kernel > Python 3 को चुनें
नई नोटबुक सेल में, यह कमांड चलाएं. इससे यह पक्का किया जा सकेगा कि आपके पास pip का नया वर्शन है:

! pip3 install --upgrade --quiet google-cloud-aiplatform \
  kfp \
  google-cloud-pipeline-components

नई नोटबुक सेल में अपने प्रोजेक्ट वैरिएबल सेट करना

PROJECT_ID = "<your-projectid>" 
REGION = "<your-region>"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

उदाहरण:

PROJECT_ID = "psc-vertex" 
REGION = "us-central1"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

नई नोटबुक सेल में, दुनिया भर में पहचाना जाने वाला यूनीक बकेट का नाम वैरिएबल के तौर पर तय करें

BUCKET_URI = f"gs://<your-bucket-name>"

उदाहरण:

BUCKET_URI = f"gs://psc-vertex-bucket"

नई नोटबुक सेल में, बकेट बनाएं

! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

इस सेक्शन में, आपको पाइपलाइन जॉब चलाने के लिए इस्तेमाल किए जाने वाले डिफ़ॉल्ट Compute Engine सेवा खाते के बारे में पता चलेगा. साथ ही, आपको इसे सही अनुमतियां देने का तरीका भी पता चलेगा.

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

पुष्टि करने के लिए कि यह प्रोसेस पूरी हो गई है, आपके सेवा खाते और प्रोजेक्ट नंबर को प्रिंट किया जाता है

नई नोटबुक सेल में, अपनी सेवा खाते को पिछले चरण में बनाए गए बकेट में पाइपलाइन आर्टफ़ैक्ट को पढ़ने और लिखने की अनुमति दें.

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectCreator {BUCKET_URI}

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectViewer {BUCKET_URI}

नई नोटबुक सेल में, पाइपलाइन के पैरामीटर तय करें. ध्यान दें कि NETWORK_ATTACHMENT_NAME, पीएससी नेटवर्क अटैचमेंट है. इसलिए, यह मेल खाना चाहिए.

PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/psc_test"
NETWORK_ATTACHMENT_URI = f"projects/{PROJECT_NUMBER}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}"

नई नोटबुक सेल में, 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')

नई नोटबुक सेल में, टेस्ट कॉम्पोनेंट तय करें

@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
            """
        ],
    )

नई नोटबुक सेल में, पाइपलाइन तय करें

@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

नई नोटबुक सेल में, यूटिलिटी फ़ंक्शन को लागू करें और पाइपलाइन के पूरा होने का इंतज़ार करें

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

नई नोटबुक सेल में, पाइपलाइन चलाने के लिए यूटिलिटी फ़ंक्शन को लागू करें

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

नई नोटबुक सेल में, पाइपलाइन को कंपाइल करें

from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')

नई नोटबुक सेल में, TARGET_IP_ADDRESS को अपडेट करके, test-svc-1 के लिए पिछले चरण में मिला आईपी पता डालें. इसके बाद, पाइपलाइन जॉब का स्टेटस देखें

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

उदाहरण:

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

17वां चरण पूरा होने के बाद, पाइपलाइन को पूरा होने में ~8 मिनट लगेंगे.

12. test-svc-1 से कनेक्टिविटी की पुष्टि करें

चरण 17 को लागू करने के लिए इस्तेमाल की गई सेल में, पाइपलाइन जॉब के स्टेटस को PIPELINE_STATE_PENDING से PIPELINE_STATE_RUNNING और आखिर में PIPELINE_STATE_SUCCEEDED में बदलते हुए देखें. इससे पता चलता है कि Vertex AI Pipelines से पिंग किया गया और test-svc-1 से जवाब मिला.

Vertex AI Pipeline और test-svc-1 के बीच ICMP ट्रैफ़िक की पुष्टि करने के लिए, test-svc-1 OS में पहले से जनरेट किए गए tcpdump सेशन को देखें. इससे दोनों दिशाओं में होने वाले ट्रैफ़िक के लॉग मिलते हैं.

tcpdump के उदाहरण में, Vertex AI Pipelines ने 192.168.10.0/28 सबनेट से आईपी पता 192.168.10.3 लिया है. 192.168.20.2, test-svc-1 का आईपी पता है. ध्यान दें कि आपके एनवायरमेंट में, आईपी पते अलग-अलग हो सकते हैं.

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. Vertex AI Pipelines AI to test-svc-2 connectivity

यहां दिए गए सेक्शन में, आपको इनग्रेस फ़ायरवॉल का एक नियम बनाना होगा. इससे Vertex AI Pipelines के सबनेट (192.168.10.0/28) से test-svc-2 तक पहुंचने वाले ट्रैफ़िक को रोका जा सकेगा. इसके बाद, आपको Notebook को अपडेट करना होगा, ताकि उसमें test-svc-2 का आईपी पता दिखे. आखिर में, Pipelines Jobs को चलाना होगा.

नोटबुक सेल में, पाइपलाइन जॉब की स्थिति में गड़बड़ी - पाइपलाइन पूरी नहीं हुई दिखेगी. साथ ही, फ़ायरवॉल लॉगिंग से कनेक्शन के काम न करने के बारे में अहम जानकारी मिलेगी.

इन्ग्रेस डेटा ट्रैफ़िक रोकने का फ़ायरवॉल नियम बनाना

Vertex AI Pipelines को test-svc-2 से कनेक्ट करने की अनुमति न देने के लिए, इनग्रेस फ़ायरवॉल के ऐसे नियम बनाएं जिनमें पीएससी नेटवर्क अटैचमेंट को सोर्स (192.168.10.0/28) और test-svc-2 के आईपी पते को डेस्टिनेशन के तौर पर तय किया गया हो.

Cloud Shell में, डेस्टिनेशन-रेंज को अपडेट करके, उसे test-svc-2 के आईपी पते से मैच करें.

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

उदाहरण:

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

नोटबुक सेल से पाइपलाइन जॉब को एक्ज़ीक्यूट करना

नई नोटबुक सेल में, TARGET_IP_ADDRESS को अपडेट करके, test-svc-2 के लिए पहले चरण में मिला आईपी पता डालें. इसके बाद, Pipelines Job Status देखें.

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

उदाहरण:

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

पाइपलाइन जॉब को पूरा होने में ~8 मिनट लगेंगे.

14. test-svc-2 से कनेक्टिविटी की पुष्टि नहीं की जा सकी

पाइपलाइन जॉब को लागू करने के लिए इस्तेमाल की गई सेल में, PIPELINE_STATE_PENDING से PIPELINE_STATE_FAILED में स्टेटस ट्रांज़िशन को नोट करें. इससे पता चलता है कि Vertex AI Pipelines से पिंग नहीं किया जा सका और test-svc-2 से कोई जवाब नहीं मिला.

लॉग एक्सप्लोरर का इस्तेमाल करके, फ़ायरवॉल लॉगिंग की उन एंट्री को देखा जा सकता है जो इनग्रैस डेनाई नियम से मेल खाती हैं. इनमें Vertex AI Pipelines सबनेट (192.168.10.0/28) और test-svc-2 का आईपी पता शामिल है.

'क्वेरी दिखाएं' को चुनें और नीचे दिए गए फ़िल्टर को डालें. इसके बाद, 'क्वेरी चलाएं' को चुनें.

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

कोई लॉग एंट्री चुनें. इसके बाद, नेस्ट किए गए फ़ील्ड को बड़ा करके, जानकारी वाले एलिमेंट दिखाएं. इनमें Vertex AI Pipelines और test-svc-2 का आईपी पता शामिल है. इससे, इनग्रेस फ़ायरवॉल के उस नियम की पुष्टि की जा सकती है जिसे अस्वीकार कर दिया गया है.

15. व्यवस्थित करें

Cloud Shell से, ट्यूटोरियल के कॉम्पोनेंट मिटाएं.

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. बधाई हो

बधाई हो! आपने Private Service Connect इंटरफ़ेस को कॉन्फ़िगर और पुष्टि कर ली है. साथ ही, आपने Ingress की अनुमति देने और फ़ायरवॉल को अस्वीकार करने की सुविधा लागू करके, उपभोक्ता और प्रोड्यूसर के बीच कनेक्टिविटी की पुष्टि कर ली है.

आपने उपभोक्ता इन्फ़्रास्ट्रक्चर बनाया है. साथ ही, आपने एक नेटवर्क अटैचमेंट जोड़ा है. इससे Vertex AI Pipelines सेवा को पीएससी इंटरफ़ेस वीएम बनाने की अनुमति मिलती है, ताकि उपभोक्ता और प्रॉड्यूसर के बीच कम्यूनिकेशन हो सके. आपने सीखा कि उपभोक्ता वीपीसी नेटवर्क में फ़ायरवॉल के नियम कैसे बनाए जाते हैं. इन नियमों से, उपभोक्ता नेटवर्क में मौजूद इंस्टेंस को कनेक्ट करने की अनुमति दी जाती है और कनेक्ट करने से रोका जाता है.

Cosmopup को ट्यूटोरियल बहुत पसंद हैं!!

आगे क्या करना है?

ज़्यादा जानकारी और वीडियो

Private Service Connect के बारे में खास जानकारी

Private Service Connect Interface Vertex AI Pipelines

1. परिचय

आपको क्या बनाना है

आपको क्या सीखने को मिलेगा

आपको इन चीज़ों की ज़रूरत होगी

2. शुरू करने से पहले

ट्यूटोरियल के साथ काम करने के लिए प्रोजेक्ट को अपडेट करना

3. उपयोगकर्ता का सेटअप

उपयोगकर्ता वीपीसी बनाना

उपयोगकर्ता के सबनेट बनाना

क्लाउड राऊटर और एनएटी कॉन्फ़िगरेशन

Private Service Connect Network Attachment सबनेट बनाना

4. Identity-Aware Proxy (IAP) चालू करना

5. उपयोगकर्ता वीएम इंस्टेंस बनाना

6. Private Service Connect नेटवर्क अटैचमेंट

नेटवर्क अटैचमेंट बनाना

नेटवर्क अटैचमेंट की सूची बनाना

नेटवर्क अटैचमेंट के बारे में जानकारी

7. Vertex AI Workbench सेटअप करना

उपयोगकर्ता के मैनेज किए गए सेवा खाते बनाना

Vertex AI Workbench इंस्टेंस बनाना

8. टेस्ट-svc-1 से कनेक्टिविटी के लिए Vertex AI Pipelines

9. Vertex AI सेवा एजेंट को अपडेट करना

10. डिफ़ॉल्ट सेवा खाते को अपडेट करना

11. Vertex AI Pipelines जॉब डिप्लॉय करना

12. test-svc-1 से कनेक्टिविटी की पुष्टि करें

13. Vertex AI Pipelines AI to test-svc-2 connectivity

इन्ग्रेस डेटा ट्रैफ़िक रोकने का फ़ायरवॉल नियम बनाना

नोटबुक सेल से पाइपलाइन जॉब को एक्ज़ीक्यूट करना

14. test-svc-2 से कनेक्टिविटी की पुष्टि नहीं की जा सकी

15. व्यवस्थित करें

16. बधाई हो

आगे क्या करना है?

ज़्यादा जानकारी और वीडियो

रेफ़रंस दस्तावेज़