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

Agent Engine PSC Explicit Proxy

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

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

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

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

एजेंट डिप्लॉय करना | Vertex AI में जनरेटिव एआई | Google Cloud

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

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

इस ट्यूटोरियल में, आपको Private Service Connect (PSC) इंटरफ़ेस के साथ डिप्लॉय किया गया एक एजेंट इंजन बनाना है. इससे, RFC1918 पते के साथ उपभोक्ता के वीपीसी में डिप्लॉय की गई प्रॉक्सी वीएम के ज़रिए, सार्वजनिक साइट (https://api.frankfurter.app/) से कनेक्ट किया जा सकेगा. डप्लॉयमेंट का यह उदाहरण, VPC-SC की सुविधा वाले प्रोजेक्ट पर लागू होता है. इसके अलावा, यह उन एडमिन के लिए भी लागू होता है जिन्हें किरायेदार के वीपीसी के बजाय, ग्राहक के नेटवर्क के ज़रिए इंटरनेट से बाहर निकलने की ज़रूरत होती है.

इमेज 1

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

एजेंट इंजन को डिप्लॉय करना और प्रॉक्सी वीएम को एक्सप्लिसिट प्रॉक्सी के तौर पर कॉन्फ़िगर करना. इससे, एजेंट इंजन को सार्वजनिक यूआरएल https://api.frankfurter.app पर पहुंचने की अनुमति मिलती है

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

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

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

Google Cloud प्रोजेक्ट

IAM अनुमतियां

Compute Network Admin (roles/compute.networkAdmin)
कंप्यूट इंस्टेंस एडमिन (roles/compute.instanceAdmin)
कंप्यूट सिक्योरिटी एडमिन (roles/compute.securityAdmin)
डीएनएस एडमिन (roles/dns.admin)
IAP-secured Tunnel User (roles/iap.tunnelResourceAccessor)
लॉगिंग एडमिन (roles/logging.admin)
Notebooks एडमिन (roles/notebooks.admin)
प्रोजेक्ट के लिए आईएएम एडमिन (roles/resourcemanager.projectIamAdmin)
सेवा खाते का एडमिन (roles/iam.serviceAccountAdmin)
Service Usage Admin (roles/serviceusage.serviceUsageAdmin)

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 "iap.googleapis.com"

पुष्टि करें कि एपीआई चालू हो गए हैं

gcloud services list --enabled

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

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

यह वीपीसी, ग्राहक के प्रोजेक्ट में मौजूद होता है. इस वीपीसी में ये संसाधन बनाए जाएंगे

उपभोक्ता सबनेट
नेटवर्क अटैचमेंट सबनेट
Cloud Router (Cloud NAT के लिए ज़रूरी है)
Cloud NAT

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

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

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

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 में, Cloud Router बनाएं.

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

Cloud Shell में, लॉगिंग की सुविधा चालू करके NAT गेटवे बनाएं. हम लॉगिंग का इस्तेमाल करके, Frankfurter API (https://api.frankfurter.app/) के लिए सार्वजनिक आईपी के ऐक्सेस की पुष्टि करेंगे.

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 में, उपभोक्ता VM इंस्टेंस, proxy-vm बनाएं. यह एजेंट इंजन के लिए एक्सप्लिसिट प्रॉक्सी के तौर पर काम करेगा. हम एचटीटीपी ट्रैफ़िक को प्रॉक्सी करने के लिए, ऐप्लिकेशन के तौर पर tinyproxy का इस्तेमाल करेंगे.

gcloud compute instances create proxy-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --can-ip-forward \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=rfc1918-subnet1 \
    --shielded-secure-boot \
    --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 नोट करें. इसका इस्तेमाल प्रोड्यूसर, Private Service Connect इंटरफ़ेस बनाते समय करेगा.

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

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

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

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

Cloud Shell में, यहां दिया गया तरीका अपनाएं. इससे demo.com नाम का डीएनएस बनाया जा सकेगा.

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

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

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

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 फ़ायरवॉल का नियम बनाएं

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

Cloud Shell में, इन्ग्रेस फ़ायरवॉल नियम बनाएं.

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

8. Jupyter Notebook बनाना

यहां दिए गए सेक्शन में, Jupyter Notebook बनाने का तरीका बताया गया है. इस नोटबुक का इस्तेमाल, इंटरनेट इग्रेस के लिए एक्सप्लिसिट प्रॉक्सी को टारगेट करने वाले एजेंट इंजन को डिप्लॉय करने के लिए किया जाएगा.

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

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

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

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

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

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

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

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

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

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

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

Cloud Shell में, नोटबुक सेवा खाते को Compute Engine के डिफ़ॉल्ट सेवा खाते का इस्तेमाल करने की अनुमति दें.

gcloud iam service-accounts add-iam-policy-binding \
    $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')-compute@developer.gserviceaccount.com \
    --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

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

नीचे दिए गए सेक्शन में, आपको एक्सप्लिसिट प्रॉक्सी में एसएसएच करना होगा. इसके बाद, 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

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 में, अपना प्रोजेक्ट नंबर सेट करें.

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"

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

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

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

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

12. प्रॉक्सी वीएम Tcpdump

Agent Engine से आईपी कनेक्टिविटी की पुष्टि करने के लिए, हम TCPDUMP का इस्तेमाल कर सकते हैं. इससे हमें PSC नेटवर्क अटैचमेंट सबनेट, 192.168.10.0/28 से होने वाले कम्यूनिकेशन को मॉनिटर करने में मदद मिलेगी. ऐसा तब होगा, जब एजेंट इंजन से सार्वजनिक यूआरएल पर get अनुरोध किया जाएगा.

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

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

प्रॉक्सी-वीएम ओएस से tcpdump को एक्ज़ीक्यूट करें.

sudo tcpdump -i any net 192.168.10.0/28 -nn

13. एजेंट इंजन डिप्लॉय करना

ध्यान दें: इस सेक्शन में दिए गए टास्क पूरे करने के लिए, हम GCP Console और JupyterLab नोटबुक का इस्तेमाल करेंगे

नीचे दिए गए सेक्शन में, एक ऐसी नोटबुक बनाई जाएगी जो ये काम करेगी:

यह कुकी, विनिमय दर का डेटा पाने के लिए Frankfurter API (https://api.frankfurter.app/) का इस्तेमाल करती है
यह नीति, प्रॉक्सी-वीएम को टारगेट करने वाले किसी प्रॉक्सी सर्वर (proxy_server) का रेफ़रंस देती है. यह प्रॉक्सी सर्वर, FQDN proxy-vm.demo.com का इस्तेमाल करके, उपभोक्ताओं के वीपीसी में मौजूद होता है
dnsPeeringConfigs "domain": "demo.com." को परिभाषित करें

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

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

ज़रूरी Python लाइब्रेरी इंस्टॉल करें: Agent Engine के लिए ज़रूरी लाइब्रेरी इंस्टॉल करें. इनमें pyyaml, google-cloud-aiplatform, cloudpickle, google-cloud-api-keys, और langchain-google-vertexai शामिल हैं.

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

!pip install pyyaml
!pip install google-cloud-aiplatform[agent_engines,langchain]==1.96.0
!pip install cloudpickle==3.1.1
!pip install google-cloud-api-keys
!pip install langchain-google-vertexai==2.0.24

Jupyter Notebook कर्नल को फिर से चालू करें: इससे यह पक्का किया जा सकेगा कि नई इंस्टॉल की गई लाइब्रेरी सही तरीके से लोड हो गई हैं.

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

# Restart the notebook kernel after install, so you can run langchain successfully.

import IPython

app = IPython.Application.instance()
app.kernel.do_shutdown(True)

प्रोजेक्ट और बकेट वैरिएबल सेट करें: अपने Google Cloud प्रोजेक्ट आईडी, प्रोजेक्ट नंबर, सेवा का नाम, GCS डायरेक्ट्री, एंडपॉइंट, बकेट का नाम, और जगह तय करें.

सेल चलाने से पहले, यहां दिए गए फ़ील्ड अपडेट करें

PROJECT_ID = "enter-your-projectid"
PROJECT_NUMBER = "enter-your-projectnumber"
BUCKET= "enter-a-unique-bucket-name"

ध्यान दें: हम अगले चरण में, Cloud Storage बकेट बनाने के लिए BUCKET वैरिएबल का इस्तेमाल करेंगे.

JupyterLab नोटबुक में, एक नई सेल बनाएं. इसके बाद, इसे अपडेट करें और चलाएं.

PROJECT_ID = "enter-your-projectid"  #@param {type:"string"}
PROJECT_NUMBER = "enter-your-projectnumber"  #@param {type:"string"}
SERVICE_NAME = "aiplatform"  #@param ["autopush-aiplatform", "staging-aiplatform", "aiplatform"]
# @markdown  Specify where your agent code should be written in GCS:
GCS_DIR = "reasoning-engine-test"  #@param {type:"string"}
ENDPOINT = "https://us-central1-aiplatform.googleapis.com" # @param ["https://us-central1-aiplatform.googleapis.com", "https://us-central1-autopush-aiplatform.sandbox.googleapis.com", "https://us-central1-staging-aiplatform.sandbox.googleapis.com"]
BUCKET= "enter-a-unique-bucket-name" #@param {type:"string"}
LOCATION="us-central1" #@param {type:"string"}

GCS बकेट बनाएं: एजेंट कोड को सेव करने के लिए, Cloud Storage बकेट बनाएं.

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

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

नेटवर्क अटैचमेंट का नाम तय करें: अपने Private Service Connect नेटवर्क अटैचमेंट का नाम डालें.

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

NETWORK_ATTACHMENT_NAME = 'psc-network-attachment' #@param {type:"string"}

Python क्लाइंट लाइब्रेरी शुरू करना: Google Cloud सेवाओं के लिए ज़रूरी क्लाइंट लाइब्रेरी सेट अप करें.

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

import json
import pprint

import cloudpickle
from google import auth as google_auth
from google.auth.transport import requests as google_requests
from google.cloud import storage
import yaml


def get_identity_token():
    """Gets ID token for calling Cloud Run."""
    credentials, _ = google_auth.default()
    auth_request = google_requests.Request()
    credentials.refresh(auth_request)
    return credentials.id_token

if not GCS_DIR or "your_ldap" in GCS_DIR:
    raise ValueError("GCS_DIR must be set or you must set your ldap.")

if not PROJECT_ID:
    raise ValueError("PROJECT_ID must be set.")


client = storage.Client(project=PROJECT_ID)
bucket = client.get_bucket(BUCKET)

एजेंट और टूल कॉन्फ़िगर करना: StreamingAgent क्लास और get_exchange_rate फ़ंक्शन को तय करें. इससे, एक्सप्लिसिट प्रॉक्सी के ज़रिए Frankfurter API का इस्तेमाल करके, मुद्रा विनिमय दरें फ़ेच की जा सकती हैं.

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

get_exchange_rate फ़ंक्शन, मुद्रा बदलने की दर का डेटा पाने के लिए Frankfurter API (https://api.frankfurter.app/) का इस्तेमाल करेगा.
proxy_server = "http://proxy-vm.demo.com:8888" FQDN, उपभोक्ता के वीपीसी में डिप्लॉय किए गए प्रॉक्सी वीएम से जुड़ा होता है. हम बाद के चरण में एफ़क्यूडीएन को हल करने के लिए, डीएनएस पियरिंग का इस्तेमाल कर रहे हैं.

from langchain_google_vertexai import ChatVertexAI
from langchain.agents import AgentExecutor
from langchain.agents.format_scratchpad.tools import format_to_tool_messages
from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
from langchain.tools.base import StructuredTool
from langchain_core import prompts
from re import S
from typing import Callable, Sequence
import google.auth
import vertexai


class StreamingAgent:

    def __init__(
            self,
            model: str,
            tools: Sequence[Callable],
            project_id: str,
        ):
        self.model_name = model
        self.tools = tools
        self.project_id = project_id

    def set_up(self):
        """All unpickle-able logic should go here.

        The .set_up() method should not be called for an object that is being
        prepared for deployment.
        """
        creds, _ = google.auth.default(quota_project_id=self.project_id)
        vertexai.init(project=self.project_id, location="us-central1", credentials=creds)

        prompt = {
            "input": lambda x: x["input"],
            "agent_scratchpad": (
                lambda x: format_to_tool_messages(x["intermediate_steps"])
            ),
        } | prompts.ChatPromptTemplate.from_messages([
            ("user", "{input}"),
            prompts.MessagesPlaceholder(variable_name="agent_scratchpad"),
        ])

        llm = ChatVertexAI(model_name=self.model_name)
        if self.tools:
            llm = llm.bind_tools(tools=self.tools)

        self.agent_executor = AgentExecutor(
            agent=prompt | llm | ToolsAgentOutputParser(),
            tools=[StructuredTool.from_function(tool) for tool in self.tools],
        )

    def query(self, input: str):
        """Query the application.

        Args:
            input: The user prompt.

        Returns:
            The output of querying the application with the given input.
        """
        return self.agent_executor.invoke(input={"input": input})

    def stream_query(self, input: str):
        """Query the application and stream the output.

        Args:
            input: The user prompt.

        Yields:
            Chunks of the response as they become available.
        """
        for chunk in self.agent_executor.stream(input={"input": input}):
            yield chunk

def get_exchange_rate(
    currency_from: str = "USD",
    currency_to: str = "EUR",
    currency_date: str = "latest",
):
    """Retrieves the exchange rate between two currencies on a specified date.

    Uses the Frankfurter API (https://api.frankfurter.app/) to obtain
    exchange rate data.

    Args:
        currency_from: The base currency (3-letter currency code).
            Defaults to "USD" (US Dollar).
        currency_to: The target currency (3-letter currency code).
            Defaults to "EUR" (Euro).
        currency_date: The date for which to retrieve the exchange rate.
            Defaults to "latest" for the most recent exchange rate data.
            Can be specified in YYYY-MM-DD format for historical rates.

    Returns:
        dict: A dictionary containing the exchange rate information.
            Example: {"amount": 1.0, "base": "USD", "date": "2023-11-24",
                "rates": {"EUR": 0.95534}}
    """
    import requests

    proxy_server = "http://proxy-vm.demo.com:8888" # This is the VM's FQDN to reach the proxy vm in the consumers network

    proxies = {
       "http": proxy_server,
       "https": proxy_server,
    }
    response = requests.get(
        f"https://api.frankfurter.app/{currency_date}",
        params={"from": currency_from, "to": currency_to},
        proxies=proxies,
    )
    return response.json()

Cloud Storage में एजेंट की फ़ाइलें अपलोड करना: सीरियल किए गए एजेंट और उसकी ज़रूरी शर्तों को, तय किए गए GCS बकेट में अपलोड करें.

अपनी JupyterLab नोटबुक में, एक नई सेल बनाएं और यह कोड चलाएं:

# Upload files to Cloud Storage.
if not GCS_DIR:
    raise ValueError("GCS_DIR must be set.")

FILE = "streaming_agent.pkl"
blob = bucket.blob(f"{GCS_DIR}/{FILE}")
with blob.open("wb") as f:
    cloudpickle.dump(
        StreamingAgent(
            model="gemini-2.0-flash-001",  # Required.
            tools=[get_exchange_rate],  # Optional.
            project_id=PROJECT_ID
        ), f)


requirements = """
google-cloud-aiplatform[agent_engines,langchain]==1.96.0
cloudpickle==3.1.1
"""

blob = bucket.blob(f"{GCS_DIR}/requirements-streaming.txt")
blob.upload_from_string(requirements)

!gsutil ls gs://{BUCKET}/{GCS_DIR}

एजेंट इंजन डिप्लॉय करें: एजेंट इंजन को डिप्लॉय करें. साथ ही, इसे पीएससी इंटरफ़ेस और डीएनएस पियरिंग के साथ कॉन्फ़िगर करें, ताकि उपभोक्ता वीपीसी में प्रॉक्सी वीएम के FQDN को हल किया जा सके.

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

उपयोगकर्ता के वीपीसी से डीएनएस पियरिंग को, demo.com डोमेन नेम के लिए dnsPeeringConfigs (dnsPeeringConfigs) का इस्तेमाल करके कॉन्फ़िगर किया जाता है.

import requests


token = !gcloud auth application-default print-access-token

response = requests.post(
    f"{ENDPOINT}/v1beta1/projects/{PROJECT_ID}/locations/{LOCATION}/reasoningEngines",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {token[0]}"
    },
    data=json.dumps({
        "displayName": "PSC-I Explicit Proxy",
        "description": "test psc-i agent + proxy vm",
        "spec": {
            "packageSpec": {
                "pickleObjectGcsUri": f"gs://{BUCKET}/{GCS_DIR}/streaming_agent.pkl",
                "requirementsGcsUri": f"gs://{BUCKET}/{GCS_DIR}/requirements-streaming.txt",
                "pythonVersion": "3.10"
            },
            "deploymentSpec": {
                "pscInterfaceConfig": {
                    "networkAttachment": NETWORK_ATTACHMENT_NAME,
                    "dnsPeeringConfigs": [
                    {
                      "domain": "demo.com.",
                      "targetProject": PROJECT_ID,
                      "targetNetwork": "consumer-vpc", #Consumer VPC
                    },
                  ],
                }
            }
        },
    })
)

pprint.pprint(json.loads(response.content))
reasoning_engine_id = json.loads(response.content)["name"].split("/")[5]
pprint.pprint(reasoning_engine_id)

डिप्लॉयमेंट की स्थिति पर नज़र रखना: एजेंट इंजन को डिप्लॉय करने की कार्रवाई की स्थिति देखें.

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

operation_id = json.loads(response.content)["name"].split("/")[7]
pprint.pprint(operation_id)

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

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

# You can run this multiple times to check the status of the deployment operation, operation takes approx 5 min.
token = !gcloud auth application-default print-access-token
response = requests.get(
    f"{ENDPOINT}/v1beta1/projects/{PROJECT_ID}/locations/{LOCATION}/operations/{operation_id}        ",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {token[0]}"
    }
)
pprint.pprint(json.loads(response.content))

अपडेट होने का उदाहरण:

डिप्लॉय किए गए एजेंट से क्वेरी करना: डिप्लॉय किए गए एजेंट इंजन को क्वेरी भेजकर, उसकी सुविधाओं को टेस्ट करें.

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

response = requests.post(
    f"{ENDPOINT}/v1beta1/projects/{PROJECT_ID}/locations/{LOCATION}/reasoningEngines/{reasoning_engine_id}:query",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {token[0]}"
    },
    data=json.dumps({ "input": {"input": "What is the exchange rate from US dollars to Euro?"} })
)
print(response.text)

क्वेरी के नतीजों को स्ट्रीम करना: एजेंट इंजन की क्वेरी से मिले आउटपुट को स्ट्रीम करें.

JupyterLab नोटबुक में, एक नई सेल बनाएं और यहां दिया गया कोड चलाएं. इससे, उपभोक्ताओं के वीपीसी में मौजूद प्रॉक्सी का इस्तेमाल करके, सार्वजनिक यूआरएल पर एपीआई कॉल ट्रिगर होगा.

token = !gcloud auth application-default print-access-token
print(f"{ENDPOINT}/v1beta1/projects/{PROJECT_ID}/locations/us-central1/reasoningEngines/{reasoning_engine_id}:streamQuery")

response = requests.post(
    f"{ENDPOINT}/v1beta1/projects/{PROJECT_ID}/locations/us-central1/reasoningEngines/{reasoning_engine_id}:streamQuery",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {token[0]}"
    },
    data=json.dumps({ "input": {"input": "What is the exchange rate from US dollars to Euro?"} })
)
for chunk in response.iter_lines():
    print(chunk.decode('utf-8'))
# pprint.pprint(json.loads(response.content))

अपडेट होने का उदाहरण:

14. Tcpdump की पुष्टि करना

tcpdump का आउटपुट देखें. इसमें, एजेंट इंजन और Prox-VM के बीच कम्यूनिकेशन की जानकारी दी गई है. यह कम्यूनिकेशन, पोस्ट किए गए अनुरोध पर PSC नेटवर्क अटैचमेंट के आईपी पते का इस्तेमाल करके किया गया था.

user@proxy-vm:~$ sudo tcpdump -i any net 192.168.10.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
22:17:53.983212 ens4  In  IP 192.168.10.2.22261 > 10.10.10.2.8888: Flags [S], seq 3841740961, win 28800, options [mss 1440,sackOK,TS val 4245243253 ecr 0,nop,wscale 7], length 0
22:17:53.983252 ens4  Out IP 10.10.10.2.8888 > 192.168.10.2.22261: Flags [S.], seq 2232973833, ack 3841740962, win 64768, options [mss 1420,sackOK,TS val 2251247643 ecr 4245243253,nop,wscale 7], length 0
22:17:53.985167 ens4  In  IP 192.168.10.2.22261 > 10.10.10.2.8888: Flags [.], ack 1, win 225, options [nop,nop,TS val 4245243256 ecr 2251247643], length 0
22:17:53.986476 ens4  In  IP 192.168.10.2.22261 > 10.10.10.2.8888: Flags [P.], seq 1:45, ack 1, win 16384, options [nop,nop,TS val 4245243256 ecr 2251247643], length 44
22:17:53.986485 ens4  Out IP 10.10.10.2.8888 > 192.168.10.2.22261: Flags [.], ack 45, win 506, options [nop,nop,TS val 2251247646 ecr 4245243256], length 0
22:17:54.043347 ens4  Out IP 10.10.10.2.8888 > 192.168.10.2.22261: Flags [P.], seq 1:71, ack 45, win 506, options [nop,nop,TS val 2251247703 ecr 4245243256], length 70

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

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

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

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

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

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

प्रॉक्सी-वीएम टीसीपीडंप सेशन से बाहर निकलें और उससे जुड़ा सार्वजनिक आईपी पता पाने के लिए, Frankfurter api.frankfurter.app को पिंग करें.

ping -c4 api.frankfurter.app

इस उदाहरण में, api.frankfurter.app के लिए 104.26.1.198 को सार्वजनिक आईपी के तौर पर दिखाया गया है

user@proxy-vm:~$ ping -c4 api.frankfurter.app

PING api.frankfurter.app (104.26.1.198) 56(84) bytes of data.

64 bytes from 104.26.1.198 (104.26.1.198): icmp_seq=1 ttl=61 time=10.9 ms

64 bytes from 104.26.1.198 (104.26.1.198): icmp_seq=2 ttl=61 time=10.9 ms

64 bytes from 104.26.1.198 (104.26.1.198): icmp_seq=3 ttl=61 time=10.9 ms

64 bytes from 104.26.1.198 (104.26.1.198): icmp_seq=4 ttl=61 time=10.9 ms

आइए, NAT लॉगिंग पर एक नज़र डालते हैं, ताकि यह देखा जा सके कि 104.26.1.198 के लिए ट्रैफ़िक का पता चला है या नहीं.

इन पर जाएं:

Monitoring → Log Explorer

इस फ़िल्टर का इस्तेमाल करें:

resource.type="nat_gateway"

समयावधि चुनें. इसके बाद, क्वेरी चलाएं

उस लॉग एंट्री को बड़ा करें जो api.frankfurter.app के (डेस्टिनेशन) सार्वजनिक आईपी (104.26.1.198) और सोर्स आईपी पते की पहचान करती है. साथ ही, उस प्रॉक्सी-वीएम का नाम भी दिखाती है जो इंटरनेट से बाहर निकलने के लिए, साफ़ तौर पर प्रॉक्सी के इस्तेमाल की पुष्टि करता है.

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

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

token = !gcloud auth application-default print-access-token

response = requests.delete(
    f"{ENDPOINT}/v1beta1/projects/{PROJECT_ID}/locations/us-central1/reasoningEngines/{reasoning_engine_id}",
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {token[0]}"
    },
)
print(response.text)

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

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 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 compute networks delete consumer-vpc --quiet

18. बधाई हो

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

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

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

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

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

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

Private Service Connect इंटरफ़ेस के बारे में जानकारी | वीपीसी | Google Cloud

Agent Engine PSC Explicit Proxy

1. परिचय

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

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

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

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

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

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

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

एपीआई चालू करना

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

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

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

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

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

4. IAP की सुविधा चालू करना

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

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

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

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

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

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

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

8. Jupyter Notebook बनाना

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

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

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

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

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

12. प्रॉक्सी वीएम Tcpdump

13. एजेंट इंजन डिप्लॉय करना

14. Tcpdump की पुष्टि करना

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

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

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

18. बधाई हो

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

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

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