एजेंट गेटवे का एजेंट रनटाइम से वीपीसी नेटवर्क तक इग्रेस

1. परिचय

इस कोडलैब में, निजी वीपीसी नेटवर्क के ज़रिए रिमोट एंडपॉइंट ऐक्सेस करने वाले एआई एजेंट के लिए, एजेंट गेटवे के इग्रेस गवर्नेंस के बारे में बताया गया है. इग्रेस (एजेंट-टू-एनीवेयर) मोड में काम करने वाला एजेंट गेटवे, Private Service Connect (PSC) इंटरफ़ेस का इस्तेमाल करके, वीपीसी नेटवर्क से निजी तौर पर कनेक्ट करने की सुविधा देता है. इस उदाहरण में, एजेंट रनटाइम, एजेंट गेटवे का इस्तेमाल करके, Cloud Run पर होस्ट किए गए रिमोट स्ट्रीम किए जा सकने वाले एचटीटीपी एमसीपी सर्वर को ऐक्सेस करता है. इसके लिए, वह वीपीसी नेटवर्क में Google APIs के लिए Private Service Connect (PSC) एंडपॉइंट का इस्तेमाल करता है.

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

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

जब एजेंट गेटवे, इग्रेस (एजेंट-टू-एनीवेयर) मोड में काम करता है, तो यह गेटवे का इस्तेमाल करने के लिए कॉन्फ़िगर किए गए एजेंट से किए गए सभी आउटबाउंड अनुरोधों को प्रॉक्सी करता है. एजेंट के हर वर्कलोड अनुरोध की पुष्टि, यूनीक एजेंट आइडेंटिटी का इस्तेमाल करके की जाती है. साथ ही, Identity-Aware Proxy (IAP) की नीतियों का इस्तेमाल करके, अनुरोध को अनुमति दी जाती है. एमसीपी टूल के कॉल को डाइनैमिक तरीके से डिकोड किया जाता है. साथ ही, नीति लागू करने के लिए उनकी जांच की जाती है. सुरक्षा एडमिन, ग्रेन्यूलर अनुमतियों को केंद्रीय तौर पर लागू कर सकते हैं. इससे यह पक्का किया जा सकता है कि एजेंट सिर्फ़ मंज़ूरी वाले एंडपॉइंट और तरीकों का इस्तेमाल कर सकें.

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

  • एजेंट गेटवे, इग्रेस (agent-to-anywhere) मोड में
  • Identity-Aware Proxy (IAP) ऑथराइज़ेशन एक्सटेंशन
  • एजेंट की पहचान के साथ एजेंट रनटाइम ADK एजेंट
  • Cloud Run में स्ट्रीम किए जा सकने वाले एचटीटीपी एमसीपी सर्वर
  • Google API और कस्टम एमसीपी एंडपॉइंट के साथ एजेंट रजिस्ट्री
  • आईएएम ऐक्सेस कंट्रोल के साथ अनुमति से जुड़ी नीतियां
  • Google APIs के लिए वीपीसी नेटवर्क संसाधन, Cloud DNS ज़ोन, और पीएससी एंडपॉइंट
  • एजेंट गेटवे से बाहर निकलने वाले डेटा के लिए, पीएससी नेटवर्क अटैचमेंट
  • Cloud Next Generation Firewall (NGFW) फ़ायरवॉल की नीति से जुड़े नियम

figure1

पहली इमेज. कोडलैब का स्ट्रक्चर

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

  • स्ट्रक्चर्ड कॉन्फ़िगरेशन सीक्वेंस में एजेंट गेटवे को डिप्लॉय करने का तरीका
  • प्राइवेट वीपीसी नेटवर्क कनेक्टिविटी के साथ एजेंट गेटवे को कॉन्फ़िगर करने का तरीका
  • अनुमति देने से जुड़ी नीतियों को ड्राय-रन मोड से लागू किए गए मोड में कैसे बदला जाता है
  • एजेंट रजिस्ट्री में Google API एंडपॉइंट और एमसीपी सर्वर रजिस्टर करने का तरीका
  • एजेंट गेटवे के लॉग का ऑडिट करके, डेटा बाहर जाने से जुड़ी नीतियों की पुष्टि कैसे करें
  • Cloud NGFW के लॉग का इस्तेमाल करके, एजेंट गेटवे के इग्रेस ट्रैफ़िक की पुष्टि कैसे करें

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

  • बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट
  • नेटवर्किंग सेवाएं, BigQuery डेटासेट, और एजेंट प्लैटफ़ॉर्म के संसाधनों को उपलब्ध कराने के लिए IAM अनुमतियां
  • Google Cloud CLI (gcloud और bq कॉम्पोनेंट) इंस्टॉल किया गया हो, साथ ही POSIX के साथ काम करने वाला शेल (bash या zsh)
  • कमांड-लाइन टूल: git, curl, jq (JSON प्रोसेसर), Python 3, और uv (Python पैकेज मैनेजर)

2. कॉन्सेप्ट

डिप्लॉयमेंट का क्रम

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

इस कोडलैब में, डिप्लॉयमेंट के लिए इस क्रम का इस्तेमाल किया गया है:

  1. DRY_RUN मोड में शुरू करें: पक्का करें कि एजेंट के अनुरोध, गेटवे पर पहुंच रहे हों और ऑडिट-ओनली मोड में पास हो रहे हों.
  2. सभी सेवाओं को रजिस्टर करें: Agent Registry में सभी एजेंटिक कॉम्पोनेंट रजिस्टर करें और एजेंट टूल के ऐक्सेस की पुष्टि करें. Agent Registry को भेजी गई क्वेरी देखने के लिए, Cloud Logging और Agent Gateway observability dashboard का इस्तेमाल करें.
  3. अनुमति देने से जुड़ी नीतियां बनाएं: एजेंट से एमसीपी सर्वर और एंडपॉइंट तक ईग्रेस ट्रैफ़िक की अनुमति देने के लिए, अनुमति देने से जुड़ी नीतियां बनाएं और लागू करें.
  4. ENFORCED मोड पर स्विच करें: नीतियों को लागू करने और बिना अनुमति वाले इग्रेस ट्रैफ़िक को ब्लॉक करने के लिए, अनुमति देने वाले एक्सटेंशन की नीति को अपडेट करें.

figure2

दूसरी इमेज. डिप्लॉयमेंट का क्रम

इग्रेस रूटिंग टोपोलॉजी

एजेंट गेटवे इग्रेस (agent-to-anywhere) एजेंटिक वर्कलोड के लिए, केंद्रीकृत और ज़ीरो-ट्रस्ट आउटबाउंड प्रॉक्सी के तौर पर काम करता है. जब कोई एजेंट किसी बाहरी टूल या एपीआई से अनुरोध करता है, तो आउटबाउंड अनुरोध को एजेंट गेटवे इंटरसेप्ट करता है. इसके बाद, इसे गवर्नेस की नीतियों के हिसाब से परखा जाता है. इसके बाद, इसे मंज़िल तक पहुंचाया जाता है. Google Cloud Agent Platform आर्किटेक्चर में, एजेंट गेटवे इन चीज़ों को डेटा प्लेन कनेक्टिविटी देता है:

  • निजी नेटवर्क (वीपीसी): आउटबाउंड ट्रैफ़िक, जो एंटरप्राइज़ के इंटरनल एपीआई, माइक्रोसेवाओं, निजी वीपीसी में होस्ट किए गए डेटाबेस, और हाइब्रिड कनेक्टिविटी के ज़रिए ऐक्सेस किए जा सकने वाले ऑन-प्रिमाइसेस या क्रॉस-क्लाउड नेटवर्क को टारगेट करता है.
  • बाहरी नेटवर्क (इंटरनेट): आउटबाउंड ट्रैफ़िक, तीसरे पक्ष की वेब सेवाओं, SaaS API या सार्वजनिक एंडपॉइंट को टारगेट करता है.
  • एआई सेवाएं और एजेंट प्लैटफ़ॉर्म: मैनेज किए गए Google Cloud API, फ़ाउंडेशन मॉडल, Google MCP एंडपॉइंट (जैसे कि BigQuery), और प्लैटफ़ॉर्म गवर्नेंस सेवाओं (जैसे कि एजेंट रजिस्ट्री और IAP नीतियां) को टारगेट करने वाला आउटबाउंड ट्रैफ़िक.

figure3

तीसरी इमेज. एजेंट गेटवे से बाहर निकलने वाले ट्रैफ़िक की राउटिंग टोपोलॉजी

इस कोडलैब में, Agent Runtime पर मौजूद कस्टम एजेंट से निकलने वाले आउटबाउंड ट्रैफ़िक पर फ़ोकस किया गया है. यह ट्रैफ़िक, वीपीसी नेटवर्क में डिप्लॉय किए गए Google APIs के एंडपॉइंट के लिए पीएससी को टारगेट करता है. इस आर्किटेक्चर की मदद से, Cloud Run पर होस्ट किए गए एमसीपी सर्वर को निजी तौर पर ऐक्सेस किया जा सकता है. इसके लिए, एजेंट गेटवे इग्रेस के लिए पीएससी नेटवर्क अटैचमेंट का इस्तेमाल किया जाता है.

वीपीसी कनेक्टिविटी

एजेंट गेटवे इग्रेस (agent-to-anywhere), डिप्लॉयमेंट की वाईएएमएल कॉन्फ़िगरेशन फ़ाइल में networkConfig: egress: networkAttachment: [URI] तय करके, किसी वीपीसी नेटवर्क से कनेक्ट हो सकता है. इस सेटिंग से, एजेंट गेटवे पर रूटिंग के नियम कॉन्फ़िगर किए जाते हैं. इससे, वीपीसी नेटवर्क में पीएससी नेटवर्क अटैचमेंट के ज़रिए, निजी आईपी पतों पर जाने वाले ट्रैफ़िक को भेजा जा सकता है.

figure4

चौथी इमेज. Agent Gateway वीपीसी कनेक्टिविटी

एजेंट गेटवे, Cloud DNS पीयरिंग का इस्तेमाल करके, निजी डीएनएस होस्टनेम को रिज़ॉल्व कर सकता है. इसके लिए, टारगेट प्रोजेक्ट और वीपीसी नेटवर्क तय करना होता है. dnsPeeringConfig: domains: [NAME] कॉन्फ़िगरेशन में शामिल सभी निजी ज़ोन, टारगेट प्रोजेक्ट में Cloud DNS रिकॉर्ड का इस्तेमाल करेंगे. अन्य सभी डीएनएस क्वेरी के लिए, डिफ़ॉल्ट वीपीसी Cloud DNS सार्वजनिक रिज़ॉल्वर का इस्तेमाल किया जाएगा.

यहां कॉन्सेप्ट वाला हिस्सा खत्म होता है... अब सेटअप सेक्शन पर जाएं.

3. सेटअप

ज़रूरी IAM भूमिकाएं

इस कोडलैब में संसाधन बनाने के लिए, इन भूमिकाओं की ज़रूरत होती है:

कैटगरी

ज़रूरी IAM भूमिका (आईडी)

ब्यौरा

एपीआई मैनेजमेंट

roles/serviceusage.serviceUsageAdmin

Google Cloud की एपीआई सेवाएं चालू करना

नेटवर्किंग और गेटवे

roles/networkservices.admin

एजेंट गेटवे को चालू करना

सेवा एक्सटेंशन

roles/serviceextensions.admin

रूटिंग एक्सटेंशन कॉन्फ़िगर करना

नेटवर्क सिक्योरिटी

roles/networksecurity.admin

अनुमति से जुड़ी नीतियां लागू करना

एजेंट रजिस्ट्री

roles/agentregistry.admin

कैटलॉग के लिए अनुमति मिला हुआ होस्ट

Vertex AI और एजेंट

roles/aiplatform.admin

एजेंट रनटाइम वर्कलोड डिप्लॉय करना

इग्रेस नीतियां

roles/iap.admin

roles/iap.egressor नीतियां लागू करना

Cloud Storage

roles/storage.admin

डिप्लॉयमेंट के लिए स्टेजिंग बकेट मैनेज करना

लॉग और ऑडिटिंग

roles/logging.viewer

ट्रेस और ऑडिट लॉग की जांच करना

Cloud Run डेवलपर

roles/run.developer

Cloud Run सेवाओं को डिप्लॉय करना

Artifact Registry पढ़ने वाला

roles/artifactregistry.reader

कंटेनर इमेज पुल करना

कंप्यूट नेटवर्क एडमिन

roles/compute.networkAdmin

वीपीएन नेटवर्किंग संसाधनों को मैनेज करना

डीएनएस एडमिन

roles/dns.admin

Cloud DNS ज़ोन और रिकॉर्ड मैनेज करना

इसके अलावा, roles/admin या लेगसी भूमिका roles/owner जैसी सामान्य भूमिका का इस्तेमाल करें.

अपने प्रोजेक्ट को ऐक्सेस करना

इस कोडलैब में, Google Cloud के किसी एक प्रोजेक्ट का इस्तेमाल किया जाता है. कॉन्फ़िगरेशन के चरणों में, gcloud सीएलआई और Linux शेल कमांड का इस्तेमाल किया जाता है.

सबसे पहले, अपने Google Cloud प्रोजेक्ट की कमांड लाइन ऐक्सेस करें:

प्रोजेक्ट आईडी सेट करना

gcloud config set project SET_YOUR_PROJECT_ID_HERE

सेशन की पुष्टि करना

# login to gcloud cli
gcloud auth login

# login for gcloud api
gcloud auth application-default login

शेल एनवायरमेंट वैरिएबल सेट करना

# set custom var for slug (eg, "foo") and region preference
export SLUG="foo"
export REGION="us-central1"
export MREGION="us"
echo ${SLUG}
echo ${REGION}
echo ${MREGION}

# create project vars (automatic)
export PROJ_ID=$(gcloud config list --format="value(core.project)")
export PROJ_NO=$(gcloud projects describe ${PROJ_ID} --format="value(projectNumber)")
export ORG_ID=$(gcloud projects get-ancestors ${PROJ_ID} --format="value(id)" | tail -n 1)
export USER_IDENTITY=$(gcloud config get-value account)
echo ${PROJ_ID}
echo ${PROJ_NO}
echo ${ORG_ID}
echo ${USER_IDENTITY}

# create resource vars (automatic)
export AGW_NAME="agw-${SLUG}-${REGION}-ata"
export AGW_URI="projects/${PROJ_ID}/locations/${REGION}/agentGateways/${AGW_NAME}"
export RE_AGENT_NAME="agent-weather"
export RE_AGENT_ID_SET="principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJ_NO}"
export STAGING_BUCKET="agent-staging-${PROJ_NO}"
export MCP_NAME="mcp-weather"
export MCP_DISPLAY_NAME="${MCP_NAME}-${PROJ_NO}.${REGION}.run.app"
export MCP_URL="https://${MCP_DISPLAY_NAME}/mcp"
echo ${AGW_NAME}
echo ${AGW_URI}
echo ${RE_AGENT_NAME}
echo ${RE_AGENT_ID_SET}
echo ${STAGING_BUCKET}
echo ${MCP_NAME}
echo ${MCP_DISPLAY_NAME}
echo ${MCP_URL}

# create local dir for config files
mkdir -p cfg

अगर Google Cloud SDK को खुद से मैनेज किया जा रहा है (यानी कि Cloud Shell के बाहर), तो कॉम्पोनेंट को नए वर्शन में अपडेट करें.

# update gcloud cli
gcloud components update

एपीआई सेवाएं चालू करना

# enable google apis (agent platform bundle, part 1)
gcloud services enable \
  agentregistry.googleapis.com \
  aiplatform.googleapis.com \
  apphub.googleapis.com \
  apptopology.googleapis.com \
  cloudapiregistry.googleapis.com \
  cloudtrace.googleapis.com \
  compute.googleapis.com \
  dataform.googleapis.com \
  iam.googleapis.com \
  iamconnectors.googleapis.com \
  iap.googleapis.com \
  logging.googleapis.com \
  modelarmor.googleapis.com \
  monitoring.googleapis.com \
  networksecurity.googleapis.com \
  networkservices.googleapis.com \
  notebooks.googleapis.com \
  observability.googleapis.com

# enable google apis (agent platform bundle, part 2)
gcloud services enable \
  securitycenter.googleapis.com \
  saasservicemgmt.googleapis.com \
  storage.googleapis.com \
  telemetry.googleapis.com \
  texttospeech.googleapis.com

# enable google apis (all the rest)
gcloud services enable \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  dns.googleapis.com

सेटअप का हिस्सा यहीं खत्म होता है... अब नेटवर्क सेक्शन पर जाएं.

4. नेटवर्क

वीपीसी नेटवर्क को कस्टम मोड का इस्तेमाल करके डिप्लॉय किया जाता है, ताकि पीएससी नेटवर्क अटैचमेंट के साथ काम करने वाले रेगुलर सबनेट बनाए जा सकें. ये सबनेट, एजेंट गेटवे और Cloud Run डायरेक्ट वीपीसी इग्रेस के लिए बनाए जाते हैं.

Google APIs के लिए पीएससी एंडपॉइंट को एक /32ग्लोबल इंटरनल IPv4 पते का इस्तेमाल करके डिप्लॉय किया जाता है, ताकि Cloud Run को निजी तौर पर इंटरनल ऐक्सेस किया जा सके. यह आईपी पता, किसी भी क्षेत्रीय सबनेट से असाइन नहीं किया गया है.

नेटवर्क बनाना

ग्लोबल वीपीसी नेटवर्क बनाएं.

# create vpc network
gcloud compute networks create vnet-${SLUG} --subnet-mode=custom

एजेंट गेटवे पीएससी नेटवर्क अटैचमेंट और Cloud Run डायरेक्ट वीपीसी इग्रेस के लिए सबनेट बनाएं.

# create subnet for agent gateway psc na
gcloud compute networks subnets create subnet-${REGION}-agw \
  --network=vnet-${SLUG} \
  --range=192.168.10.0/28 \
  --region=${REGION} \
  --enable-private-ip-google-access

# create subnet for cloud run dvpc egress
gcloud compute networks subnets create subnet-${REGION}-crun \
  --network=vnet-${SLUG} \
  --range=10.10.10.0/24 \
  --region=${REGION} \
  --enable-private-ip-google-access

फ़ायरवॉल के नियम बनाना

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

# create fw policy
gcloud compute network-firewall-policies create fw-policy-${SLUG} --global

# create fw policy rule
gcloud compute network-firewall-policies rules create 1001 \
  --description="allow all out and log" \
  --firewall-policy=fw-policy-${SLUG} \
  --global-firewall-policy \
  --action=allow \
  --direction=EGRESS \
  --layer4-configs=all \
  --dest-ip-ranges=0.0.0.0/0 \
  --enable-logging

# associate fw policy to vpc network
gcloud compute network-firewall-policies associations create \
  --name=fw-policy-bind-${SLUG} \
  --firewall-policy=fw-policy-${SLUG} \
  --network=vnet-${SLUG} \
  --global-firewall-policy

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

एक ऐसा पीएससी नेटवर्क अटैचमेंट बनाएं जिसे नए प्रोड्यूसर कनेक्शन को अपने-आप स्वीकार करने के लिए कॉन्फ़िगर किया गया हो.

# create psc network attachment
gcloud compute network-attachments create psc-na-${REGION}-agw \
  --region=${REGION} \
  --subnets=subnet-${REGION}-agw \
  --connection-preference=ACCEPT_AUTOMATIC

पीएसटीएन को नेटवर्क से अटैच करने की पुष्टि करना

# show psc network attachment details
gcloud compute network-attachments describe psc-na-${REGION}-agw --region=${REGION}

# fetch psc na uri
export PSC_NA_URI=$(gcloud compute network-attachments describe psc-na-${REGION}-agw \
  --region=${REGION} \
  --format="value(selfLink.scope(v1))")
echo ${PSC_NA_URI}

पीएससी एंडपॉइंट बनाना

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

# set env var for psc ep ip address
export PSC_EP_IP="240.0.0.10"
echo ${PSC_EP_IP}

# reserve internal global ipv4 address
gcloud compute addresses create ip-psc2gapis \
  --global \
  --purpose=PRIVATE_SERVICE_CONNECT \
  --addresses=${PSC_EP_IP} \
  --network=vnet-${SLUG}

all-apis बंडल का इस्तेमाल करके, Google API के लिए पीएससी एंडपॉइंट बनाएं. इसमें Cloud Run शामिल है (run.app).

# create psc endpoint for google apis
gcloud compute forwarding-rules create psc2gapis \
  --global \
  --network=vnet-${SLUG} \
  --address=ip-psc2gapis \
  --target-google-apis-bundle=all-apis

पीएसटीएन कैरियर के एंडपॉइंट की पुष्टि करना

# show psc endpoint details
gcloud compute forwarding-rules describe psc2gapis --global

डीएनएस ज़ोन और रिकॉर्ड बनाना

run.app डोमेन के लिए, Cloud DNS की मैनेज की गई प्राइवेट ज़ोन बनाएं.

# create private dns zone
gcloud dns managed-zones create priv-zone-run \
  --description="private zone for cloud run" \
  --dns-name="run.app." \
  --visibility=private \
  --networks=vnet-${SLUG}

पीएससी एंडपॉइंट के आईपी पते पर ले जाने वाले A के लिए, वाइल्डकार्ड डीएनएस A रिकॉर्ड बनाएं.*.run.app.

# create dns record
gcloud dns record-sets create *.run.app \
  --zone=priv-zone-run \
  --type=A \
  --ttl=300 \
  --rrdatas=${PSC_EP_IP}

डीएनएस क्वेरी लॉगिंग की सुविधा चालू करने के लिए, Cloud DNS की नीति बनाएं.

# create dns policy (logging)
gcloud dns policies create dns-policy-${SLUG} \
  --description="dns logging for vnet-${SLUG}" \
  --networks=vnet-${SLUG} \
  --enable-logging

Cloud NAT बनाना

एमसीपी सर्वर के लिए, Cloud Run डायरेक्ट वीपीसी इग्रेस की सुविधा चालू करें. इसके लिए, Cloud Router और Cloud NAT बनाएं, ताकि एमसीपी सर्वर, वीपीसी नेटवर्क के ज़रिए मौसम के बाहरी डेटा को ऐक्सेस कर सके.

# create router for nat
gcloud compute routers create cr-nat-${SLUG}-${REGION} \
  --network=vnet-${SLUG} \
  --asn=16550 \
  --region=${REGION}

# create nat gateway
gcloud compute routers nats create nat-${SLUG}-${REGION} \
  --router=cr-nat-${SLUG}-${REGION} \
  --region=${REGION} \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges

नेटवर्क का हिस्सा यहीं खत्म होता है... अब गेटवे सेक्शन पर जाएं.

5. गेटवे

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

यहां Agent Gateway, क्षेत्रीय रजिस्ट्री का इस्तेमाल करके, क्षेत्रीय एजेंट रनटाइम संसाधनों को सपोर्ट करता है. साथ ही, वीपीसी नेटवर्क पीएससी नेटवर्क अटैचमेंट और डीएनएस पियरिंग कॉन्फ़िगरेशन के लिए networkConfig फ़ील्ड तय करता है.

गेटवे बनाना

# create new agent gateway config file (with network settings)
cat > cfg/${AGW_NAME}-networkConfig.yaml << EOF
name: ${AGW_NAME}
protocols:
  - MCP
googleManaged:
  governedAccessPath: AGENT_TO_ANYWHERE
registries:
  - "//agentregistry.googleapis.com/projects/${PROJ_ID}/locations/${REGION}"
networkConfig:
  egress:
    networkAttachment: ${PSC_NA_URI}
  dnsPeeringConfig:
    domains:
      - run.app.
    targetProject: ${PROJ_ID}
    targetNetwork: projects/${PROJ_ID}/global/networks/vnet-${SLUG}
EOF

# import agent gateway config file (create gateway)
gcloud network-services agent-gateways import ${AGW_NAME} \
  --source="cfg/${AGW_NAME}-networkConfig.yaml" \
  --location=${REGION}

गेटवे की पुष्टि करना

# show agent gateway details
gcloud network-services agent-gateways describe ${AGW_NAME} \
  --location=${REGION}

# show psc network attachment details
gcloud compute network-attachments describe psc-na-${REGION}-agw --region=${REGION}

देखें कि कोई मान्य कनेक्शन एंडपॉइंट मौजूद हो.

connectionEndpoints:
- ipAddress: 192.168.10.2
  projectIdOrNum: '[AGW_PROJECT_NO]'
  status: ACCEPTED
  subnetwork: https://www.googleapis.com/compute/v1/projects/${PROJ_ID}/regions/${REGION}/subnetworks/subnet-${REGION}-agw

गेटवे का हिस्सा यहीं खत्म होता है... अब अनुमति सेक्शन पर जाएं.

6. अनुमति देना

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

  1. प्रतिनिधिमंडल का फ़्लो: जब कोई एजेंट किसी बाहरी एंडपॉइंट या एमसीपी सर्वर को चालू करने की कोशिश करता है, तो यह अनुरोध को एजेंट गेटवे पर भेज देता है. ऐक्सेस का आकलन स्थानीय तौर पर करने के बजाय, गेटवे, अनुमति देने वाले एक्सटेंशन का इस्तेमाल करके, IAP की आकलन सेवा को कॉलआउट भेजता है. IAP, एजेंट (SPIFFE पर आधारित) की पहचान की पुष्टि करता है. इसके लिए, एजेंट रजिस्ट्री में मौजूद टारगेट रिसॉर्स की IAM नीति का इस्तेमाल किया जाता है. IAP, गेटवे को ALLOW या DENY का फ़ैसला वापस भेजता है. इसके बाद, गेटवे या तो ट्रैफ़िक को आगे भेजता है या एचटीटीपी 403 Forbidden स्टेटस कोड के साथ उसे ब्लॉक कर देता है.
  2. लागू करने के मोड: DRY_RUN मोड में, IAP अनुरोधों का आकलन करता है और Cloud Logging में फ़ैसलों को लॉग करता है. हालांकि, इस दौरान ट्रैफ़िक को ब्लॉक नहीं किया जाता. ENFORCE मोड में, बिना अनुमति वाले एजेंट से किए गए किसी भी अनुरोध या बिना रजिस्टर किए गए टारगेट को तुरंत ब्लॉक कर दिया जाता है.
  3. बाइंडिंग लेयर: सेवा एक्सटेंशन, Agent Gateway से कनेक्ट होता है. इसके लिए, REQUEST_AUTHZ प्रोफ़ाइल के साथ कॉन्फ़िगर की गई अनुमति देने की नीति का इस्तेमाल किया जाता है.

पुष्टि करने वाला एक्सटेंशन

ऑथराइज़ेशन एक्सटेंशन, कनेक्टिविटी सेटिंग और अन्य पैरामीटर के साथ सुरक्षा सेवा देने वाली कंपनी के बारे में बताता है. ये पैरामीटर यह तय करते हैं कि सेवा कैसे काम करेगी और Agent Gateway के साथ कैसे इंटिग्रेट होगी.

authz एक्सटेंशन बनाना

# create authz extension config file (dry run mode)
cat > cfg/${AGW_NAME}-svc-ext-authz-iap-dryrun.yaml << EOF
name: ${AGW_NAME}-svc-ext-authz-iap-dryrun
service: iap.googleapis.com
failOpen: true
timeout: 1s
metadata:
  iamEnforcementMode: "DRY_RUN"
  iapPolicyVersion: "V1"
EOF

Import authz extension

# import authz extension file (create extension)
gcloud service-extensions authz-extensions import ${AGW_NAME}-svc-ext-authz-iap-dryrun \
  --source=cfg/${AGW_NAME}-svc-ext-authz-iap-dryrun.yaml \
  --location=${REGION}

Verify authz extension

# show authz extension details
gcloud service-extensions authz-extensions describe ${AGW_NAME}-svc-ext-authz-iap-dryrun \
  --location=${REGION}

प्राधिकरण नीति

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

अनुमति देने की नीति बनाना

# create authz policy config file (attach dry-run authz extension)
cat > cfg/${AGW_NAME}-authz-policy-profile-iap.yaml << EOF
name: ${AGW_NAME}-authz-policy-profile-iap
target:
  resources:
    - "projects/${PROJ_ID}/locations/${REGION}/agentGateways/${AGW_NAME}"
policyProfile: REQUEST_AUTHZ
action: CUSTOM
customProvider:
  authzExtension:
    resources:
      - "projects/${PROJ_ID}/locations/${REGION}/authzExtensions/${AGW_NAME}-svc-ext-authz-iap-dryrun"
EOF

Bind authz नीति

# import authz policy config file (enable authz policy)
gcloud beta network-security authz-policies import ${AGW_NAME}-authz-policy-profile-iap \
  --source=cfg/${AGW_NAME}-authz-policy-profile-iap.yaml \
  --location=${REGION}

अनुमति देने की नीति की पुष्टि करना

# show authz policy details
gcloud beta network-security authz-policies describe ${AGW_NAME}-authz-policy-profile-iap \
  --location=${REGION}

ऑथराइज़ेशन वाला हिस्सा यहीं खत्म होता है... अब कोडबेस सेक्शन पर जाएं.

7. कोडबेस

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

एजेंट रनटाइम के लिए, स्टोरेज का एक स्टैगिंग बकेट बनाया जाता है. इसका इस्तेमाल, पैकेज किए गए एजेंट ऐप्लिकेशन कोड और उसकी डिपेंडेंसी आर्टफ़ैक्ट को अपलोड, बिल्ड, और डिप्लॉय करने के लिए किया जाता है.

रिमोट आर्टफ़ैक्ट फ़ेच करना

# clone remote repository to temp local dir
git clone https://github.com/GoogleCloudPlatform/cloud-networking-solutions.git ./temp_agw_cuj_arun_egress_vpc

# copy agent runtime and endpoint definitions to working project dir
cp -r temp_agw_cuj_arun_egress_vpc/codelabs/agw-cuj-arun-egress-vpc/agent-weather ./agent-weather
cp -r temp_agw_cuj_arun_egress_vpc/codelabs/agw-cuj-arun-egress-vpc/mcp-weather ./mcp-weather

# remove temporary directory
rm -rf temp_agw_cuj_arun_egress_vpc

स्टेजिंग बकेट बनाना

# create storage bucket for agent deployment artifacts
gcloud storage buckets create gs://${STAGING_BUCKET} --location=${REGION}

# verify staging bucket url
gcloud storage buckets list --format="value(storage_url)"

कोडबेस का हिस्सा यहीं खत्म होता है... अब रजिस्ट्री सेक्शन पर जाएं.

8. रजिस्ट्री

एजेंट रजिस्ट्री, एआई के पूरे नेटवर्क में मौजूद सभी एजेंट, एमसीपी सर्वर, और एंडपॉइंट (एपीआई) की एक सेंट्रलाइज़्ड इन्वेंट्री होती है. यह एक कैटलॉग भी है. इसका इस्तेमाल, एआई ऐप्लिकेशन के लिए रजिस्टर किए गए अन्य टूल और सेवाओं को लिस्ट करने, खोजने, और उन्हें ढूंढने के लिए किया जा सकता है. Agent Gateway, रजिस्ट्री के डेटा मॉडल का इस्तेमाल, गवर्नेंस फ़्रेमवर्क के तौर पर करता है. इससे, डेटा को बाहर भेजने के ऐक्सेस कंट्रोल को लागू किया जा सकता है. प्रिंसिपल कॉलिंग एजेंट के लिए IAM रोल की अनुमतियों की जांच, रजिस्ट्री संसाधन से जुड़ी नीति के हिसाब से की जाती है.

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

एंडपॉइंट रजिस्टर करना

# create endpoint service (with multiple entries)
gcloud agent-registry services create core-gapi-services \
  --location=${REGION} \
  --display-name="gapi.core.services" \
  --description="core apis and services" \
  --endpoint-spec-type=no-spec \
  --interfaces=protocolBinding=JSONRPC,url=https://telemetry.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://cloudresourcemanager.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://iamcredentials.googleapis.com

एंडपॉइंट के रजिस्ट्रेशन की पुष्टि करना

# list registry regional endpoints
gcloud agent-registry endpoints list --location=${REGION} \
  --flatten="interfaces[]" \
  --format="table(displayName, name.basename():label=ENDPOINT_ID, interfaces.url:label=URL)"

रजिस्ट्री का यह हिस्सा पूरा हुआ... अब एमसीपी सर्वर सेक्शन पर जाएं.

9. एमसीपी सर्वर

डिप्लॉयमेंट के लिए IAM अनुमतियां देना

सोर्स कोड से Cloud Run सेवाओं को डिप्लॉय करने के लिए, Compute के डिफ़ॉल्ट सेवा खाते को अनुमतियां दें.

# grant cloud run builder role to default compute sa
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="serviceAccount:${PROJ_NO}-compute@developer.gserviceaccount.com" \
  --role="roles/run.builder"

IAM अनुमतियों की पुष्टि करना

# show iam policy on project for default compute sa
gcloud projects get-iam-policy ${PROJ_ID} \
  --flatten="bindings[].members" \
  --filter="bindings.members=serviceAccount:${PROJ_NO}-compute@developer.gserviceaccount.com" \
  --format="table(bindings.role:label=ROLE, bindings.members:label=PRINCIPAL_IDENTITY)"

एमसीपी सर्वर डिप्लॉय करना

# deploy cloud run service
gcloud -q run deploy ${MCP_NAME} \
  --source=mcp-weather/server \
  --region=${REGION} \
  --no-allow-unauthenticated \
  --min-instances=1 \
  --network=vnet-${SLUG} \
  --subnet=subnet-${REGION}-crun \
  --vpc-egress=all-traffic \
  --startup-probe=httpGet.path=/warmup

इनग्रेस के लिए IAM अनुमतियां देना

उपयोगकर्ता के ऐक्सेस के लिए नीति बाइंड करना

Cloud Run पर होस्ट किए गए एमसीपी सर्वर को चालू करने के लिए, उपयोगकर्ता खाते (खुद) को अनुमतियां दें. toolspec जनरेशन स्क्रिप्ट को चलाने के लिए यह ज़रूरी है.

# grant run invoker role to user account on cloud run service level
gcloud run services add-iam-policy-binding ${MCP_NAME} \
  --region=${REGION} \
  --member="user:${USER_IDENTITY}" \
  --role="roles/run.invoker"

IAM अनुमतियों की पुष्टि करना

# show iam policy on cloud run service for invoker role
gcloud run services get-iam-policy ${MCP_NAME} \
  --region=${REGION} \
  --flatten="bindings[].members" \
  --filter="bindings.role=roles/run.invoker" \
  --format="table(bindings.members:label=PRINCIPAL_IDENTITY, bindings.role:label=ROLE)"

एमसीपी को शुरू करने के लिए कस्टम एसए बनाना

Cloud Run पर होस्ट किए गए एमसीपी सर्वर को चालू करने के लिए, एक कस्टम सेवा खाता बनाएं. इस सेवा खाते का इस्तेमाल एजेंट करेगा. इससे वह Google के हस्ताक्षर वाला मान्य OIDC आईडी टोकन फ़ेच कर पाएगा, ताकि Cloud Run को ऐक्सेस किया जा सके.

# create custom sa for mcp server invocation
gcloud iam service-accounts create sa-${MCP_NAME}-invoker \
  --display-name="custom sa to invoke ${MCP_NAME}"

# set env var for service account identity
export MCP_INVOKER_SA="sa-${MCP_NAME}-invoker@${PROJ_ID}.iam.gserviceaccount.com"
echo ${MCP_INVOKER_SA}

सेवा खाते के लिए नीति बाइंड करना

# grant run invoker role to custom sa on cloud run service level
gcloud run services add-iam-policy-binding ${MCP_NAME} \
  --role="roles/run.invoker" \
  --member="serviceAccount:${MCP_INVOKER_SA}" \
  --region=${REGION}

IAM अनुमतियों की पुष्टि करना

# show iam policy on cloud run service for invoker role
gcloud run services get-iam-policy ${MCP_NAME} \
  --region=${REGION} \
  --flatten="bindings[].members" \
  --filter="bindings.role=roles/run.invoker" \
  --format="table(bindings.members:label=PRINCIPAL_IDENTITY, bindings.role:label=ROLE)"

पुष्टि करने के लिए आईएएम अनुमतियां देना

डिफ़ॉल्ट Compute सेवा खाते को, सेवा खाते के डुप्लीकेट की भूमिकाएं असाइन करें. इससे, ऐप्लिकेशन डिफ़ॉल्ट क्रेडेंशियल (एडीसी) के तहत काम करने वाले एजेंट को, कस्टम इन्वोकर सेवा खाते की ओर से Google के हस्ताक्षर वाले ओआईडीसी आईडी टोकन मिंट करने की अनुमति मिल जाएगी. इससे Cloud Run पर किए जाने वाले कॉल की पुष्टि की जा सकेगी.

पुष्टि के लिए नीति बाइंड करना

# grant oidc token creator role to default compute service account
gcloud iam service-accounts add-iam-policy-binding ${MCP_INVOKER_SA} \
  --role="roles/iam.serviceAccountOpenIdTokenCreator" \
  --member="serviceAccount:${PROJ_NO}-compute@developer.gserviceaccount.com"

# grant service account token creator role to default compute service account
gcloud iam service-accounts add-iam-policy-binding ${MCP_INVOKER_SA} \
  --role="roles/iam.serviceAccountTokenCreator" \
  --member="serviceAccount:${PROJ_NO}-compute@developer.gserviceaccount.com"

IAM अनुमतियों की पुष्टि करना

# show iam policy for the custom service account
gcloud iam service-accounts get-iam-policy ${MCP_INVOKER_SA} \
  --flatten="bindings[].members" \
  --format="table(bindings.role:label=ROLE, bindings.members:label=PRINCIPAL_IDENTITY)"

एमसीपी toolspec बनाना

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

mcp-weather/ कोडबेस में शामिल test_mcp.py स्क्रिप्ट, टारगेट एमसीपी सर्वर (एसएसई या एचटीटीपी पर) से कनेक्ट करके toolspec.json फ़ाइल जनरेट करती है. साथ ही, सर्वर से उपलब्ध कराए गए सभी टूल को वापस पाने के लिए, list_tools() को कॉल करती है.

# fetch oidc token for cloud run authentication
export OIDC_TOKEN=$(gcloud auth print-identity-token)

# generate toolspec for registry ingestion
uv --directory mcp-weather run test_mcp.py --toolspec=include --token="${OIDC_TOKEN}"

जनरेट किए गए toolspec आउटपुट से पता चलता है कि एजेंट गेटवे, ईग्रेस नीति के आकलन और उसे लागू करने के लिए, एमसीपी एट्रिब्यूट का इस्तेमाल कर सकता है.

MCP toolspec की पुष्टि करें

# show toolspec mcp attributes
jq '.tools[] | {name, isReadOnly, isDestructive, isIdempotent, isOpenWorld}' mcp-weather/toolspec.json

Cloud Run के इन्ग्रेस को अपडेट करना

Cloud Run सेवा के लिए, इनग्रेस सेटिंग बदलें, ताकि वह सिर्फ़ वीपीसी नेटवर्क से आने वाले अनुरोधों को स्वीकार करे. इससे, एमसीपी एंडपॉइंट को सीधे तौर पर सार्वजनिक ऐक्सेस नहीं मिलता. साथ ही, सिर्फ़ इंटरनल संसाधनों को इसे ऐक्सेस करने की अनुमति मिलती है. वीपीसी नेटवर्क में Google API के लिए, पीएससी एंडपॉइंट पर जाने वाले ट्रैफ़िक को इंटरनल इनग्रेस माना जाएगा और इसकी अनुमति दी जाएगी.

# update cloud run service config
gcloud run services update ${MCP_NAME} \
  --region=${REGION} \
  --ingress=internal

Cloud Run इन्ग्रेस की पुष्टि करना

# show cloud run service details
gcloud run services describe ${MCP_NAME} --region=${REGION} | grep -iE 'ingress|egress'

एमसीपी सर्वर रजिस्टर करना

अब toolspec मिलने के बाद, एमसीपी सर्वर को क्षेत्रीय एजेंट रजिस्ट्री में रजिस्टर करें.

# register mcp server
gcloud agent-registry services create ${MCP_NAME} \
  --location=${REGION} \
  --display-name="${MCP_DISPLAY_NAME}" \
  --description="mcp server for weather info" \
  --mcp-server-spec-type=tool-spec \
  --mcp-server-spec-content=mcp-weather/toolspec.json \
  --interfaces=url=${MCP_URL},protocolBinding=JSONRPC

MCP रजिस्ट्रेशन की पुष्टि करना

# list registry regional mcp servers
gcloud agent-registry mcp-servers list --location=${REGION} --format="table(displayName, interfaces.url)"

# show mcp server registry details
gcloud agent-registry services describe ${MCP_NAME} --location=${REGION}

# fetch mcp server registry id
export MCP_REGISTRY_ID=$(gcloud agent-registry services describe ${MCP_NAME} \
  --location=${REGION} \
  --format="value(registryResource.basename())")
echo ${MCP_REGISTRY_ID}

एमसीपी सर्वर सेक्शन यहां खत्म होता है... अब ADK एजेंट सेक्शन पर चलते हैं.

10. ADK एजेंट

Agent Runtime में डिप्लॉय किए गए agent-weather ADK एजेंट को, Agent Platform के साथ इंटिग्रेट करने के लिए डिप्लॉयमेंट स्क्रिप्ट में इन सेटिंग के साथ कॉन्फ़िगर किया जाता है:

  • "identity_type": types.IdentityType.AGENT_IDENTITY, ताकि एजेंट के लिए यूनीक SPIFFE पर आधारित प्रिंसिपल आइडेंटिटी उपलब्ध कराई जा सके
  • "agent_gateway_config": { "agent_to_anywhere_config": {"agent_gateway": } } का इस्तेमाल करके, एजेंट की ओर से शुरू किए गए सभी आउटबाउंड ट्रैफ़िक को नीति के उल्लंघन का आकलन करने और उसे लागू करने के लिए, एजेंट गेटवे पर भेजें

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

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

# deploy agent runtime workload
uv --directory agent-weather run python3 deploy_agent.py \
  --project=${PROJ_ID} \
  --region=${REGION} \
  --src-dir=./agent \
  --staging-bucket=${STAGING_BUCKET} \
  --display-name="${RE_AGENT_NAME}" \
  --description="agent for weather info" \
  --mcp-server-url="${MCP_URL}" \
  --mcp-invoker-sa="${MCP_INVOKER_SA}" \
  --enable-telemetry \
  --enable-agent-identity \
  --agent-gateway-egress=${AGW_URI} \
  --allow-token-sharing

डिप्लॉयमेंट की पुष्टि करना

डिप्लॉयमेंट की परफ़ॉर्मेंस से जुड़ी अहम जानकारी फ़ेच करना

# fetch agent runtime resource (reasoning engine) id
export RE_ENGINE_ID=$(curl -s -X GET "https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJ_ID}/locations/${REGION}/reasoningEngines" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" | \
  jq -r --arg name "${RE_AGENT_NAME}" '.reasoningEngines[] | select(.displayName==$name) | .name | split("/") | last')
echo ${RE_ENGINE_ID}

# fetch agent runtime (reasoning engine) agent identity
export RE_AGENT_IDENTITY=$(gcloud agent-registry agents list \
  --location=${REGION} --filter="displayName=${RE_AGENT_NAME}" \
  --format="value(attributes.'agentregistry.googleapis.com/system/RuntimeIdentity'.principal)")
echo ${RE_AGENT_IDENTITY}

# fetch agent registry uid for agent
export RE_AGENT_REGISTRY_ID=$(gcloud agent-registry agents list \
  --location=${REGION} \
  --filter="displayName=${RE_AGENT_NAME}" \
  --format="value(uid)")
echo ${RE_AGENT_REGISTRY_ID}

रजिस्ट्री एंट्री की पुष्टि करना

# show agent resource registry details
gcloud agent-registry agents describe ${RE_AGENT_REGISTRY_ID} --location=${REGION}

गेटवे के कॉन्फ़िगरेशन की पुष्टि करना

# show agent config details (gateway config)
curl -s -X GET "https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJ_ID}/locations/${REGION}/reasoningEngines/${RE_ENGINE_ID}" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  | jq '{displayName: .displayName, name: .name, effectiveIdentity: .spec.effectiveIdentity, agentGatewayConfig: .spec.deploymentSpec.agentGatewayConfig}'

पुष्टि करने के लिए आईएएम अनुमतियां देना

जब किसी एजेंट को एजेंट आइडेंटिटी का इस्तेमाल करने के लिए कॉन्फ़िगर किया जाता है, तो उसे फ़ेडरेटेड सिक्योरिटी टोकन सर्विस (एसटीएस) से एक टोकन (JWT-SVID फ़ॉर्मैट) मिलता है. इस पर sts.googleapis.com (एसपीआईएफ़ई आइडेंटिटी प्रोवाइडर) के हस्ताक्षर होते हैं.

हालांकि, Cloud Run में पहले से मौजूद IAM इनवॉकर की जांच करने की सुविधा, सिर्फ़ मुख्य Google OIDC जारी करने वाले (accounts.google.com) के हस्ताक्षर किए गए स्टैंडर्ड OIDC आईडी टोकन पर भरोसा करती है और उनकी पुष्टि कर सकती है.

इसलिए, कस्टम सेवा खाते का इस्तेमाल, फ़ेडरेट किए गए एसटीएस टोकन (JWT-SVID) को बदलने के लिए किया जाता है. यह टोकन, एजेंट की पहचान से मिलता है. इसे रनटाइम में सेवा खाते की नकली पहचान का इस्तेमाल करके, स्टैंडर्ड Google (OIDC) टोकन में बदला जाता है.

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

पुष्टि करने के लिए नीति बाइंड करें (किसी दूसरे के नाम पर काम करना)

# grant service account token creator role to agent principal identity
gcloud iam service-accounts add-iam-policy-binding ${MCP_INVOKER_SA} \
  --role="roles/iam.serviceAccountTokenCreator" \
  --member="${RE_AGENT_IDENTITY}"

# grant service account openid token creator role to agent principal identity
gcloud iam service-accounts add-iam-policy-binding ${MCP_INVOKER_SA} \
  --role="roles/iam.serviceAccountOpenIdTokenCreator" \
  --member="${RE_AGENT_IDENTITY}"

IAM अनुमतियों की पुष्टि करना

# show iam policy for custom service account
gcloud iam service-accounts get-iam-policy ${MCP_INVOKER_SA} \
  --flatten="bindings[].members" \
  --format="table(bindings.members.sub('^.*locations/', '.../locations/'):label=PRINCIPAL_IDENTITY, bindings.role:label=ROLE)"

रनटाइम के लिए IAM अनुमतियां देना

रंटाइम के लिए IAM अनुमतियां देने से, एजेंट को AI प्लैटफ़ॉर्म की सेवाओं और Google के अन्य मुख्य एपीआई और सेवाओं को ऐक्सेस करने की अनुमति मिलती है. इसके लिए, एजेंट अपनी SPIFFE पर आधारित मुख्य एजेंट पहचान का इस्तेमाल करता है. इन नीतियों को संसाधन लेवल पर IAM का इस्तेमाल करके लागू किया जाता है.

एजेंट की पहचान के लिए ज़रूरी भूमिकाएं असाइन करें.

एजेंट के ऐक्सेस के लिए नीतियां बाइंड करना

# grant ai platform user role
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="${RE_AGENT_IDENTITY}" \
  --role="roles/aiplatform.user"

# grant agent default access role
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="${RE_AGENT_IDENTITY}" \
  --role="roles/aiplatform.agentDefaultAccess"

# grant agent registry viewer role
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="${RE_AGENT_IDENTITY}" \
  --role="roles/agentregistry.viewer"

# grant cloud logging writer role
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="${RE_AGENT_IDENTITY}" \
  --role="roles/logging.logWriter"

# grant cloud monitoring writer role
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="${RE_AGENT_IDENTITY}" \
  --role="roles/monitoring.metricWriter"

# grant browser role for resource manager lookup
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="${RE_AGENT_IDENTITY}" \
  --role="roles/browser"

IAM अनुमतियों की पुष्टि करना

# show iam policy on project for agent identity
gcloud projects get-iam-policy ${PROJ_ID} \
  --flatten="bindings[].members" \
  --filter="bindings.members:${RE_AGENT_IDENTITY}" \
  --format="table(bindings.members.sub('^.*locations/', '.../locations/'):label=PRINCIPAL_IDENTITY, bindings.role:label=ROLE)"

ADK एजेंट के बारे में जानकारी देने वाला सेक्शन यहां खत्म होता है... अब नीतियों वाले सेक्शन पर चलते हैं.

11. नीतियां

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

एजेंट गेटवे से बाहर निकलने के लिए IAM रोल असाइन करने से, ऐक्सेस से जुड़ी ऐसी नीतियां लागू की जा सकती हैं जिनसे एजेंट प्रिंसिपल आइडेंटिटी को, रजिस्टर किए गए डेस्टिनेशन संसाधनों का ऐक्सेस मिलता है. यह ऐक्सेस, एजेंट गेटवे के ज़रिए मिलता है. नीतियों को एजेंट गेटवे लेवल पर लागू किया जाता है. साथ ही, Identity-Aware Proxy (IAP) की IAM नीतियों का इस्तेमाल करके इनकी पुष्टि की जाती है.

एजेंट गेटवे से डेटा बाहर भेजने के लिए, IAM भूमिकाएं असाइन करना

Agent Gateway, आने वाले अनुरोधों की जांच करता है. इससे यह पुष्टि की जाती है कि कॉल करने वाले एजेंट की पहचान की पुष्टि हो गई है और उसके पास टारगेट संसाधन पर iap.webServiceVersions.egressViaIAP अनुमति है. यह अनुमति, roles/iap.egressor की भूमिका के तहत दी जाती है.

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

IAM नीतियां, डेस्टिनेशन रिसॉर्स से जुड़ी होती हैं. इनके बारे में एजेंट रजिस्ट्री के डेटा मॉडल में बताया गया है. iap_web/agentRegistry संसाधन, IAM हैरारकी में "रजिस्ट्री-वाइड" लेवल को दिखाता है. यहां agentRegistry, agents, mcpServers, और endpoints के लिए अलग-अलग चाइल्ड रिसॉर्स के पैरंट के तौर पर काम करता है. इस कोडलैब में, IAM नीति को mcpServer और endpoint लेवल से जोड़ा गया है. इससे, खास चाइल्ड रिसॉर्स के लिए अनुमति लागू होती है.

एमसीपी सर्वर के लिए एजेंट की नीति कॉन्फ़िगर करना

एजेंट से एमसीपी सर्वर तक के लिए नीति बनाना

# fetch active etag on policy for mcp server
export IAP_ETAG=$(gcloud beta iap web get-iam-policy \
  --resource-type=agent-registry --region=${REGION} \
  --mcp-server=${MCP_REGISTRY_ID} --format="value(etag)")
echo ${IAP_ETAG}

ध्यान दें: etag: को डिफ़ॉल्ट ACAB वैल्यू दिखानी चाहिए, क्योंकि अब तक कोई नीति तय नहीं की गई है.

# create policy config file
cat > cfg/iap-policy-agent-to-mcp.json << EOF
{
  "bindings": [
    {
      "role": "roles/iap.egressor",
      "members": [
        "${RE_AGENT_IDENTITY}"
      ]
    }
  ],
  "etag": "${IAP_ETAG}"
}
EOF

एजेंट के लिए, एमसीपी सर्वर से जुड़ी नीति

# import policy file
gcloud beta iap web set-iam-policy cfg/iap-policy-agent-to-mcp.json \
  --resource-type=agent-registry \
  --mcp-server=${MCP_REGISTRY_ID} \
  --region=${REGION}

IAM अनुमतियों की पुष्टि करना

# show iap iam policy on mcp server for agent
gcloud beta iap web get-iam-policy \
  --region=${REGION} \
  --resource-type=agent-registry \
  --mcp-server=${MCP_REGISTRY_ID}

नीतियों से जुड़ा सेक्शन यहीं खत्म होता है... अब ऑडिट सेक्शन पर चलते हैं.

12. ऑडिट

Agent Gateway authorization एक्सटेंशन, DRY_RUN मोड में काम कर रहा है. आउटबाउंड अनुरोधों को देखा और लॉग किया जाता है, लेकिन उन्हें ब्लॉक नहीं किया जाता. ENFORCED मोड पर स्विच करने से पहले लॉग का विश्लेषण करने से, यह पुष्टि की जा सकेगी कि ज़रूरी ट्रैफ़िक को अनुमति देने के लिए, किन नीतियों को कॉन्फ़िगर करना होगा.

एजेंट की क्वेरी की जांच करना

Google Cloud Console के यूज़र इंटरफ़ेस (यूआई) के लिए ब्राउज़र विंडो खोलें और यहां जाएं:

  • Agent Platform → Agents → Deployments → agent-weather
  • प्लेग्राउंड टैब चुनें

इसके अलावा, इस टर्मिनल कमांड को दोहराएं और एजेंट के प्लेग्राउंड पर जाने के लिए लिंक पर क्लिक करें:

# playground
echo "https://console.cloud.google.com/agent-platform/runtimes/locations/${REGION}/agent-engines/${RE_ENGINE_ID}/playground?project=${PROJ_ID}"

कुछ टेस्ट क्वेरी सबमिट करें....

  • What is the weather like in London?
  • How warm is it in New York?

पुष्टि करें कि क्वेरी के जवाब सही हैं.

ऑडिट लॉग का विश्लेषण करना

लॉग देखें और नीति के उल्लंघन की जांच करने के लिए, ड्राई-रन के तौर पर किए गए आकलन की जांच करें.

# show gateway logs for endpoints and authz status (duplicates removed)
gcloud logging read \
  "resource.type=\"networkservices.googleapis.com/Gateway\" \
  AND httpRequest.requestUrl:*" \
  --project=${PROJ_ID} \
  --limit=50 \
  --freshness=24h \
  --format="table( \
    timestamp.date(tz=LOCAL):label=TIMESTAMP, \
    httpRequest.status:label=STATUS, \
    jsonPayload.authzPolicyInfo.result:label=AUTHZ, \
    httpRequest.requestUrl.sub('(https?://[^/:]+).*', '\1'):label=ENDPOINT \
  )" | awk 'NR==1 {print; next} ! seen[$2,$3,$4]++'

TIMESTAMP            STATUS  AUTHZ    ENDPOINT
YYYY-MM-DDTHH:MM:SS  200     ALLOWED  https://cloudresourcemanager.googleapis.com
YYYY-MM-DDTHH:MM:SS  200     ALLOWED  https://${REGION}-aiplatform.googleapis.com
YYYY-MM-DDTHH:MM:SS  200     ALLOWED  https://iamcredentials.googleapis.com
YYYY-MM-DDTHH:MM:SS  200     ALLOWED  https://mcp-weather-${PROJ_NO}.${REGION}.run.app
YYYY-MM-DDTHH:MM:SS  200     ALLOWED  https://telemetry.googleapis.com
YYYY-MM-DDTHH:MM:SS  202     ALLOWED  https://mcp-weather-${PROJ_NO}.${REGION}.run.app

एजेंट से एंडपॉइंट तक की नीति कॉन्फ़िगर करना

ऐसा इसलिए है, क्योंकि agent-weather के लिए मुख्य Google API, रजिस्ट्री (gapi.core.services) में एक सामूहिक एंडपॉइंट सेवा के तहत रजिस्टर किए गए थे. इसलिए, एंडपॉइंट ऐक्सेस करने के लिए एजेंट को बाहर निकलने की अनुमतियां देने के लिए, सिर्फ़ एक नीति की ज़रूरत होती है.

एजेंट से एंडपॉइंट तक के लिए नीति बनाना

# set var for endpoint display name
export ENDPOINT_DISPLAY_NAME="gapi.core.services"
echo ${ENDPOINT_DISPLAY_NAME}

# fetch endpoint registry id
export ENDPOINT_REGISTRY_ID=$(gcloud agent-registry services list \
  --location=${REGION} \
  --filter="displayName=${ENDPOINT_DISPLAY_NAME}" \
  --format="value(registryResource.basename())")
echo ${ENDPOINT_REGISTRY_ID}

# create policy config file
cat > cfg/iap-policy-agent-to-ep.json << EOF
{
  "bindings": [
    {
      "role": "roles/iap.egressor",
      "members": [
        "${RE_AGENT_IDENTITY}"
      ]
    }
  ]
}
EOF

एजेंट के लिए एंडपॉइंट से नीति को बाइंड करना

# import policy file (bind iam policy)
gcloud -q beta iap web set-iam-policy cfg/iap-policy-agent-to-ep.json \
  --resource-type=agent-registry \
  --endpoint=${ENDPOINT_REGISTRY_ID} \
  --region=${REGION}

IAM अनुमतियों की पुष्टि करना

# show iap iam policy on endpoint for agent
gcloud beta iap web get-iam-policy \
  --region=${REGION} \
  --resource-type=agent-registry \
  --endpoint=${ENDPOINT_REGISTRY_ID}

ऑडिट का यह हिस्सा यहीं खत्म होता है... अब लागू करें सेक्शन पर जाएं.

13. लागू करें

एजेंट, DRY_RUN मोड में गेटवे के ज़रिए अनुरोध कर सका. ऐक्सेस लॉग और एंडपॉइंट का विश्लेषण करके, गवर्नेंस से जुड़ी नीतियों का एक सेट बनाया गया. इससे एजेंट से ज़रूरी इग्रेस ट्रैफ़िक की अनुमति दी जा सकती है. अब अनुमति देने की नीति को अपडेट करके, Agent Gateway IAP की अनुमति देने वाले एक्सटेंशन को ENFORCE मोड में बदलें.

अनुमति देने वाले एक्सटेंशन को अपडेट करना

authz एक्सटेंशन बनाना

# create authz extension config file (enforced mode)
cat > cfg/${AGW_NAME}-svc-ext-authz-iap-enforced.yaml << EOF
name: ${AGW_NAME}-svc-ext-authz-iap-enforced
service: iap.googleapis.com
failOpen: false
timeout: 1s
metadata:
  iapPolicyVersion: "V1"
EOF

Import authz extension

# import authz extension file (create extension)
gcloud service-extensions authz-extensions import ${AGW_NAME}-svc-ext-authz-iap-enforced \
  --source=cfg/${AGW_NAME}-svc-ext-authz-iap-enforced.yaml \
  --location=${REGION}

Verify authz extension

# list authz extensions (imported configs)
gcloud service-extensions authz-extensions list --location=${REGION}

अनुमति से जुड़ी नीति अपडेट करना

अनुमति देने की नीति बनाना

# re-write authz policy config file (pointing to enforced authz extension)
cat > cfg/${AGW_NAME}-authz-policy-profile-iap.yaml << EOF
name: ${AGW_NAME}-authz-policy-profile-iap
target:
  resources:
    - "projects/${PROJ_ID}/locations/${REGION}/agentGateways/${AGW_NAME}"
policyProfile: REQUEST_AUTHZ
action: CUSTOM
customProvider:
  authzExtension:
    resources:
      - "projects/${PROJ_ID}/locations/${REGION}/authzExtensions/${AGW_NAME}-svc-ext-authz-iap-enforced"
EOF

Bind authz नीति

# import authz policy config file (enable new authz policy)
gcloud beta network-security authz-policies import ${AGW_NAME}-authz-policy-profile-iap \
  --source=cfg/${AGW_NAME}-authz-policy-profile-iap.yaml \
  --location=${REGION}

अनुमति देने की नीति की पुष्टि करना

# show authz policy details (verify enforced mode)
gcloud beta network-security authz-policies describe ${AGW_NAME}-authz-policy-profile-iap \
  --location=${REGION}

एनफ़ोर्समेंट की पुष्टि करना

कंसोल के यूज़र इंटरफ़ेस (यूआई) में, एजेंट प्लेग्राउंड पर वापस जाएं.

  • नया चैट सेशन बनाने के लिए, "+ नया सेशन" बटन पर क्लिक करें

जांच के लिए कोई और क्वेरी सबमिट करें...

  • What is the current temperature in Los Angeles?

ध्यान दें कि Gemini foundation मॉडल (${REGION}-aiplatform.googleapis.com/...) और एमसीपी सर्वर एंडपॉइंट (mcp-weather-${PROJ_NO}.${REGION}.run.app/mcp) को भेजे गए एजेंट के अनुरोध, एचटीटीपी 200 OK स्टेटस कोड के साथ पास किए जाते हैं.

गेटवे लॉग का विश्लेषण करना

# show gateway logs for http requests
gcloud logging read \
  "resource.type=\"networkservices.googleapis.com/Gateway\" \
  AND httpRequest.requestUrl:*" \
  --project=${PROJ_ID} \
  --limit=10 \
  --format="table(
    timestamp.date(tz=LOCAL):label=TIMESTAMP,
    httpRequest.requestMethod:label=METHOD,
    httpRequest.status:label=STATUS,
    jsonPayload.authzPolicyInfo.result:label=IAP_AUTHZ,
    jsonPayload.agentGatewayInfo.mcpInfo.method:label=MCP_METHOD,
    httpRequest.requestUrl:label=URL)"

देखें कि कोई अनुरोध ब्लॉक न किया गया हो. गेटवे के ऑडिट लॉग में, एचटीटीपी 403 Forbidden स्टेटस कोड के साथ, बाहर निकलने के किसी भी ऐसे अनुरोध को ढूंढें जिसे अस्वीकार कर दिया गया हो.

# show gateway logs for authz denies
gcloud logging read \
  "resource.type=\"networkservices.googleapis.com/Gateway\" \
  AND (jsonPayload.authzPolicyInfo.result=\"DENIED\" OR httpRequest.status=403)" \
  --project=${PROJ_ID} \
  --limit=10 \
  --format="table(
    timestamp.date(tz=LOCAL):label=TIMESTAMP,
    httpRequest.requestMethod:label=METHOD,
    httpRequest.status:label=STATUS,
    jsonPayload.enforcedGatewaySecurityPolicy.serverNameIndication:label=SNI,
    jsonPayload.authzPolicyInfo.result:label=AUTHZ_RESULT,
    jsonPayload.authzPolicyInfo.policies[0].name.basename():label=DENYING_POLICY
  )"

Agent Gateway के एमसीपी लॉग देखें. साथ ही, ध्यान दें कि प्रोटोकॉल मेटाडेटा को दिखाने के लिए, एमसीपी ऐप्लिकेशन पेलोड (JSON-RPC) की जांच कैसे की जाती है. इसमें यह भी शामिल है कि कौनसे टूल इस्तेमाल किए जा रहे हैं.

# show gateway logs for mcp requests with method and tool name
gcloud logging read \
  "resource.type=\"networkservices.googleapis.com/Gateway\" \
  AND jsonPayload.agentGatewayInfo.mcpInfo.method:*" \
  --project=${PROJ_ID} \
  --limit=10 \
  --format="table(
    timestamp.date(tz=LOCAL):label=TIMESTAMP,
    httpRequest.status:label=STATUS,
    jsonPayload.authzPolicyInfo.result:label=IAP_AUTHZ,
    jsonPayload.agentGatewayInfo.mcpInfo.method:label=MCP_METHOD,
    jsonPayload.agentGatewayInfo.mcpInfo.parameter:label=TOOL_NAME,
    httpRequest.requestUrl:label=URL
  )"

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

नेटवर्क फ़ायरवॉल की नीति से जुड़े नियम की प्राथमिकता 1001 के लिए लॉग देखें.

# show firewall logs for rule 1001
gcloud logging read \
  "jsonPayload.rule_details.priority=1001" \
  --project=${PROJ_ID} \
  --limit=10 \
  --format="table(
    timestamp.date(tz=LOCAL):label=TIMESTAMP,
    jsonPayload.disposition:label=ACTION,
    jsonPayload.connection.src_ip:label=SRC_IP,
    jsonPayload.connection.dest_ip:label=DEST_IP,
    jsonPayload.connection.dest_port:label=DEST_PORT,
    jsonPayload.vpc.subnetwork_name:label=SUBNET
  )"

अलग-अलग ट्रैफ़िक पाथ के नेटवर्क-लेवल के व्यू पर ध्यान दें:

  • subnet-${REGION}-agw का इस्तेमाल करके, इंटरनल वीपीसी नेटवर्क के संसाधनों से कम्यूनिकेट करने वाला एजेंट गेटवे
  • Cloud Run पर होस्ट किया गया एमसीपी सर्वर, subnet-${REGION}-crun का इस्तेमाल करके मौसम की जानकारी देने वाले बाहरी एपीआई को कॉल कर रहा है
TIMESTAMP            ACTION   SRC_IP        DEST_IP        DEST_PORT  SUBNET
YYYY-MM-DDTHH:MM:SS  ALLOWED  10.10.10.16   188.40.99.226  443        subnet-${REGION}-crun
YYYY-MM-DDTHH:MM:SS  ALLOWED  10.10.10.16   202.61.206.6   443        subnet-${REGION}-crun
YYYY-MM-DDTHH:MM:SS  ALLOWED  10.10.10.16   188.40.99.226  443        subnet-${REGION}-crun
YYYY-MM-DDTHH:MM:SS  ALLOWED  10.10.10.16   202.61.206.6   443        subnet-${REGION}-crun
YYYY-MM-DDTHH:MM:SS  ALLOWED  10.10.10.16   202.61.206.6   443        subnet-${REGION}-crun
YYYY-MM-DDTHH:MM:SS  ALLOWED  10.10.10.16   202.61.206.6   443        subnet-${REGION}-crun
YYYY-MM-DDTHH:MM:SS  ALLOWED  192.168.10.2  240.0.0.10     443        subnet-${REGION}-agw
YYYY-MM-DDTHH:MM:SS  ALLOWED  192.168.10.2  240.0.0.10     443        subnet-${REGION}-agw
YYYY-MM-DDTHH:MM:SS  ALLOWED  192.168.10.2  240.0.0.10     443        subnet-${REGION}-agw

डीएनएस लॉग का विश्लेषण करना

निजी डीएनएस ज़ोन (priv-zone-run) से हल की गई अनुरोधों के लिए, डीएनएस क्वेरी के लॉग देखें.

gcloud logging read \
  "resource.type=\"dns_query\" AND resource.labels.target_name=\"priv-zone-run\"" \
  --project=${PROJ_ID} \
  --limit=10 \
  --format="table(
    timestamp.date(tz=LOCAL):label=TIMESTAMP,
    jsonPayload.queryName:label=QUERY_NAME,
    jsonPayload.queryType:label=TYPE,
    jsonPayload.rdata:label=RESPONSE_RDATA,
    jsonPayload.sourceNetwork:label=NETWORK,
    resource.labels.source_type:label=SRC_TYPE
  )"

ध्यान दें कि Cloud Run सेवा (mcp-weather...run.app) के लिए डीएनएस लुकअप, डीएनएस पीयरिंग का इस्तेमाल करके वीपीसी नेटवर्क से शुरू होते हैं. साथ ही, Google API (240.0.0.10) के लिए इंटरनल पीएससी एंडपॉइंट पर सफलतापूर्वक हल किए जाते हैं.

TIMESTAMP            QUERY_NAME                                     TYPE  RESPONSE_RDATA                                                     NETWORK   SRC_TYPE
YYYY-MM-DDTHH:MM:SS  mcp-weather-${PROJ_NO}.${REGION}.run.app.  A     mcp-weather-${PROJ_NO}.${REGION}.run.app. 300     IN      a       240.0.0.10  vnet-${SLUG}  peering-zone
YYYY-MM-DDTHH:MM:SS  mcp-weather-${PROJ_NO}.${REGION}.run.app.  A     mcp-weather-${PROJ_NO}.${REGION}.run.app. 300     IN      a       240.0.0.10  vnet-${SLUG}  peering-zone
YYYY-MM-DDTHH:MM:SS  mcp-weather-${PROJ_NO}.${REGION}.run.app.  A     mcp-weather-${PROJ_NO}.${REGION}.run.app. 300     IN      a       240.0.0.10  vnet-${SLUG}  peering-zone
YYYY-MM-DDTHH:MM:SS  mcp-weather-${PROJ_NO}.${REGION}.run.app.  A     mcp-weather-${PROJ_NO}.${REGION}.run.app. 300     IN      a       240.0.0.10  vnet-${SLUG}  peering-zone

नीति उल्लंघन ठीक करने से जुड़ा सेक्शन यहां खत्म होता है... अब सफ़ाई सेक्शन पर चलते हैं.

14. साफ़-सफ़ाई सेवा 

# delete agent runtime
curl -s -X DELETE "https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJ_ID}/locations/${REGION}/reasoningEngines/${RE_ENGINE_ID}?force=true" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)"

# next

# delete agent resources
gcloud -q storage rm --recursive gs://${STAGING_BUCKET}

for ROLE in \
  "roles/aiplatform.user" \
  "roles/aiplatform.agentDefaultAccess" \
  "roles/agentregistry.viewer" \
  "roles/logging.logWriter" \
  "roles/monitoring.metricWriter" \
  "roles/browser"; do
  gcloud -q projects remove-iam-policy-binding ${PROJ_ID} \
    --member="${RE_AGENT_IDENTITY}" \
    --role="${ROLE}"
done

# next

# delete mcp (cloud run) resources
gcloud -q projects remove-iam-policy-binding ${PROJ_ID} \
  --member="serviceAccount:${PROJ_NO}-compute@developer.gserviceaccount.com" \
  --role="roles/run.builder"

gcloud -q run services delete ${MCP_NAME} --region=${REGION}

gcloud -q artifacts repositories delete cloud-run-source-deploy --location=${REGION}

gcloud -q iam service-accounts delete sa-${MCP_NAME}-invoker@${PROJ_ID}.iam.gserviceaccount.com

gcloud -q agent-registry services delete ${MCP_NAME} --location=${REGION}

# next

# delete gateway resources (policy binding must be deleted synchronously first)
gcloud -q beta network-security authz-policies delete ${AGW_NAME}-authz-policy-profile-iap --location=${REGION}

gcloud -q beta service-extensions authz-extensions delete ${AGW_NAME}-svc-ext-authz-iap-dryrun --location=${REGION} --async

gcloud -q beta service-extensions authz-extensions delete ${AGW_NAME}-svc-ext-authz-iap-enforced --location=${REGION} --async

gcloud -q network-services agent-gateways delete ${AGW_NAME} --location=${REGION} --async

# next

# remove policies
export IAP_ETAG=$(gcloud beta iap web get-iam-policy --resource-type=agent-registry --endpoint=${ENDPOINT_REGISTRY_ID} --region=${REGION} --format="value(etag)")
cat > cfg/iap-policy-empty.json << EOF
{
  "bindings": [],
  "etag": "${IAP_ETAG}"
}
EOF

gcloud -q beta iap web set-iam-policy cfg/iap-policy-empty.json \
  --resource-type=agent-registry \
  --endpoint=${ENDPOINT_REGISTRY_ID} \
  --region=${REGION}

# next

# delete dns resources
gcloud -q dns record-sets delete *.run.app --type=A --zone=priv-zone-run

gcloud -q dns managed-zones delete priv-zone-run

gcloud -q dns policies update dns-policy-${SLUG} --networks=""

gcloud -q dns policies delete dns-policy-${SLUG}

# next

# delete router (includes nat) and psc resources
gcloud -q compute routers delete cr-nat-${SLUG}-${REGION} --region=${REGION}

gcloud -q compute forwarding-rules delete psc2gapis --global

gcloud -q compute addresses delete ip-psc2gapis --global

# next

# delete firewall resources
gcloud -q compute network-firewall-policies associations delete --name=fw-policy-bind-${SLUG} --firewall-policy=fw-policy-${SLUG} --global-firewall-policy

gcloud -q compute network-firewall-policies rules delete 1001 --firewall-policy=fw-policy-${SLUG} --global-firewall-policy

gcloud -q compute network-firewall-policies delete fw-policy-${SLUG} --global

# next

# delete network resources
gcloud -q compute networks subnets delete subnet-${REGION}-agw --region=${REGION}

gcloud -q compute networks subnets delete subnet-${REGION}-crun --region=${REGION}

gcloud -q compute network-attachments delete psc-na-${REGION}-agw --region=${REGION}

gcloud -q compute networks delete vnet-${SLUG}

# next

# clean up local working directories and generated configs
rm -rf cfg agent-weather mcp-weather

# end

सफ़ाई करने का काम यहीं खत्म होता है... अब निष्कर्ष पर आते हैं!

15. नतीजा

बधाई हो! आपने एजेंट गेटवे को डिप्लॉय कर लिया है और आउटबाउंड एआई एजेंट के ट्रैफ़िक को मैनेज कर लिया है!

cosmopup

Cosmopup को लगता है कि Codelabs बहुत अच्छे हैं!

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

इस फ़ीडबैक फ़ॉर्म का इस्तेमाल करके, बेझिझक कोई टिप्पणी करें, सवाल पूछें या सुधार के बारे में बताएं.

धन्यवाद!