Vertex AI Pipelines PSC इंटरफ़ेस के लिए, साफ़ तौर पर प्रॉक्सी सेट करना

1. परिचय

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

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

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

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

Vertex AI PSC-Interface की पहुंच से जुड़ी ज़रूरी बातें

  • पीएससी-इंटरफ़ेस, RFC1918 पते के ब्लॉक में मौजूद वीपीसी या ऑन-प्रीमाइसेस डेस्टिनेशन पर ट्रैफ़िक को रूट कर सकता है.
  • RFC-1918 के बाहर के पतों को टारगेट करने वाले पीएससी-इंटरफ़ेस के लिए, उपभोक्ता के वीपीसी में RFC-1918 पते के साथ एक प्रॉक्सी डिप्लॉय करना ज़रूरी है. Vertex AI डिप्लॉयमेंट में, प्रॉक्सी को टारगेट एंडपॉइंट के FQDN के साथ तय किया जाना चाहिए. पहले फ़िगर में, ग्राहकों के वीपीसी में कॉन्फ़िगर किया गया एक्सप्लिसिट प्रॉक्सी दिखाया गया है. इससे, नीचे दिए गए नॉन RFC-1918 सीआईडीआर को रूट करने में मदद मिलती है:

[1] 240.0.0.0/4

[2] 203.0.113.0/2

[3]10.10.20.0/28 के लिए प्रॉक्सी की ज़रूरत नहीं है. यह rfc1918 रेंज में आता है.

  • सिर्फ़ पीएससी इंटरफ़ेस का इस्तेमाल करके डिप्लॉयमेंट को कॉन्फ़िगर करने पर, इंटरनेट ऐक्सेस करने की डिफ़ॉल्ट सेटिंग बनी रहती है. यह आउटबाउंड ट्रैफ़िक, सीधे तौर पर Google के मैनेज किए गए सुरक्षित टेनेंट नेटवर्क से बाहर निकलता है.

476f87a96f153b95.png

Vertex AI PSC-Interface VPC-SC से जुड़ी ज़रूरी बातें

  • जब आपका प्रोजेक्ट, वीपीसी सर्विस कंट्रोल के पेरीमीटर का हिस्सा होता है, तब Google के मैनेज किए गए किरायेदार के डिफ़ॉल्ट इंटरनेट ऐक्सेस को पेरीमीटर ब्लॉक कर देता है. ऐसा डेटा एक्सफ़िल्ट्रेशन को रोकने के लिए किया जाता है.
  • इस स्थिति में, डिप्लॉयमेंट को सार्वजनिक इंटरनेट का ऐक्सेस देने के लिए, आपको साफ़ तौर पर एक सुरक्षित इग्रेस पाथ कॉन्फ़िगर करना होगा. इससे ट्रैफ़िक आपके वीपीसी से होकर जाएगा. इसके लिए, हमारा सुझाव है कि आप अपने वीपीसी के दायरे में RFC1918 पते वाला प्रॉक्सी सर्वर सेट अप करें. साथ ही, प्रॉक्सी वीएम को इंटरनेट ऐक्सेस करने की अनुमति देने के लिए, Cloud NAT गेटवे बनाएं.

ज़्यादा जानकारी के लिए, यहां दिए गए संसाधन देखें:

Vertex AI के संसाधनों के लिए Private Service Connect इंटरफ़ेस सेट अप करना | Google Cloud

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

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

इमेज 2

782ba8f1f3c3f522.png

उपभोक्ता वीपीसी में एक ही पीएससी-नेटवर्क-अटैचमेंट बनाया जाएगा. इसमें डीएनएस पीयरिंग का इस्तेमाल किया जाएगा, ताकि किरायेदार प्रोजेक्ट में मौजूद उपभोक्ता वीएम को हल किया जा सके. इस प्रोजेक्ट में Vertex AI Training को होस्ट किया जाता है. इससे ये काम किए जा सकते हैं:

  1. Vertex AI Pipelines को डिप्लॉय करना और प्रॉक्सी वीएम को एक्सप्लिसिट प्रॉक्सी के तौर पर कॉन्फ़िगर करना. इससे, क्लास ई सबनेट में मौजूद वीएम के ख़िलाफ़ wget कार्रवाई की जा सकेगी.

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

  • नेटवर्क अटैचमेंट बनाने का तरीका
  • कोई प्रोड्यूसर, नेटवर्क अटैचमेंट का इस्तेमाल करके पीएससी इंटरफ़ेस कैसे बना सकता है
  • डीएनएस पियरिंग का इस्तेमाल करके, प्रोड्यूसर से उपभोक्ता तक कम्यूनिकेशन कैसे सेट अप करें
  • Vertex AI Pipelines से, rfc1918 के अलावा दूसरे आईपी पते के स्पेस से कम्यूनिकेशन कैसे सेट अप करें

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

Google Cloud प्रोजेक्ट

IAM अनुमतियां

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 "compute.googleapis.com"
gcloud services enable "aiplatform.googleapis.com"
gcloud services enable "dns.googleapis.com"
gcloud services enable "notebooks.googleapis.com"
gcloud services enable "storage.googleapis.com"
gcloud services enable "cloudresourcemanager.googleapis.com"
gcloud services enable "artifactregistry.googleapis.com"
gcloud services enable "cloudbuild.googleapis.com"

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

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

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

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

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

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

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

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

gcloud compute networks subnets create rfc1918-subnet1 --project=$projectid --range=10.10.10.0/28 --network=consumer-vpc --region=us-central1

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

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

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

Cloud Router और NAT कॉन्फ़िगरेशन

इस ट्यूटोरियल में, Cloud NAT का इस्तेमाल प्रॉक्सी वीएम को इंटरनेट ऐक्सेस देने के लिए किया गया है. इस वीएम के पास सार्वजनिक आईपी पता नहीं है. Cloud NAT की मदद से, सिर्फ़ निजी आईपी पते वाले वीएम को इंटरनेट से कनेक्ट किया जा सकता है. इससे वे सॉफ़्टवेयर पैकेज इंस्टॉल करने जैसे टास्क कर पाते हैं.

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

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

Cloud Shell में, NAT गेटवे बनाएं.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-for-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1 --enable-logging --log-filter=ALL

4. 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 में, कंज्यूमर वीएम इंस्टेंस, class-e-vm बनाएं.

gcloud compute instances create class-e-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=class-e-subnet \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'Class-e server !!' | tee /var/www/html/index.html
      EOF"

Cloud Shell में, उपभोक्ता वीएम इंस्टेंस, proxy-vm बनाएं. यह Vertex AI Pipelines के लिए, एक्सप्लिसिट प्रॉक्सी के तौर पर काम करेगा. हम एचटीटीपी ट्रैफ़िक को प्रॉक्सी करने के लिए, ऐप्लिकेशन के तौर पर tinyproxy का इस्तेमाल करेंगे. हालांकि, एचटीटीपीएस भी काम करता है.

gcloud compute instances create proxy-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --can-ip-forward \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=rfc1918-subnet1 \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install tinyproxy -y
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'proxy server !!' | tee /var/www/html/index.html
      EOF"

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

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

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

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

gcloud compute network-attachments create psc-network-attachment \
    --region=us-central1 \
    --connection-preference=ACCEPT_AUTOMATIC \
    --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 नाम वाले psc-network-attachment को नोट करें. इसका इस्तेमाल, प्रोड्यूसर Private Service Connect इंटरफ़ेस बनाते समय करेगा.

Cloud Console में PSC नेटवर्क अटैचमेंट का यूआरएल देखने के लिए, यहां जाएं:

नेटवर्क सेवाएं → Private Service Connect → नेटवर्क अटैचमेंट → psc-network-attachment

e191e54a103d2222.png

7. निजी डीएनएस ज़ोन

आपको demo.com के लिए Cloud DNS ज़ोन बनाना होगा. साथ ही, इसमें ऐसे A रिकॉर्ड जोड़ने होंगे जो आपके वीएम के आईपी पतों पर ले जाते हों. बाद में, Vertex AI Pipelines के काम में डीएनएस पियरिंग को डिप्लॉय किया जाएगा. इससे, यह उपभोक्ता के डीएनएस रिकॉर्ड को ऐक्सेस कर पाएगा.

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

gcloud dns --project=$projectid managed-zones create private-dns-codelab --description="" --dns-name="demo.com." --visibility="private" --networks="https://compute.googleapis.com/compute/v1/projects/$projectid/global/networks/consumer-vpc"

Cloud Shell में, वीएम इंस्टेंस के बारे में जानकारी पाने के लिए, describe कमांड का इस्तेमाल करें. इससे आपको आईपी पते मिलेंगे.

gcloud compute instances describe class-e-vm --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe proxy-vm --zone=us-central1-a | grep  networkIP:

Cloud Shell में, वीएम के लिए रिकॉर्ड सेट बनाएं. जैसे, class-e-vm. साथ ही, अपने एनवायरमेंट के आउटपुट के आधार पर आईपी पते को अपडेट करना न भूलें.

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

Cloud Shell में, वीएम और प्रॉक्सी-वीएम के लिए रिकॉर्ड सेट बनाएं. साथ ही, अपने एनवायरमेंट के आउटपुट के आधार पर आईपी पते को अपडेट करना न भूलें.

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

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

नीचे दिए गए सेक्शन में, एक फ़ायरवॉल नियम बनाएं. इससे पीएससी नेटवर्क अटैचमेंट से आने वाले ट्रैफ़िक को, उपभोक्ता के वीपीसी में RFC1918 कंप्यूट संसाधनों को ऐक्सेस करने की अनुमति मिलती है.

Cloud Shell में, इन्ग्रेस फ़ायरवॉल का ऐसा नियम बनाएं जिससे पीएससी नेटवर्क अटैचमेंट सबनेट से प्रॉक्सी-वीएम को ऐक्सेस किया जा सके.

gcloud compute firewall-rules create allow-access-to-proxy \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="192.168.10.0/28" \
    --destination-ranges="10.10.0.0/19" \
    --enable-logging

Cloud Shell में, इन्ग्रेस फ़ायरवॉल का ऐसा नियम बनाएं जिससे प्रॉक्सी-वीएम सबनेट से क्लास-ई सबनेट को ऐक्सेस किया जा सके.

gcloud compute firewall-rules create allow-access-to-class-e \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="10.10.10.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

8. एक्सप्लिसिट प्रॉक्सी को अपडेट करना

नीचे दिए गए सेक्शन में, आपको एक्सप्लिसिट प्रॉक्सी में एसएसएच करना होगा. इसके बाद, tinyproxy.conf कॉन्फ़िगरेशन फ़ाइल को अपडेट करना होगा. इसके बाद, रीसेट करना होगा.

Cloud Shell से

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

tinyproxy की कॉन्फ़िगरेशन फ़ाइल खोलें और अपनी पसंद के एडिटर का इस्तेमाल करके उसे अपडेट करें. यहां VIM का इस्तेमाल करने का एक उदाहरण दिया गया है.

sudo vim /etc/tinyproxy/tinyproxy.conf

# Locate the "Listen" configuration line to restrict listening to only its private IP address of the Proxy-VM, rather than all interfaces. 

Listen 10.10.10.2

# Locate the "Allow" configuration line to allow requests ONLY from the PSC Network Attachment Subnet

Allow 192.168.10.0/24

Save the configs by the following steps:
1. Press the `ESC` key to enter Command Mode.
2. Type `:wq` to save (w) and quit (q).
3. Press `Enter`

Restart the tinyproxy service to apply the changes:
sudo systemctl restart tinyproxy

Validate the tinyproxy service is running:
sudo systemctl status tinyproxy

Perform an exit returning to cloud shell
exit

9. Jupyter Notebook बनाना

यहां दिए गए सेक्शन में, Jupyter Notebook बनाने का तरीका बताया गया है. इस नोटबुक का इस्तेमाल, Vertex AI Pipelines की मदद से एक ऐसा जॉब डिप्लॉय करने के लिए किया जाएगा जो Vertex AI Pipelines से टेस्ट इंस्टेंस पर wget भेजता है. 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 में, सेवा खाते को Cloud Build Editor की भूमिका के साथ अपडेट करें.

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

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"

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

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

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

gcloud workbench instances create workbench-tutorial --vm-image-project=cloud-notebooks-managed --vm-image-family=workbench-instances --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=rfc1918-subnet1 --disable-public-ip --shielded-secure-boot=true --shielded-integrity-monitoring=true --shielded-vtpm=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

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

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

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

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

gcloud projects describe $projectid | grep projectNumber

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

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

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

projectnumber=YOUR-PROJECT-Number

Cloud Shell में, AI Platform के लिए एक सेवा खाता बनाएं. अगर आपके प्रोजेक्ट में पहले से कोई सेवा खाता मौजूद है, तो यह चरण छोड़ दें.

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

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

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

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

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

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

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

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

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

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

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

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

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

12. Tcpdump चालू करना

Vertex AI Pipelines से आईपी कनेक्टिविटी की पुष्टि करने के लिए, हम TCPDUMP का इस्तेमाल कर सकते हैं. इससे हमें पीएससी नेटवर्क अटैचमेंट सबनेट, 192.168.10.0/28 से शुरू होने वाले कम्यूनिकेशन को मॉनिटर करने में मदद मिलेगी. ऐसा तब होगा, जब Vertex AI Pipelines से vm, class-e-vm.demo.com (240.0.0.0/4) को get अनुरोध भेजा जाएगा.

Cloud Shell से प्रॉक्सी वीएम में एसएसएच करें.

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

प्रॉक्सी-वीएम ओएस से, क्लास-ई-वीएम और पीएससी नेटवर्क अटैचमेंट सबनेट पर tcpdump फ़िल्टरिंग लागू करें.

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

Cloud Shell का नया टैब खोलें, अपने प्रोजेक्ट के वैरिएबल को अपडेट करें, और class-e-vm में एसएसएच करें

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

क्लास-ई-वीएम ओएस से, प्रॉक्सी-वीएम सबनेट पर tcpdump फ़िल्टरिंग को लागू करें..

sudo tcpdump -i any net 10.10.10.0/28 -nn

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

यहां दिए गए सेक्शन में, आपको एक नोटबुक बनानी होगी. इससे, Vertex AI Pipelines से एक्सप्लिसिट प्रॉक्सी तक wget किया जा सकेगा. इससे आपको RFC 1918 के अलावा अन्य वीएम तक पहुंचने में मदद मिलती है. जैसे, क्लास-ई-वीएम. rfc1918-vm को ऐक्सेस करने के लिए, Vertex AI Pipelines को किसी एक्सप्लिसिट प्रॉक्सी की ज़रूरत नहीं होती, क्योंकि इसका टारगेट RFC 1918 आईपी पता होता है.

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

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

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

# Install gcloud
!pip install google-cloud

# Install the pipeline required packages
!pip install --upgrade google-cloud-aiplatform \
                         google-cloud-storage \
                         kfp \
                         google-cloud-pipeline-components

# Import libraries
from time import gmtime, strftime
import json
import requests

JupyterLab नोटबुक में, एक नई सेल बनाएं. इसके बाद, इसे अपडेट करें और चलाएं. पक्का करें कि आपने PROJECT_ID को अपने एनवायरमेंट की जानकारी से अपडेट किया हो.

import json
import requests
import pprint

PROJECT_ID = 'YOUR-PROJECT-ID' #Enter your project ID
PROJECT_NUMBER=!gcloud projects list --filter="project_id:$PROJECT_ID" --format="value(PROJECT_NUMBER)"
PROJECT_NUMBER=str(PROJECT_NUMBER).strip('[').strip(']').strip("'")
print(PROJECT_NUMBER)

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

# us-central1 is used for the codelab
REGION = "us-central1" #@param {type:"string"}
SERVICE_NAME = "aiplatform" #@param {type:"string"}
SERVICE ="{}.googleapis.com".format(SERVICE_NAME)
ENDPOINT="{}-{}.googleapis.com".format(REGION, SERVICE_NAME)
API_VERSION = "v1" # @param {type: "string"}

LOCATION = REGION

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिए गए कॉन्फ़िगरेशन को चलाएं. साथ ही, इन बातों का ध्यान रखें:

  • proxy_server = "http://proxy-vm.demo.com:8888" FQDN, उपभोक्ता के वीपीसी में डिप्लॉय किए गए प्रॉक्सी वीएम से जुड़ा होता है. हम बाद के चरण में एफ़क्यूडीएन को हल करने के लिए, डीएनएस पियरिंग का इस्तेमाल कर रहे हैं.
%%writefile main.py

import logging
import socket
import sys
import os

def make_api_request(url: str, proxy_vm_ip: str, proxy_vm_port: str):
    """
    Makes a GET request to a non-rfc1918 API and saves the response.

    Args:
        url: The URL of the API to send the request to.
    """
    import requests

    try:
        # response = requests.get(url)
        proxy_server = f"http://proxy-vm.demo.com:8888" # replace with you VM's IP and proxy port.

        proxies = {
          "http": proxy_server,
          "https": proxy_server,
        }

        response = requests.get(url, proxies=proxies)
        logging.info(response.text)

        response.raise_for_status()  # Raise an exception for bad status codes
        logging.info(f"Successfully fetched data from {url}")
    except requests.exceptions.RequestException as e:
        logging.error(f"An error occurred: {e}")
        raise e

if __name__ == '__main__':
  # Configure logging to print clearly to the console
  logging.basicConfig(
      level=logging.INFO,
      format='%(levelname)s: %(message)s',
      stream=sys.stdout
  )
  url_to_test = os.environ['NONRFC_URL']
  proxy_vm_ip = os.environ['PROXY_VM_IP']
  proxy_vm_port = os.environ['PROXY_VM_PORT']

  logging.info(f"url_to_test: {url_to_test}")
  logging.info(f"proxy_vm_ip: {proxy_vm_ip}")
  logging.info(f"proxy_vm_port: {proxy_vm_port}")
  make_api_request(url_to_test, proxy_vm_ip, proxy_vm_port)

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

%%writefile Dockerfile
FROM python:3.9-slim

RUN apt-get update && \
  apt-get install -y iputils-ping && \
  apt-get install -y wget

RUN pip install cloudml-hypertune requests kfp

COPY main.py /main.py

ENTRYPOINT ["python3", "/main.py"]

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

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

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

IMAGE_PROJECT = PROJECT_ID
IMAGE_REPO = 'pipelines-test-repo-psc' 
IMAGE_NAME = 'nonrfc-ip-call'
TAG = 'v1'

IMAGE_URI= f'us-central1-docker.pkg.dev/{IMAGE_PROJECT}/{IMAGE_REPO}/{IMAGE_NAME}:{TAG}'
IMAGE_URI

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

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

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं. अगर गड़बड़ी (gcloud.builds.submit) मौजूद है, तो उसे अनदेखा करें.

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

अपनी JupyterLab नोटबुक में, यहां दी गई सेल बनाएं और उसे चलाएं. साथ ही, इन हाइलाइट पर ध्यान दें:

  • उपयोगकर्ता के वीपीसी से डीएनएस पियरिंग को, demo.com डोमेन नेम के लिए dnsPeeringConfigs (dnsPeeringConfigs) का इस्तेमाल करके कॉन्फ़िगर किया जाता है.
  • एक्सप्लिसिट प्रॉक्सी को PROXY_VM_IP वैरिएबल के तौर पर तय किया गया है. यह proxy-vm.demo.com है. रिज़ॉल्यूशन को, उपभोक्ता के वीपीसी में डीएनएस पियरिंग के ज़रिए मैनेज किया जाता है.
  • पोर्ट 8888, tinyproxy में कॉन्फ़िगर किया गया लिसनिंग पोर्ट (डिफ़ॉल्ट) है
  • class-e-vm-demo.com के लिए Wget को डीएनएस पियरिंग के ज़रिए हल किया जाता है
  • इस कोड में Vertex के लिए "psc-network-attachment" के बारे में बताया गया है. इससे Vertex, नेटवर्क अटैचमेंट सबनेट का इस्तेमाल करके दो पीएससी इंटरफ़ेस इंस्टेंस डिप्लॉय कर पाता है.
import json
from datetime import datetime


JOB_ID_PREFIX='test_psci-nonRFC' #@param {type:"string"}
JOB_ID = '{}_{}'.format(JOB_ID_PREFIX, datetime.now().strftime("%Y%m%d%H%M%S"))

# PSC-I configs

PRODUCER_PROJECT_ID = PROJECT_ID
DNS_DOMAIN = 'class-e-vm.demo.com' #@param {type:"string"}
NON_RFC_URL = f"http://{DNS_DOMAIN}"

PROXY_VM_IP = "proxy-vm.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8888" #@param {type:"string"}

CUSTOM_JOB = {
  "display_name": JOB_ID,
  "job_spec": {
      "worker_pool_specs": [
          {
           "machine_spec": {
             "machine_type": "n1-standard-4",
           },
           "replica_count": 1,
           "container_spec": {
             "image_uri": IMAGE_URI,
             "env": [{
               "name": "NONRFC_URL",
               "value": NON_RFC_URL
             },
             {
               "name": "PROXY_VM_IP",
               "value": PROXY_VM_IP
             },
             {
               "name": "PROXY_VM_PORT",
               "value": PROXY_VM_PORT
             }]
           },
         },
      ],
      "enable_web_access": True,
      "psc_interface_config": {
        "network_attachment": "psc-network-attachment",
        "dns_peering_configs": [
          {
            "domain": "demo.com.",
            "target_project": PROJECT_ID,
            "target_network": "consumer-vpc"
          },
        ]
      },
  }
}

print(json.dumps(CUSTOM_JOB, indent=2))

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

import requests
bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/customJobs/"

print("request_uri: ", request_uri)

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

response_autopush = requests.post(request_uri, json=CUSTOM_JOB, headers=headers)
response = response_autopush
print("response:", response)
if response.reason == 'OK':
  job_name = response.json()['name']
  job_id = job_name.split('/')[-1]
  print("Created Job: ", response.json()['name'])
else:
  print(response.text)

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

# Print KFP SDK version (should be >= 1.6)
! python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

# Print AI Platform version
! python3 -c "from google.cloud import aiplatform; print('AI Platform version: {}'.format(aiplatform.__version__))"

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

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

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

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

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

# pipeline parameters
CACHE_PIPELINE = False # @param {type: "string"}
_DEFAULT_IMAGE = IMAGE_URI
BUCKET_URI = "gs://{BUCKET_URI}"  # @param {type: "string"}
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/intro"
PIPELINE_DISPLAY_NAME = "pipeline_nonRFCIP" # @param {type: "string"}

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

from re import S
import kfp
from kfp import dsl
from kfp.dsl import container_component, ContainerSpec
from kfp import compiler
from google.cloud import aiplatform


# ==== Component with env variable ====

@container_component
def dns_peering_test_op(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    return ContainerSpec(
        image=_DEFAULT_IMAGE,
        command=["bash", "-c"],
        args=[
            """
            apt-get update && apt-get install inetutils-traceroute inetutils-ping netcat-openbsd curl -y

            echo "Local IP(s): $(hostname -I)"

            echo "Attempting to trace route to %s"
            traceroute -w 1 -m 7 "%s"

            echo "Sending curl requests to http://%s via proxy %s:%s and recording trace..."
            if curl -L -v --trace-ascii /dev/stdout -x http://%s:%s "http://%s"; then
                echo "Curl request succeeded!"
            else
                echo "Curl request failed!"
                exit 1
            fi
            """ % (dns_domain, dns_domain, dns_domain, proxy_vm_ip, proxy_vm_port, proxy_vm_ip, proxy_vm_port, dns_domain)

        ]
    )

# ==== Pipeline ====
@dsl.pipeline(
    name="dns-peering-test-pipeline",
    description="Test DNS Peering using env variable",
    pipeline_root=PIPELINE_ROOT,
)
def dns_peering_test_pipeline(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    dns_test_task = dns_peering_test_op(dns_domain=dns_domain, proxy_vm_ip=proxy_vm_ip, proxy_vm_port=proxy_vm_port)
    dns_test_task.set_caching_options(enable_caching=CACHE_PIPELINE)

# ==== Compile pipeline ====
if __name__ == "__main__":
    aiplatform.init(project=PROJECT_ID, location=LOCATION)

    compiler.Compiler().compile(
        pipeline_func=dns_peering_test_pipeline,
        package_path="dns_peering_test_pipeline.yaml",
    )
    print("✅ Pipeline compiled to dns_peering_test_pipeline.yaml")

JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं.

# Define the PipelineJob body; see API Reference https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.pipelineJobs/create

import requests, json
import datetime

bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/pipelineJobs/"

print("request_uri: ", request_uri)

14. पीएससी इंटरफ़ेस की पुष्टि

Vertax AI Pipelines में इस्तेमाल किए गए नेटवर्क अटैचमेंट आईपी भी देखे जा सकते हैं. इसके लिए, यहां जाएं:

नेटवर्क सेवाएं → Private Service Connect → नेटवर्क अटैचमेंट → psc-network-attachment

किरायेदार प्रोजेक्ट चुनें (प्रोजेक्ट का नाम -tp पर खत्म होता है)

f47150235fedb8ce.png

हाइलाइट किया गया फ़ील्ड, पीएससी नेटवर्क अटैचमेंट से Vertex AI Pipelines के इस्तेमाल किए गए आईपी पते को दिखाता है.

39e7b251aeb4f191.png

15. Cloud Logging की पुष्टि करना

Vertex AI Pipelines का जॉब पहली बार चलाने में करीब 14 मिनट लगेंगे. इसके बाद, इसे चलाने में कम समय लगेगा. यह पुष्टि करने के लिए कि नतीजे सही हैं, यह तरीका अपनाएं:

Vertex AI → ट्रेनिंग → कस्टम जॉब पर जाएं

लागू की गई कस्टम जॉब चुनें

a9be0395c842aa6f.png

'लॉग देखें' चुनें

53e30765ba5827f3.png

Cloud Logging उपलब्ध होने के बाद, 'क्वेरी चलाएं' को चुनें. इससे हाइलाइट किया गया यह विकल्प जनरेट होगा. इससे पुष्टि होगी कि Vertex AI Pipelines से class-e-vm तक wget की प्रोसेस पूरी हो गई है.

f2c5d9fdf5cc8bed.png

3b3788603bb433ee.png

16. TCPDump की पुष्टि करना

आइए, टीसीपीडंप आउटपुट की समीक्षा करें. इससे कंप्यूट इंस्टेंस से कनेक्टिविटी की पुष्टि होती है:

प्रॉक्सी-वीएम से, एचटीटीपी GET और 200 OK को मॉनिटर करें

03:05:34.778574 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778946 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.778974 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781999 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906678 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

class-e-vm से, एचटीटीपी GET और 200 OK को मॉनिटर करें

03:05:34.778768 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778819 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.781815 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781856 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906503 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

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

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

gcloud compute instances delete proxy-vm --zone=us-central1-a --quiet

gcloud compute instances delete workbench-tutorial --zone=us-central1-a --quiet

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

gcloud compute network-attachments delete psc-network-attachment --region=us-central1 --quiet

gcloud compute networks subnets delete intf-subnet rfc1918-subnet1 --region=us-central1 --quiet

gcloud dns record-sets delete class-e-vm.demo.com --zone=private-dns-codelab  --type=A
gcloud dns record-sets delete proxy-vm.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab
gcloud compute networks delete consumer-vpc --quiet

18. बधाई हो

बधाई हो, आपने Vertex AI Pipelines के साथ Private Service Connect इंटरफ़ेस को कॉन्फ़िगर और पुष्टि कर लिया है.

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

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

c911c127bffdee57.jpeg

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

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

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