Agent Engine (ADK) PSC SWP Integration

1. परिचय

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

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

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

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

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

PSC-Interface, VPC नेटवर्क से मिले डेस्टिनेशन के आधार पर, VPC या ऑन-प्रीमिसेस डेस्टिनेशन पर ट्रैफ़िक को रूट कर सकता है.
एजेंट इंजन, वीपीसी नेटवर्क से कनेक्ट होने के लिए जिस नेटवर्क अटैचमेंट का इस्तेमाल करता है उसकी पहुंच को सीमित करने के लिए, इग्रेस फ़ायरवॉल नियमों को लागू करना सबसे सही तरीका है.
एजेंट इंजन के नेटवर्क अटैचमेंट सबनेट से निकलने वाले नेटवर्क इग्रेस ट्रैफ़िक के स्कोप को सीमित करने के लिए, वीपीसी इग्रेस फ़ायरवॉल का नियम लागू किया जाना चाहिए. इस नियम के तहत, एजेंट इंजन से SWP तक ट्रैफ़िक को अनुमति दी जाएगी. साथ ही, आउटबाउंड ट्रैफ़िक को अस्वीकार कर दिया जाएगा.

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

एजेंट इंजन पीएससी-इंटरफ़ेस के काम करने के लिए, आपको ग्राहक के वीपीसी में इंटरनेट इग्रेस कनेक्टिविटी देनी होगी. भले ही, वीपीसी सेवा नियंत्रण चालू हों.

Secure Web Proxy

Secure Web Proxy एक मैनेज की गई, क्लाउड-नेटिव सेवा है. यह आपको आउटबाउंड ट्रैफ़िक (एचटीटीपी/एचटीटीपीएस) के लिए, बेहतर कंट्रोल और सुरक्षा देती है. यह एक सेंट्रल गेटवे के तौर पर काम करता है. इसकी मदद से, पीएससी इंटरफ़ेस के साथ डिप्लॉय किए गए एजेंट इंजन से शुरू किए गए कनेक्शन पर सुरक्षा नीतियां लागू की जा सकती हैं. ये कनेक्शन, वीपीसी रिसॉर्स (जैसे कि वीएम, GKE, इंटरनेट, और मल्टीक्लाउड एनवायरमेंट) से जुड़े होते हैं.

इससे क्या समस्या हल होती है

डेटा को बाहर जाने से रोकता है: यह सुविधा, बिना अनुमति के अपलोड किए जाने वाले डेटा या नुकसान पहुंचाने वाली साइटों के साथ कम्यूनिकेट करने वाले डेटा को ब्लॉक करती है.
नीतियों का पालन करना: इससे यह पक्का किया जाता है कि आउटबाउंड ट्रैफ़िक, आपके संगठन की सुरक्षा और डेटा मैनेज करने की नीतियों का पालन करता हो.
ऑपरेशनल ओवरहेड कम करता है: Secure Web Proxy एक पूरी तरह से मैनेज की जाने वाली सेवा है. इसलिए, आपको अपने प्रॉक्सी वीएम को डिप्लॉय, स्केल या बनाए रखने की ज़रूरत नहीं होती.
ज़्यादा जानकारी देता है: इससे ट्रांसपोर्ट लेयर सिक्योरिटी (टीएलएस) से एन्क्रिप्ट (सुरक्षित) किए गए ट्रैफ़िक की जांच की जा सकती है, ताकि छिपे हुए खतरों का पता लगाया जा सके.

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

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

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

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

इस ट्यूटोरियल में, आपको Private Service Connect (PSC) इंटरफ़ेस के साथ डिप्लॉय किया गया एक ऐसा एजेंट इंजन बनाना है जो SWP के साथ इंटिग्रेट हो. इससे ADK लाइब्रेरी का इस्तेमाल करके, ये काम किए जा सकते हैं:

प्रॉक्सी कॉन्फ़िगरेशन में इस्तेमाल किए गए एसडब्ल्यूपी के पूरी तरह क्वालिफ़ाइड डोमेन नेम को हल करने के लिए, Agent Engine में डीएनएस पियरिंग डिप्लॉय करें.
RFC1918 पते के साथ उपभोक्ता के वीपीसी में डिप्लॉय की गई सुरक्षित वेब प्रॉक्सी के ज़रिए, सार्वजनिक साइट (https://api.frankfurter.app/) से कनेक्ट करने की अनुमति दें.
नेटवर्क अटैचमेंट सबनेट से SWP तक ट्रैफ़िक को अनुमति दें, जबकि बाकी सभी को अनुमति न दें.

इमेज 1

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

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

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

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)
प्रोजेक्ट के लिए IAM एडमिन (roles/resourcemanager.projectIamAdmin)
सेवा खाते का एडमिन (roles/iam.serviceAccountAdmin)
Service Usage Admin (roles/serviceusage.serviceUsageAdmin)

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

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

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

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

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 enable "networksecurity.googleapis.com"
gcloud services enable "networkservices.googleapis.com"
gcloud services enable "cloudresourcemanager.googleapis.com"

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

gcloud services list --enabled

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

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

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

उपभोक्ता सबनेट
नेटवर्क अटैचमेंट सबनेट
सिर्फ़ प्रॉक्सी सबनेट
फ़ायरवॉल के नियम
Cloud DNS

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

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

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

Cloud Shell में, SWP के लिए सबनेट बनाएं:

gcloud compute networks subnets create swp-subnet --project=$projectid --range=10.10.10.0/28 --network=consumer-vpc --region=us-central1 --enable-private-ip-google-access

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

क्षेत्रीय प्रॉक्सी सबनेट बनाना

Cloud Shell में, प्रॉक्सी-ओनली सबनेट बनाएं. यह Envoy पर आधारित प्रॉडक्ट के लिए ज़रूरी है. जैसे, Secure Web Proxy और रीजनल इंटरनल/एक्सटर्नल ऐप्लिकेशन लोड बैलेंसर. –purpose फ़्लैग को REGIONAL_MANAGED_PROXY पर सेट किया जाना चाहिए:

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

नोटबुक सबनेट बनाना

Cloud Shell में, नोटबुक इंस्टेंस के लिए सबनेट बनाएं:

gcloud compute networks subnets create notebook-subnet --project=$projectid --range=192.168.20.0/28 --network=consumer-vpc --region=us-central1 --enable-private-ip-google-access

4. Secure Web Proxy बनाना

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

इस नीति में ऐसे नियम शामिल होंगे जो सेशन मैच, host() == 'api.frankfurter.app' और ऐप्लिकेशन मैच request.method == 'GET' के आधार पर, सुरक्षित वेब प्रॉक्सी के ज़रिए ट्रैफ़िक को मैनेज करते हैं

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

Cloud Shell में, policy.yaml फ़ाइल बनाएं:

cat > policy.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/my-swp-policy 
description: "My basic SWP policy" 
EOF

Cloud Shell में, नीति इंपोर्ट करें:

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

Secure Web Proxy के नियम बनाना

नीति में नियम तय करें, ताकि यह तय किया जा सके कि किस ट्रैफ़िक को अनुमति दी जाएगी या नहीं. नियमों का आकलन, प्राथमिकता के आधार पर किया जाता है.

Cloud Shell में, agent engine इस्तेमाल करने वाले इंटरनेट एंडपॉइंट, api.frankfurter.app को ऐक्सेस करने की अनुमति देने के लिए, rule.yaml फ़ाइल बनाएं:

cat > rule.yaml << EOF
name: "projects/$projectid/locations/us-central1/gatewaySecurityPolicies/my-swp-policy/rules/allow-example"
description: "Allow frankfurter API"
enabled: true
priority: 10
basicProfile: ALLOW
sessionMatcher: "host() == 'api.frankfurter.app'"
EOF

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

gcloud network-security gateway-security-policies rules import allow-example \
    --source=rule.yaml \
    --location=us-central1 \
    --gateway-security-policy=my-swp-policy

Secure Web Proxy के नियम बनाना

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

Cloud Shell में, SWP को डिप्लॉय करने के लिए इस्तेमाल की जाने वाली gateway.yaml फ़ाइल बनाएं.

अपने एनवायरमेंट की जानकारी के साथ इन वैरिएबल को अपडेट करने के बाद, YAML फ़ाइल को सेव करना न भूलें: PROJECT_ID, REGION, NETWORK_NAME, और PROXY_ONLY_SUBNET_NAME. यहां बताया गया पोर्ट 8888, आउटर टनल पोर्ट है. इसे Agent Engine में प्रॉक्सी कॉन्फ़िगरेशन के साथ मैप किया जाता है.

cat > gateway.yaml << EOF
name: "projects/$projectid/locations/us-central1/gateways/my-swp-instance"
type: SECURE_WEB_GATEWAY
ports: [8888]
addresses: ["10.10.10.5"]
gatewaySecurityPolicy: "projects/$projectid/locations/us-central1/gatewaySecurityPolicies/my-swp-policy"
network: "projects/$projectid/global/networks/consumer-vpc"
subnetwork: "projects/$projectid/regions/us-central1/subnetworks/swp-subnet"
routingMode: EXPLICIT_ROUTING_MODE
EOF

Cloud Shell में, गेटवे इंपोर्ट करें:

gcloud network-services gateways import my-swp-instance \
    --source=gateway.yaml \
    --location=us-central1

5. 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 नेटवर्क अटैचमेंट का यूआरएल देखने के लिए, यहां जाएं:

Network Services → Private Service Connect → Network Attachment → psc-network-attachment

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

आपको 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"

DNS A रिकॉर्ड के लिए इस्तेमाल किए गए SWP के आईपी पते पाना और उन्हें सेव करना.

Cloud Shell में, swp और my-swp-instance के बारे में जानकारी पाने के लिए, यह कमांड चलाएं:

gcloud network-services gateways describe my-swp-instance --location=us-central1

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

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

फ़ायरवॉल कॉन्फ़िगरेशन

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

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

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

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

Cloud Shell में, नेटवर्क अटैचमेंट से आने वाले सभी ट्रैफ़िक को अस्वीकार करने वाला इग्रेस फ़ायरवॉल नियम बनाएं:

gcloud compute firewall-rules create deny-all \
    --network=consumer-vpc \
    --action=DENY \
    --rules=ALL \
    --direction=EGRESS \
    --priority=65534 \
    --source-ranges="192.168.10.0/28" \
    --destination-ranges="0.0.0.0/0" \
    --enable-logging

7. VPC नेटवर्क के लिए फ़ायरवॉल की नीति बनाएं, ताकि थ्रेट इंटेलिजेंस की सुविधा काम कर सके:

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

Cloud Shell में, ग्लोबल फ़ायरवॉल नीति बनाएं:

gcloud compute network-firewall-policies create psc-secure-policy \
    --global \
    --description="Policy to protect VPC with Threat Intelligence"

Cloud Shell में, नीति को अपने वीपीसी से जोड़ें:

gcloud compute network-firewall-policies associations create \
    --firewall-policy=psc-secure-policy \
    --network=consumer-vpc \
    --name=psc-swp-association \
    --global-firewall-policy

Cloud Shell में, थ्रेट इंटेलिजेंस के नियम जोड़ें:

ये नियम, एजेंट से ट्रैफ़िक शुरू करने से पहले, नुकसान पहुंचाने वाले लोगों या कंपनियों के लिए ट्रैफ़िक को कम कर देंगे. इस उदाहरण में, हमने ये नियम जोड़े हैं: Tor Exit Nodes (Egress) को ब्लॉक करें, जाने-माने नुकसान पहुंचाने वाले आईपी (Egress) को ब्लॉक करें, जाने-माने ऐनॉनमस प्रॉक्सी(Egress) को ब्लॉक करें, और क्रिप्टो माइनर को ब्लॉक करें, ताकि बिना अनुमति के संसाधन का इस्तेमाल (Egress) न किया जा सके.

gcloud compute network-firewall-policies rules create 100 \
    --firewall-policy=psc-secure-policy \
    --action=deny \
    --direction=EGRESS \
    --dest-threat-intelligence=iplist-tor-exit-nodes \
    --layer4-configs=all \
    --enable-logging \
    --description="Block anonymous Tor traffic" \
    --global-firewall-policy

gcloud compute network-firewall-policies rules create 110 \
    --firewall-policy=psc-secure-policy \
    --action=deny \
    --direction=EGRESS \
    --dest-threat-intelligence=iplist-known-malicious-ips \
    --layer4-configs=all \
    --enable-logging \
    --description="Block known botnets and malware sources" \
    --global-firewall-policy

gcloud compute network-firewall-policies rules create 120 \
    --firewall-policy=psc-secure-policy \
    --action=deny \
    --direction=EGRESS \
    --dest-threat-intelligence=iplist-anon-proxies \
    --layer4-configs=all \
    --enable-logging \
    --description="Block Known Anonymous Proxies" \
    --global-firewall-policy

gcloud compute network-firewall-policies rules create 130 \
    --firewall-policy=psc-secure-policy \
    --action=deny \
    --direction=EGRESS \
    --dest-threat-intelligence=iplist-crypto-miners \
    --layer4-configs=all \
    --enable-logging \
    --description="Block Crypto Miners (Prevent unauthorized resource usage)" \
    --global-firewall-policy

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. 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=notebook-subnet --disable-public-ip --shielded-secure-boot=true --shielded-integrity-monitoring=true --shielded-vtpm=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

इस नोटबुक इंस्टेंस से ट्रैफ़िक को फ़ॉरवर्ड करने के लिए, मौजूदा Secure Web Proxy में एक और नियम जोड़ें:

Cloud Shell में, टेक्स्ट एडिटर का इस्तेमाल करके rule-notebook.yaml फ़ाइल बनाएं. साथ ही, पक्का करें कि आपने YAML फ़ाइल में अपना प्रोजेक्ट आईडी अपडेट किया हो

cat > rule-notebook.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/my-swp-policy/rules/allow-notebook-subnet
description: Allow Internet access for notebook subnet
enabled: true
priority: 2
basicProfile: ALLOW
sessionMatcher: inIpRange(source.ip,'192.168.20.2')
EOF

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

gcloud network-security gateway-security-policies rules import allow-notebook-subnet \
    --source=rule-notebook.yaml \
    --location=us-central1 \
    --gateway-security-policy=my-swp-policy

10. 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"

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

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

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

यह कुकी, विनिमय दर का डेटा पाने के लिए Frankfurter API (https://api.frankfurter.app/) का इस्तेमाल करती है
यह नीति, उपभोक्ता के वीपीसी में SWP को टारगेट करने वाले एक्सप्लिसिट प्रॉक्सी (proxy_server) को रेफ़र करती है. इसके लिए, FQDN swp.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 में खुलता है.
File > New > Notebook चुनें
Kernel > Python 3 चुनें

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

JupyterLab नोटबुक में, एक नई सेल बनाएं और SWP का आईपी पता डालकर यह निर्देश चलाएं

!pip install --proxy http://10.10.10.5:8888 --upgrade google-cloud-aiplatform[agent_engines,adk]

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

PROJECT_ID
BUCKET_NAME
AGENT_NAME

इस लैब में, BUCKET_NAME और AGENT_NAME वैरिएबल का इस्तेमाल करके, स्टोरेज बकेट को शुरू और कॉन्फ़िगर किया जाएगा. यह स्टोरेज बकेट दुनिया भर में उपलब्ध है

यहां दिए गए सेक्शन में, PROXY_SERVER को तय किया गया है. उदाहरण के लिए, swp.demo.com. इसके लिए, नाम रिज़ॉल्यूशन के लिए डीएनएस पियरिंग की ज़रूरत होती है. कॉन्फ़िगरेशन में, AGENT_PEER_DOMAIN को demo.com के तौर पर डिप्लॉय किया जाता है. यह AGENT_PEER_NETWORK, consumer-vpc में पिछले चरण में बनाए गए निजी डीएनएस ज़ोन से मेल खाता है.

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

# --- Fundamental Project Configuration ---
PROJECT_ID = "YOUR_PROJECT_ID"
LOCATION = "us-central1" # e.g., "us-central1"
BUCKET_NAME = "YOUR_BUCKET_NAME" # A GCS bucket in the same location

# --- Agent Configuration ---
AGENT_NAME = "YOUR_AGENT_NAME"
MODEL = "gemini-2.5-flash" # Or another suitable model

# --- Network and Proxy Configuration ---
# The agent will call the Frankfurter API via this proxy
PROXY_SERVER = "http://swp.demo.com:8888"

# --- Deployment Configuration (PSC & DNS Peering) ---
# This should be a pre-existing Network Attachment
NETWORK_ATTACHMENT_NAME = f"projects/{PROJECT_ID}/regions/{LOCATION}/networkAttachments/psc-network-attachment"
# Optional DNS Peering config
AGENT_PEER_DOMAIN = "demo.com."
AGENT_PEER_NETWORK = "consumer-vpc"

# --- Initialize Vertex AI SDK ---
import vertexai
STAGING_BUCKET = f"gs://{BUCKET_NAME}"

vertexai.init(project=PROJECT_ID, location=LOCATION, staging_bucket=STAGING_BUCKET)

print(f"Vertex AI SDK initialized for project {PROJECT_ID} in {LOCATION}.")

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

!adk create $AGENT_NAME --model=$MODEL --project=$PROJECT_ID --region=$LOCATION

अपनी JupyterLab नोटबुक में, एक नई सेल बनाएं. इसके बाद, SWP के FQDN और पोर्ट से मेल खाने वाला प्रॉक्सी वैरिएबल बनाने के लिए, यह कोड चलाएं.

import os
os.environ["PROXY_SERVER_URL"] = "http://swp.demo.com:8888"

यहां दिए गए कोड सेल में, एजेंट इंजन के लिए प्रॉक्सी कॉन्फ़िगरेशन दिखाया गया है. इससे एजेंट इंजन, इंटरनेट एंडपॉइंट api.frankfurter.app को ऐक्सेस कर पाएगा. इसके लिए, SWP को तय किया गया है. साथ ही, PROXY_SERVER_TO_USE का इस्तेमाल किया गया है, जो os.environ["PROXY_SERVER_URL"]. पर मैप करता है

import requests
# Use the globally defined proxy server URL
    proxies = {
       "http": PROXY_SERVER_TO_USE,
       "https": PROXY_SERVER_TO_USE,
    }
    try:
        response = requests.get(
            f"https://api.frankfurter.app/{currency_date}",
            params={"from": currency_from, "to": currency_to},
            proxies=proxies,
) 
response.raise_for_status() 
print(response.json()) 
except requests.exceptions.RequestException as e: print(f"An error occurred: {e}")

अपनी JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिया गया कोड चलाएं. यह कोड, currency exchange targeting api.frankfurther.app के लिए टूल लागू करने की जानकारी देता है.

%%writefile $AGENT_NAME/agent.py
from google.adk.agents.llm_agent import Agent
import os
import requests


# Get Proxy Server URL
# This is the VM's FQDN to reach the proxy vm in the consumers network
if "PROXY_SERVER_URL" not in os.environ:
    raise ValueError("Missing required environment variable: PROXY_SERVER_URL is not set.")
PROXY_SERVER_TO_USE = os.environ["PROXY_SERVER_URL"]

# Mock tool implementation
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}}
    """
    # Use the globally defined proxy server URL
    proxies = {
       "http": PROXY_SERVER_TO_USE,
       "https": PROXY_SERVER_TO_USE,
    }
    
    try:
        response = requests.get(
            f"https://api.frankfurter.app/{currency_date}",
            params={"from": currency_from, "to": currency_to},
            proxies=proxies,
        )
        response.raise_for_status()  # Raise an error for bad responses
        return response.json()
    except Exception as e:
        return f"An unexpected error occurred: {e}"

root_agent = Agent(
    model='gemini-2.5-flash',
    name='root_agent',
    description="Provides the currency exchange rates between two currencies",
    instruction="You are a helpful assistant that provides the currency exchange rates between two currencies. Use the 'get_exchange_rate' tool for this purpose.",
    tools=[get_exchange_rate],
)

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

# 1. Set your variables
CURRENCY_DATE="latest"
CURRENCY_FROM="USD"
CURRENCY_TO="EUR"
PROXY_SERVER="http://swp.demo.com:8888"

# 2. Run the curl command
!curl -x "$PROXY_SERVER" "https://api.frankfurter.app/$CURRENCY_DATE?from=$CURRENCY_FROM&to=$CURRENCY_TO"

अपनी JupyterLab नोटबुक में, एक नई सेल बनाएं और नीचे दिए गए कोड को चलाएं. यह कोड, DNS पियरिंग के साथ-साथ, Agent Engine के इस्तेमाल किए गए पीएससी इंटरफ़ेस कॉन्फ़िगरेशन को चालू करता है.

import json
import os

CONFIG_FILE_PATH = os.path.join(AGENT_NAME, ".agent_engine_config.json")
# Create your config as a Python dictionary ---
config_data = {
    "requirements": [
        "google-cloud-aiplatform[agent_engines,adk]",
        "requests",
    ],
    "psc_interface_config": {
        "network_attachment": NETWORK_ATTACHMENT_NAME,
        "dns_peering_configs": [
            {
                "domain": AGENT_PEER_DOMAIN,
                "target_project": PROJECT_ID,
                "target_network": AGENT_PEER_NETWORK,
            },
        ],
    },
}

# Write the dictionary to a JSON file ---
os.makedirs(AGENT_NAME, exist_ok=True) # Ensure the directory exists
with open(CONFIG_FILE_PATH, 'w') as f:
    json.dump(config_data, f, indent=4)

print(f"Successfully created {CONFIG_FILE_PATH} with your variables.")

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

import json
import os

CONFIG_FILE_PATH = os.path.join(AGENT_NAME, ".agent_engine_config.json")
# Create your config as a Python dictionary ---
config_data = {

    "psc_interface_config": {
        "network_attachment": NETWORK_ATTACHMENT_NAME,
        "dns_peering_configs": [
            {
                "domain": AGENT_PEER_DOMAIN,
                "target_project": PROJECT_ID,
                "target_network": AGENT_PEER_NETWORK,
            },
        ],
    },
}

# Write the dictionary to a JSON file ---
os.makedirs(AGENT_NAME, exist_ok=True) # Ensure the directory exists
with open(CONFIG_FILE_PATH, 'w') as f:
    json.dump(config_data, f, indent=4)

print(f"Successfully created {CONFIG_FILE_PATH} with your variables.")

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

%%writefile $AGENT_NAME/.env

GOOGLE_CLOUD_PROJECT=PROJECT_ID
GOOGLE_CLOUD_LOCATION=us-central1
GOOGLE_GENAI_USE_VERTEXAI=1


PROXY_SERVER_URL=http://swp.demo.com:8888

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

!adk deploy agent_engine $AGENT_NAME --staging_bucket=$STAGING_BUCKET --env_file=$AGENT_NAME/.env --agent_engine_config_file=$AGENT_NAME/.agent_engine_config.json --display_name=$AGENT_NAME

सेल को चलाने पर, रीज़निंग इंजन आईडी जनरेट होगा. अगले चरण के लिए, आपको जनरेट किए गए आईडी की ज़रूरत होगी. इस उदाहरण में, यह 3235268984265768960 है.

✅ Created agent engine: projects/9315891080/locations/us-central1/reasoningEngines/3235268984265768960

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

from vertexai import agent_engines
remote_app = agent_engines.get("projects/PROJECT_NUMBER/locations/us-central1/reasoningEngines/ENTER_YOUR_ID")

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

def print_event_nicely_with_thoughts(event):
    """
    Parses and prints streaming query events, including thoughts.
    """
    try:
        content = event.get('content', {})
        role = content.get('role')
        parts = content.get('parts', [{}])

        if not parts:
            print("...")
            return

        part = parts[0] # Get the first part

        # Event 1: Model is thinking (calling a tool or just text)
        if role == 'model':

            # Check for and print any explicit 'thought' text
            if 'thought' in part:
                print(f"🧠 Thought: {part['thought']}")

            # Check for a function call
            if 'function_call' in part:
                # If we haven't *already* printed an explicit thought,
                # print a generic one.
                if 'thought' not in part:
                    print("🧠 Thinking... (decided to use a tool)")

                call = part['function_call']
                print(f"   🔧 Tool Call: {call.get('name')}()")
                print(f"      Args: {call.get('args')}")

            # Check for the final text answer
            elif 'text' in part:
                text = part.get('text', '')
                print(f"\n💬 Model: {text}")

        # Event 2: The tool returns its result
        elif role == 'user' and 'function_response' in part:
            resp = part['function_response']
            print(f"⚙️ Tool Response (from {resp.get('name')}):")
            print(f"   Output: {resp.get('response')}")

        # Other event types (like progress messages)
        else:
            print("...") # Show progress for other events

    except Exception as e:
        print(f"Error processing event: {e}")
        # print(f"Raw event: {event}") # Uncomment to debug



for event in remote_app.stream_query(
    user_id="u_456",
    # session_id=remote_session["id"],
    message="Provide USD to INR conversion rate",
):
    print_event_nicely_with_thoughts(event)

सफल तरीके से लागू किए गए उदाहरण में, USD से INR में कन्वर्ज़न रेट के आधार पर, SWP के ज़रिए सार्वजनिक एंडपॉइंट api.frankfurther.app से कनेक्टिविटी की पुष्टि की गई है.

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

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

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

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

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

13. SWP - Cloud Logging Validation

SWP की ओर से किए गए इंटरनेट इग्रेस की पुष्टि करने के लिए, Cloud Logging देखा जा सकता है. इसके लिए, यहां जाएं:

मॉनिटरिंग → लॉग एक्सप्लोरर

क्वेरी डालें: resource.type=" networkservices.googleapis.com/Gateway" इसके बाद, क्वेरी चलाएं पर क्लिक करें. यहां एक उदाहरण दिया गया है, जिसमें डेस्टिनेशन एंडपॉइंट, api.frankfurter.app की पुष्टि की गई है.

Cloud Logging के इस उदाहरण में, इन बातों की पुष्टि की गई है:

Destination_range: Agent Engine PSC Interface IP Address

Source_range: Proxy Only Subnet Dest_ip: Secure Web Proxy IP Address

पक्का करें कि क्लाउड लॉगिंग क्वेरी के लिए, project_id बदल दिया गया हो.

logName:("projects/project_id/logs/compute.googleapis.com%2Ffirewall") AND jsonPayload.rule_details.reference:("network:consumer-vpc/firewall:allow-access-to-swp")

{
  "insertId": "1j9ym95fmu8g6o",
  "jsonPayload": {
    "vpc": {
      "project_id": "XXXXXXXXXXXXX",
      "subnetwork_name": "intf-subnet",
      "vpc_name": "consumer-vpc"
    },
    "rule_details": {
      "destination_range": [
        "10.10.10.5/32"
      ],
      "reference": "network:consumer-vpc/firewall:allow-access-to-swp",
      "priority": 1000,
      "source_range": [
        "192.168.10.0/28"
      ],
      "direction": "EGRESS",
      "ip_port_info": [
        {
          "ip_protocol": "ALL"
        }
      ],
      "action": "ALLOW"
    },
    "disposition": "ALLOWED",
    "remote_instance": {
      "region": "us-central1"
    },
    "remote_vpc": {
      "vpc_name": "consumer-vpc",
      "project_id": "XXXXXXXXXXXXXXX",
      "subnetwork_name": "swp-subnet"
    },
    "connection": {
      "src_ip": "192.168.10.2",
      "src_port": 48640,
      "dest_port": 8888,
      "dest_ip": "10.10.10.5",
      "protocol": 6
    }
  },
  "resource": {
    "type": "gce_subnetwork",
    "labels": {
      "subnetwork_id": "7147084067647653041",
      "project_id": "XXXXXXXXXXXXXX",
      "location": "us-central1",
      "subnetwork_name": "intf-subnet"
    }
  },
  "timestamp": "2025-12-30T12:51:36.628538815Z",
  "logName": "projects/dec30-run1-agent/logs/compute.googleapis.com%2Ffirewall",
  "receiveTimestamp": "2025-12-30T12:51:40.846652708Z"
}

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

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

पक्का करें कि आपने "project number" और "reasoningEngines token" अपडेट किया हो

import requests
token = !gcloud auth application-default print-access-token
ENDPOINT = "https://us-central1-aiplatform.googleapis.com"
response = requests.delete(
    f"{ENDPOINT}/v1beta1/projects/218166745590/locations/us-central1/reasoningEngines/3086854705725308928",
    params={"force": "true"},
    headers={
        "Content-Type": "application/json; charset=utf-8",
        "Authorization": f"Bearer {token[0]}"
    },
)
print(response.text)

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

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

gcloud network-security gateway-security-policies rules delete allow-notebook-subnet \
    --gateway-security-policy=my-swp-policy \
    --location=us-central1

gcloud network-security gateway-security-policies rules delete allow-example \
    --gateway-security-policy=my-swp-policy \
    --location=us-central1

gcloud network-security gateway-security-policies delete my-swp-policy \
    --location=us-central1
gcloud network-services gateways delete my-swp-instance\
    --location=us-central1

gcloud dns record-sets delete swp.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab


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

export ROUTER_NAME=$(gcloud compute routers list --regions=us-central1 \
    --filter="name ~ swg-autogen-router" --format="value(name)")


 gcloud compute routers nats delete swg-autogen-nat --router=$ROUTER_NAME --region=us-central1 --quiet 

gcloud compute routers delete $ROUTER_NAME --region=us-central1 --quiet

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

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

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

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

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

gcloud compute networks delete consumer-vpc --quiet

15. बधाई हो

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

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

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

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

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

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

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

Agent Engine (ADK) PSC SWP Integration

1. परिचय

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

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

Secure Web Proxy

इससे क्या समस्या हल होती है

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

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

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

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

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

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

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

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

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

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

क्षेत्रीय प्रॉक्सी सबनेट बनाना

नोटबुक सबनेट बनाना

4. Secure Web Proxy बनाना

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

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

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

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

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

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

7. VPC नेटवर्क के लिए फ़ायरवॉल की नीति बनाएं, ताकि थ्रेट इंटेलिजेंस की सुविधा काम कर सके:

Cloud Shell में, थ्रेट इंटेलिजेंस के नियम जोड़ें:

8. Jupyter Notebook बनाना

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

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

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

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

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

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

13. SWP - Cloud Logging Validation

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

15. बधाई हो

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

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

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