इस पेज का अनुवाद Cloud Translation API से किया गया है.

Private Service Connect Interface Vertex AI Pipelines

1. परिचय

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

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

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

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

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

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

इमेज 1

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

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

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

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

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

Google Cloud प्रोजेक्ट
IAM की अनुमतियां
Compute इंस्टेंस एडमिन (roles/compute.instanceAdmin)
Compute नेटवर्क एडमिन (roles/compute.networkAdmin)
Compute सुरक्षा एडमिन (roles/compute.securityAdmin)
आईएपी से सुरक्षित टनल उपयोगकर्ता (roles/iap.tunnelResourceAccessor)
लॉगिंग एडमिन (roles/logging.admin)
Notebooks का एडमिन (roles/notebooks.admin)
प्रोजेक्ट का आईएएम एडमिन (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. उपभोक्ता सेटअप

उपभोक्ता VPC बनाना

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, एग्ज़िट एनएटी की सुविधाएं देता है. इसका मतलब है कि इंटरनेट होस्ट, उपयोगकर्ता के मैनेज किए जा रहे नोटबुक से संपर्क नहीं कर सकते. इससे नोटबुक ज़्यादा सुरक्षित हो जाती है.

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

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

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

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 नेटवर्क अटैचमेंट सबनेट बनाना

Cloud Shell में, Vertex AI पाइपलाइन का इस्तेमाल करने वाला नेटवर्क अटैचमेंट सबनेट बनाएं.

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

4. Identify 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 में, उपभोक्ता का vm इंस्टेंस, 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 में, उपभोक्ता का vm इंस्टेंस, 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 में, टेस्ट के लिए इस्तेमाल किए जा रहे VM इंस्टेंस के बारे में जानकारी पाएं.

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 इंटरफ़ेस बनाते समय करेगा.

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

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 बनाने का तरीका बताया गया है. इस नोटबुक का इस्तेमाल, ऐसी पाइपलाइन जॉब को डिप्लॉय करने के लिए किया जाएगा जो Vertex AI Pipelines से टेस्ट इंस्टेंस पर एक पिंग भेजती है. Vertex AI पाइपलाइन और इंस्टेंस वाले कंज्यूमर नेटवर्क के बीच का डेटापाथ, Private Service Connect नेटवर्क इंटरफ़ेस का इस्तेमाल करता है.

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

अगले सेक्शन में, आपको एक सेवा खाता बनाना होगा. यह खाता, ट्यूटोरियल में इस्तेमाल किए गए 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 Admin की भूमिका के साथ अपडेट करें.

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 में, निजी-क्लाइंट इंस्टेंस बनाएं.

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. test-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 और VM के बीच होने वाले कम्यूनिकेशन की पुष्टि करने के लिए किया जाएगा.

sudo tcpdump -i any icmp -nn

9. Vertex AI के सर्विस एजेंट से जुड़ा अपडेट

Vertex AI Pipelines आपकी ओर से काम करती है. जैसे, PSC इंटरफ़ेस बनाने के लिए इस्तेमाल किए गए PSC नेटवर्क अटैचमेंट सबनेट से आईपी पता पाना. ऐसा करने के लिए, 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वां चरण पूरा होने के बाद, पाइपलाइन को पूरा होने में करीब आठ मिनट लगेंगे.

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

17वां चरण पूरा करने के लिए इस्तेमाल की गई सेल में, पाइपलाइन जॉब के स्टेटस में हुए बदलाव को देखें. यह स्टेटस, PIPELINE_STATE_PENDING से PIPELINE_STATE_RUNNING और आखिर में PIPELINE_STATE_SUCCEEDED में बदल जाता है. इससे पता चलता है कि Vertex AI पाइपलाइन से पिंग किया गया है और 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 Pilelines सबनेट (192.168.10.0/28) से test-svc-2 पर आने वाले ट्रैफ़िक को रोका जा सकेगा. इसके बाद, test-svc-2 आईपी पते को दिखाने के लिए नोटबुक को अपडेट करें. आखिर में, Pipelines जॉब को चलाएं.

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

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

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 जॉब का स्टेटस देखें.

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

लागू होने के बाद, पाइपलाइन जॉब को पूरा होने में करीब आठ मिनट लगेंगे.

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

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

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

'क्वेरी दिखाएं' चुनें और नीचे दिया गया फ़िल्टर डालें, पिछले 15 मिनट के बाद 'क्वेरी चलाएं'.

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

कोई लॉग एंट्री चुनें. इसके बाद, नेस्ट किए गए फ़ील्ड को बड़ा करके, जानकारी के एलिमेंट देखें. इनमें Vertex AI पाइपलाइन और 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. बधाई हो

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

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

Cosmopup को लगता है कि ट्यूटोरियल शानदार होते हैं!!

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

ज़्यादा पढ़ने के लिए लेख और वीडियो

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

Private Service Connect Interface Vertex AI Pipelines

1. परिचय

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

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

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

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

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

3. उपभोक्ता सेटअप

उपभोक्ता VPC बनाना

उपभोक्ता सबनेट बनाना

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

Private Service Connect नेटवर्क अटैचमेंट सबनेट बनाना

4. Identify Aware Proxy (IAP) को चालू करना

5. उपभोक्ता के लिए वीएम इंस्टेंस बनाना

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

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

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

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

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

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

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

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

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

ज़्यादा पढ़ने के लिए लेख और वीडियो

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