Vertex AI Pipelines PSC Interface SWP

1. परिचय

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

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

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

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

d7dc28d6567e6283.pngइमेज:1

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

  • Vertex AI PSC-Interface, RFC1918 पते के ब्लॉक में मौजूद वीपीसी या ऑन-प्रिमाइसेस में, ट्रैफ़िक को डेस्टिनेशन तक रूट कर सकता है.
  • RFC-1918 के अलावा किसी अन्य पते के ब्लॉक को टारगेट करने वाले पीएससी-इंटरफ़ेस के लिए, उपभोक्ता के वीपीसी में RFC-1918 पते के साथ एक प्रॉक्सी डिप्लॉय करना ज़रूरी है. Vertex AI डिप्लॉयमेंट में, प्रॉक्सी को टारगेट एंडपॉइंट के FQDN के साथ तय किया जाना चाहिए. पहले फ़िगर में, उपभोक्ता वीपीसी में कॉन्फ़िगर किया गया एक्सप्लिसिट प्रॉक्सी मोड वाला Secure Web proxy (SWP) दिखाया गया है. इससे, नीचे दिए गए नॉन RFC-1918 CIDR पर राउटिंग की जा सकती है:
  1. 240.0.0.0/4
  2. 203.0.113.0/24
  3. 10.10.20.0/28 के लिए प्रॉक्सी की ज़रूरत नहीं है. यह RFC-1918 की रेंज में आता है.
  4. इंटरनेट इग्रेस

Google के मैनेज किए गए किरायेदार नेटवर्क के लिए इंटरनेट कनेक्शन:

VPC-SC के बिना Vertex AI PSC-Interface

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

VPC-SC के साथ Vertex AI PSC-Interface

  • जब आपका प्रोजेक्ट, वीपीसी सर्विस कंट्रोल के पेरीमीटर का हिस्सा होता है, तब Google-मैनेज किए गए किरायेदार के डिफ़ॉल्ट इंटरनेट ऐक्सेस को पेरीमीटर ब्लॉक कर देता है. ऐसा डेटा को बाहर जाने से रोकने के लिए किया जाता है.
  • इस स्थिति में, डिप्लॉयमेंट को सार्वजनिक इंटरनेट ऐक्सेस करने की अनुमति देने के लिए, आपको सुरक्षित इग्रेस पाथ को साफ़ तौर पर कॉन्फ़िगर करना होगा. यह पाथ, Vertex AI से कनेक्ट किए गए आपके वीपीसी के ज़रिए ट्रैफ़िक को रूट करता है. इसे हासिल करने का एक तरीका यह है कि RFC 1918 पते के साथ वीपीसी नेटवर्क में प्रॉक्सी सर्वर डिप्लॉय किया जाए. साथ ही, इसे Cloud NAT गेटवे के साथ जोड़ा जाए. ध्यान दें कि इंटरनेट पर ट्रैफ़िक फ़ॉरवर्ड करने के लिए, सुरक्षित वेब प्रॉक्सी का भी इस्तेमाल किया जा सकता है. Secure Web Proxy बनाने पर, Cloud NAT गेटवे अपने-आप बन जाता है.

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

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

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

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

2d095dc2f4de6b4b.pngदूसरी इमेज

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

Vertex AI Pipelines को डिप्लॉय करें और Secure Web Proxy को एक्सप्लिसिट प्रॉक्सी मोड में कॉन्फ़िगर करें. इससे, क्लास E सबनेट में मौजूद वर्चुअल मशीन के ख़िलाफ़ wget कार्रवाई की जा सकेगी.

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

  • नेटवर्क अटैचमेंट बनाने का तरीका
  • कोई प्रोड्यूसर, पीएससी इंटरफ़ेस बनाने के लिए नेटवर्क अटैचमेंट का इस्तेमाल कैसे कर सकता है
  • Google के मैनेज किए गए वीपीसी नेटवर्क से, उपभोक्ता वीपीसी नेटवर्क में कॉन्फ़िगर किए गए निजी डोमेन को हल करने के लिए, डीएनएस पियरिंग कैसे सेट अप करें
  • Vertex AI PSC इंटरफ़ेस से Secure Web Proxy पर ट्रैफ़िक को फ़ॉरवर्ड करने का तरीका
  • Vertex AI Pipelines से, RFC-1918 के अलावा दूसरे आईपी पते के स्पेस से कम्यूनिकेट करने का तरीका

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

Google Cloud प्रोजेक्ट

IAM अनुमतियां

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

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

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

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

gcloud config list project
gcloud config set project [YOUR-PROJECT-ID]
projectid=YOUR-PROJECT-ID
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"
gcloud services enable "networkservices.googleapis.com"
gcloud services enable "networksecurity.googleapis.com"
gcloud services enable "certificatemanager.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 --enable-private-ip-google-access

सिर्फ़ प्रॉक्सी के लिए सबनेट बनाना

gcloud compute networks subnets create proxy-only-uscentral1 \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-central1 \
    --network=consumer-vpc \
    --range=10.10.100.0/26

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 \
--enable-private-ip-google-access

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

Google Cloud Secure Web Proxy, उस इलाके में Cloud NAT गेटवे और उससे जुड़े Cloud Router को अपने-आप सेट अप और मैनेज करता है जहां इसे डिप्लॉय किया गया है.

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 \ 
    --private-network-ip=240.0.0.2

6. Secure Web Proxy

Secure Web Proxy का एक्सप्लिसिट मोड (या एक्सप्लिसिट प्रॉक्सी राउटिंग मोड), डिप्लॉयमेंट का एक ऐसा तरीका है जिसमें क्लाइंट के वर्कलोड को साफ़ तौर पर कॉन्फ़िगर किया जाना चाहिए, ताकि वे SWP के इंटरनल आईपी पते या पूरी तरह क्वालिफ़ाइड डोमेन नेम और पोर्ट का इस्तेमाल, फ़ॉरवर्डिंग प्रॉक्सी के तौर पर कर सकें.

यहां दिए गए चरणों में, YOUR-PROJECT-ID को अपने प्रोजेक्ट आईडी में बदलना न भूलें

वेब प्रॉक्सी बनाना:

Cloud Shell में, टेक्स्ट एडिटर का इस्तेमाल करके policy.yaml फ़ाइल बनाएं:

cat > policy.yaml << EOF
description: basic Secure Web Proxy policy
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
EOF

Cloud Shell में, Secure Web Proxy की नीति जनरेट करें:

gcloud network-security gateway-security-policies import policy1 \
    --source=policy.yaml \
    --location=us-central1

यहां दिए गए सेक्शन में, होस्ट sessionMatcher के आधार पर class-e-vm को ऐक्सेस करने की अनुमति देने के लिए एक नियम बनाएं.

Cloud Shell में, टेक्स्ट एडिटर का इस्तेमाल करके rule1.yaml फ़ाइल बनाएं:

cat > rule1.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-nonrfc-classe
description: Allow nonrfc class-e
enabled: true
priority: 1
basicProfile: ALLOW
sessionMatcher: host() == 'class-e-vm.demo.com'
EOF

नीचे दिए गए सेक्शन में, एक नियम बनाएं. इससे Jupyter Notebook को "class-e" वीएम पर apache2 इंस्टॉल करने की अनुमति मिलेगी.

Cloud Shell में, टेक्स्ट एडिटर का इस्तेमाल करके rule2.yaml फ़ाइल बनाएं:

cat > rule2.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-apache2
description: Allow Apache2 install on class-e VM
enabled: true
priority: 2
basicProfile: ALLOW
sessionMatcher: inIpRange(source.ip,'240.0.0.2')
EOF

Cloud Shell में, सुरक्षा नीति का पहला नियम जनरेट करें:

gcloud network-security gateway-security-policies rules import allow-nonrfc-classe \
    --source=rule1.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Cloud Shell में, सुरक्षा नीति का दूसरा नियम जनरेट करें:

gcloud network-security gateway-security-policies rules import allow-apache2 \
    --source=rule2.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Vertex AI Training के साथ काम करने के लिए, Secure Web Proxy गेटवे को इन सेटिंग के साथ कॉन्फ़िगर करें:

  • लिसनिंग पोर्ट: Vertex AI ऐप्लिकेशन के कोड में कॉन्फ़िगर किए गए उसी पोर्ट का इस्तेमाल करें. जैसे, 8080.
  • पता: RFC 1918 रेंज से कोई निजी आईपी पता असाइन करें.
  • रूटिंग मोड: इसे EXPLICIT_ROUTING_MODE पर सेट करें

Cloud Shell में, Secure Web Proxy गेटवे को तय करने के लिए, gateway.yaml फ़ाइल बनाएं:

cat > gateway.yaml << EOF
name: projects/$projectid/locations/us-central1/gateways/swp1
type: SECURE_WEB_GATEWAY
addresses: ["10.10.10.5"]
ports: [8080]
gatewaySecurityPolicy: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
network: projects/$projectid/global/networks/consumer-vpc
subnetwork: projects/$projectid/regions/us-central1/subnetworks/rfc1918-subnet1
routingMode: EXPLICIT_ROUTING_MODE
EOF

Cloud Shell में, Secure Web Proxy इंस्टेंस जनरेट करें:

gcloud network-services gateways import swp1 \
    --source=gateway.yaml \
    --location=us-central1

सुरक्षित वेब प्रॉक्सी को डिप्लॉय होने में कुछ मिनट लग सकते हैं.

e8a4cf23bfc63030.png

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

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

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

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

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

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

b969cca5242d9c8a.png

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

आपको 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 में, वीएम के लिए रिकॉर्ड सेट बनाएं, 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 में, Secure Web Proxy के लिए रिकॉर्ड सेट बनाएं. साथ ही, यह पक्का करें कि आपने अपने एनवायरमेंट के आउटपुट के आधार पर आईपी पते को अपडेट किया हो.

gcloud dns --project=$projectid record-sets create explicit-swp.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.5"

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

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

Cloud Shell में, इन्ग्रेस फ़ायरवॉल का ऐसा नियम बनाएं जो प्रॉक्सी-ओनली सबनेट से क्लास-ई सबनेट को ऐक्सेस करने की अनुमति देता हो. ऐसा इसलिए होता है, क्योंकि SWP, सोर्स पते के तौर पर सिर्फ़ प्रॉक्सी वाले सबनेट से कनेक्शन शुरू करता है.

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.100.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

9. Jupyter Notebook बनाना

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

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

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

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

Cloud Shell में लॉगिन करें और यह तरीका अपनाएं;

सेवा खाता बनाएं.

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

सेवा खाते को स्टोरेज एडमिन की भूमिका असाइन करें.

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

सेवा खाते को AI Platform User की भूमिका असाइन करें.

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

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

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

सेवा खाते को Cloud Build Editor की भूमिका के साथ अपडेट करें.

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

नोटबुक के सेवा खाते को 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 इंस्टेंस बनाना

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

Cloud Shell में, निजी क्लाइंट इंस्टेंस बनाएं.

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 Console में Vertex AI पर जाएं. इससे यह पक्का किया जा सकेगा कि Vertex AI API चालू है.

Cloud Shell में:

अपना प्रोजेक्ट नंबर पाएं.

gcloud projects describe $projectid | grep projectNumber

अपना प्रोजेक्ट नंबर सेट करें.

projectnumber=YOUR-PROJECT-NUMBER

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

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

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

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

सर्विस एजेंट खाते को 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"

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

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

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

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

12. ‘class-e-vm' पर Apache2 इंस्टॉल करें और Tcpdump चालू करें:

class-e-vm से, Secure Web Proxy के ज़रिए apache2 इंस्टॉल करें:

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

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

sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" update
sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" install apache2 -y
sudo service apache2 restart
echo 'class-e Server !!' | sudo tee /var/www/html/index.html

सिर्फ़ प्रॉक्सी वाले सबनेट पर tcpdump फ़िल्टरिंग लागू करें. इसका इस्तेमाल Secure Web Proxy, ट्रैफ़िक को टारगेट तक फ़ॉरवर्ड करने के लिए करता है.

क्लास-ई-वीएम ओएस से, प्रॉक्सी-वीएम सबनेट पर tcpdump फ़िल्टर करने का अनुरोध किया गया है..

sudo tcpdump -i any net 10.10.100.0/24 -nn

ध्यान दें: JupyterLab सेशन खोलने के लिए, पक्का करें कि आपने वर्कबेंच-ट्यूटोरियल इंस्टेंस सबनेट पर Private Google Access चालू किया हो.

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

यहां दिए गए सेक्शन में, आपको एक नोटबुक बनानी होगी. इससे, एक्सप्लिसिट प्रॉक्सी से Vertex AI Pipelines में wget किया जा सकेगा. इससे, RFC 1918 के अलावा अन्य वीएम तक पहुंचा जा सकता है. जैसे, class-e-vm. Vertex AI Pipelines को rfc1918-vm ऐक्सेस करने के लिए, एक्सप्लिसिट प्रॉक्सी की ज़रूरत नहीं होती, क्योंकि इसका टारगेट 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 नोटबुक में, एक नई सेल बनाएं. इसके बाद, इसे अपडेट करें और चलाएं. पक्का करें कि आपने 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://explicit-swp.demo.com:8080"
  • एफ़क्यूडीएन, उपभोक्ता के वीपीसी में डिप्लॉय किए गए प्रॉक्सी वीएम से जुड़ा होता है. हम बाद के चरण में एफ़क्यूडीएन को हल करने के लिए, डीएनएस पियरिंग का इस्तेमाल कर रहे हैं.
%%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 nonRFC-1918 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://explicit-swp.demo.com:8080" # replace it with your Secure Web proxy Ip-address and the 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) का इस्तेमाल करके कॉन्फ़िगर किया जाता है.
  • यहां वेब प्रॉक्सी के लिए, साफ़ तौर पर रूटिंग मोड explicit-swp.demo.com है. रिज़ॉल्यूशन को उपभोक्ता के वीपीसी में डीएनएस पियरिंग के ज़रिए हैंडल किया जाता है.
  • पोर्ट 8080, Secure Web Proxy में कॉन्फ़िगर किया गया लिसनिंग पोर्ट (डिफ़ॉल्ट) है
  • wget को class-e-vm-demo.com पर डीएनएस पियरिंग के ज़रिए हल किया जाता है
  • इस कोड में 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 = "explicit-swp.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8080" #@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 पर खत्म होता है)

a2e0b6d6243f26f1.png

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

11e411ea919d3bad.png

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

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

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

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

2f467254aa0c2e3a.png

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

8d525d3b152bcc61.png

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

a4f9e9167f4ce1ae.png

38972f834aa2bd1d.png

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

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

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

XXXXXXXXX@class-e-vm:~$ sudo tcpdump -i any net 10.10.100.0/28 -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
05:51:14.173641 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [S], seq 1747181041, win 65535, options [mss 1420,sackOK,TS val 3942828403 ecr 0,nop,wscale 8], length 0
05:51:14.173668 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [S.], seq 3013226100, ack 1747181042, win 64768, options [mss 1420,sackOK,TS val 1886125065 ecr 3942828403,nop,wscale 7], length 0
05:51:14.174977 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [.], ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 0
05:51:14.175066 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [P.], seq 1:223, ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 222: HTTP: GET / HTTP/1.1
05:51:14.175096 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [.], ack 223, win 505, options [nop,nop,TS val 1886125066 ecr 3942828405], length 0
05:51:14.239042 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [P.], seq 1:246, ack 223, win 505, options [nop,nop,TS val 1886125130 ecr 3942828405], length 245: HTTP: HTTP/1.1 200 OK

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

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

gcloud workbench instances delete workbench-tutorial --project=$projectid --location=us-central1-a

gcloud network-security gateway-security-policies rules delete allow-nonrfc-classe \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies rules delete allow-apache2 \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies delete policy1 \
    --location=us-central1
gcloud network-services gateways delete swp1 \
    --location=us-central1

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 explicit-swp.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab

gcloud computeinstances delete class-e-vm --project=$projectid --zone=us-central1-a --quiet
gcloud compute networks delete consumer-vpc --quiet

18. बधाई हो

बधाई हो, आपने Secure Web Proxy के ज़रिए, Vertex AI Pipelines Private Service Connect इंटरफ़ेस और नॉन RFC आईपी रेंज के बीच कनेक्शन को कॉन्फ़िगर और पुष्टि कर लिया है.

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

678ba30d64a76795.png

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

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

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