एजेंट गेटवे की मदद से, एक ही जगह से एजेंट को गवर्नेंस की सुविधा मिलती है. साथ ही, एजेंट रनटाइम के लिए क्रॉस-प्रोजेक्ट एजेंट रजिस्ट्री की सुविधा मिलती है

1. परिचय

एंटरप्राइज़ संगठनों में जनरेटिव एआई का इस्तेमाल बढ़ने के साथ-साथ, आर्किटेक्चर में भी तेज़ी से बदलाव हो रहा है. अब अलग से मौजूद, मोनोलिथिक चैटबॉट की जगह डिस्ट्रिब्यूटेड मल्टी-एजेंट सिस्टम (एजेंट-टू-एजेंट / ए2ए) का इस्तेमाल किया जा रहा है. इन आधुनिक टोपोलॉजी में, हाई-लेवल ऑर्केस्ट्रेटर एजेंट, कारोबार के जटिल वर्कफ़्लो को मैनेज करते हैं. इसके लिए, वे अलग-अलग Google Cloud प्रोजेक्ट में मौजूद, खास डोमेन वर्कर एजेंट, मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) टूल सर्वर, और बैकएंड एंटरप्राइज़ डेटाबेस को टास्क असाइन करते हैं.

हालांकि, बड़े पैमाने पर मल्टी-एजेंट सिस्टम को इस्तेमाल करने से सुरक्षा, गवर्नेंस, और ऑपरेशन से जुड़ी गंभीर चुनौतियां सामने आती हैं:

• शैडो एजेंट और टूल स्प्राॅल: जब डेवलपमेंट टीमें, किसी सेंट्रलाइज़्ड कैटलॉग के बिना अलग-अलग प्रोजेक्ट में एजेंट डिप्लॉय करती हैं, तो संगठनों को यह पता नहीं चल पाता कि कौनसे टूल और सब-एजेंट मौजूद हैं.
• बिना निगरानी के क्रॉस-प्रोजेक्ट इग्रेस: एजेंट को सीधे और बिना जांच के नेटवर्क रूट की अनुमति देने से, डेटा लीक होने का खतरा पैदा होता है. साथ ही, सुरक्षा से जुड़ी सीमाओं को बायपास किया जाता है.
• हार्डकोड किए गए इंटिग्रेशन में गड़बड़ी होना: डाउनस्ट्रीम एजेंट के यूआरएल और Reasoning Engine के आईडी को हार्डकोड करने से, ऐसी डिपेंडेंसी बनती हैं जो अपग्रेड या फिर से डिप्लॉय करने के दौरान टूट जाती हैं.
• कम से कम ऐक्सेस वाली पहचान की कमी: शेयर किए गए सेवा खाते, अलग-अलग एजेंट इंस्टेंस लेवल पर क्रिप्टोग्राफ़िक नॉन-रेप्यूडिएशन (यह साबित करना कि किसी व्यक्ति ने कोई कार्रवाई की है) की सुविधा नहीं दे पाते.

इन चुनौतियों को हल करने के लिए, Gemini Enterprise Agent Platform, एक ऐसा कंट्रोल प्लेन उपलब्ध कराता है जो कनेक्टिविटी और गवर्नेंस को एक ही जगह से मैनेज करता है. यह चार मुख्य पिलर पर आधारित है:

1. एजेंट गेटवे (networkservices.googleapis.com): यह एक मैनेज किया गया रीजनल नेटवर्क और नीति उल्लंघन ठीक करने का तरीका लागू करने वाला प्रॉक्सी है. AGENT_TO_ANYWHERE इग्रेस मोड में काम करते हुए, यह एजेंट के आउटबाउंड ट्रैफ़िक को इंटरसेप्ट करता है. साथ ही, अनुमति के आकलन की ज़िम्मेदारी सुरक्षा एक्सटेंशन को सौंपता है और प्रोजेक्ट की सीमाओं के पार अनुरोधों को रूट करता है.
2. एजेंट रजिस्ट्री (agentregistry.googleapis.com): यह एंटरप्राइज़ की सेवाओं का सिंगल कैटलॉग है. यह संगठन में उपलब्ध सभी टूल, एमसीपी सर्वर, और पीयर एजेंट की एक सेंट्रलाइज़्ड और जांची-परखी डायरेक्ट्री उपलब्ध कराता है. इससे डाइनैमिक रनटाइम के दौरान, अपने-आप खोज करने की सुविधा चालू हो जाती है. इसके लिए, किसी हार्डकोडेड एंडपॉइंट की ज़रूरत नहीं होती.
3. एजेंट आइडेंटिटी और आईएपी v2 गवर्नेंस (iap.googleapis.com और iam.googleapis.com): यह एक क्रिप्टोग्राफ़िक आइडेंटिटी और ऐक्सेस फ़्रेमवर्क है. एक्ज़ीक्यूट करने वाले एजेंट को यूनीक और प्रमाणित SPIFFE मशीन यूआरएन (principal://...) मिलते हैं. आउटबाउंड इग्रेस का आकलन, IAM यूनिफ़ाइड ऐक्सेस पॉलिसी (यूएपी / आईएपी v2) के हिसाब से किया जाता है. इससे, यूनिवर्सल अनुमति iap.googleapis.com/resources.egressViaIAP की पुष्टि की जाती है. इसके लिए, रिच कॉमन एक्सप्रेशन लैंग्वेज (सीईएल) कैटलॉग की शर्तों (destination.agent_registry.*) का इस्तेमाल किया जाता है.
4. एजेंट रनटाइम (रीज़निंग इंजन): यह Python पर आधारित एजेंटिक ऐप्लिकेशन के लिए, पूरी तरह से मैनेज की गई सेवा वाला सर्वरलेस एक्ज़ीक्यूशन प्लैटफ़ॉर्म है. इसमें सेंट्रल गेटवे के लिए, नेटिव कॉन्फ़िगरेशन बाइंडिंग (agent_gateway_config) की सुविधा होती है.

कोडलैब बिज़नेस सिनेरियो: मल्टी-प्रोजेक्ट फ़ूड ऐंड बेवरेज परचेज़िंग

इस कोडलैब में, आपको Google Cloud के तीन अलग-अलग क्लाउड प्रोजेक्ट में, रीयल-वर्ल्ड मल्टी-प्रोजेक्ट परचेज़िंग नेटवर्क बनाना और उसे मैनेज करना होगा:

• सेंट्रल गवर्नेंस प्रोजेक्ट (PROJECT_GOVERNANCE): इसका मालिकाना हक सेंट्रल आईटी और SecOps के पास होता है. यह सेंट्रल एजेंट गेटवे, सेंट्रल एजेंट रजिस्ट्री, और आईएएम की यूनिफ़ाइड ऐक्सेस नीतियों को होस्ट करता है.
• Consumer Orchestrator Project (PROJECT_CONCIERGE): इसका मालिकाना हक प्रोक्योरमेंट टीम के पास होता है. यह Purchasing Concierge Agent को होस्ट करता है. यह एजेंट, डाइनैमिक तरीके से वेंडर ढूंढता है और ग्राहक के ऑर्डर को रूट करता है.
• डोमेन वेंडर प्रोजेक्ट (PROJECT_SELLERS): इसका मालिकाना हक बाहरी या डिपार्टमेंटल वेंडर के पास होता है. यह बर्गर सेलर एजेंट और पिज़्ज़ा सेलर एजेंट को होस्ट करता है.

आर्किटेक्चर के लिए सबसे सही तरीका: प्रोडक्शन एंटरप्राइज़ डिप्लॉयमेंट में, एजेंट को सेंट्रलाइज़ करने के लिए, Private Service Connect (पीएससी) नेटवर्क अटैचमेंट के साथ शेयर किए गए वीपीसी का इस्तेमाल करना सबसे सही तरीका है. इससे निजी नेटवर्क की सीमा को अलग किया जा सकता है. हालांकि, इस कोडलैब का मुख्य मकसद, क्रॉस-प्रोजेक्ट गवर्नेंस, Identity-Aware Proxy (IAP v2) की यूनिफ़ाइड ऐक्सेस नीतियों, और डाइनैमिक एजेंट रजिस्ट्री की अपने-आप खोज की सुविधा को दिखाना है. इसके लिए, नेटवर्किंग डिपेंडेंसी की ज़रूरत नहीं होती.

इमेज 1. एक से ज़्यादा प्रोजेक्ट के लिए, सेंट्रलाइज़्ड गवर्नेंस आर्किटेक्चर

क्रॉस-प्रोजेक्ट सेंट्रलाइज़्ड गवर्नेंस क्यों ज़रूरी है?

बड़े एंटरप्राइज़ संगठनों में, प्रॉडक्ट टीमें और डेटा साइंस ग्रुप, Google Cloud के दर्जनों अलग-अलग क्लाउड प्रोजेक्ट में एआई एजेंट बनाते हैं. हर टीम को टूल रजिस्ट्रेशन, इग्रेस नेटवर्क रूट, और सुरक्षा से जुड़े दिशा-निर्देशों का सीधा कंट्रोल देने से, बिना जांचे-परखे टूल का इस्तेमाल बढ़ जाता है. साथ ही, डीएलपी की नीतियां अलग-अलग हो जाती हैं, वीपीसी इग्रेस की निगरानी नहीं हो पाती, और ऑडिट लॉग अलग-अलग हो जाते हैं.

क्रॉस-प्रोजेक्ट सेंट्रलाइज़्ड गवर्नेंस, नीति बनाने की प्रोसेस को एजेंट के काम करने की प्रोसेस से अलग करता है:

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

इमेज 2. तीन-टियर वाला क्रॉस-प्रोजेक्ट गवर्नेंस आर्किटेक्चर और सीमाएं

यूनिफ़ाइड ऐक्सेस नीतियों में, आइडेंटिटी के दायरे के लिए दो-टियर वाला मॉडल

जब एजेंट, Central Agent Gateway के ज़रिए कम्यूनिकेट करते हैं, तो Identity-Aware Proxy (IAP v2) ऐक्सेस का आकलन करता है. यह आकलन, कॉल करने वाले व्यक्ति की एजेंट आइडेंटिटी के आधार पर किया जाता है. यह आइडेंटिटी, क्रिप्टोग्राफ़िक तरीके से प्रमाणित होती है और SPIFFE पर आधारित होती है. इसे रनटाइम कंटेनर को अपने-आप जारी किया जाता है. यह आकलन, ग्लोबल आईएएम ऐक्सेस नीति के ख़िलाफ़ किया जाता है:

• टियर 1: Google Cloud के बुनियादी एपीआई (नियम 1 में principalSet:// के ज़रिए कोर्स-ग्रेन्ड): पूरे प्रोजेक्ट के लिए इग्रेस डेटा ट्रैफ़िक की अनुमति. इससे स्पोक प्रोजेक्ट के सभी एजेंट रनटाइम, Google के स्टैंडर्ड एपीआई (aiplatform, iamcredentials, telemetry, agentregistry) को ऐक्सेस कर पाते हैं. इससे उन्हें डिस्कवरी, टोकन जनरेशन, और अनुमान लगाने में मदद मिलती है.

  एक से ज़्यादा प्रोजेक्ट के लिए ज़रूरी शर्त: तीनों प्रोजेक्ट (PROJECT_GOVERNANCE, PROJECT_CONCIERGE, और PROJECT_SELLERS) के प्रोजेक्ट-लेवल principalSet:// को सेंट्रल core-gapi-services एंडपॉइंट पर नियम 1 में अनुमति मिलनी चाहिए. सख्त ENFORCE मोड में, अगर किसी प्रोजेक्ट का principalSet शामिल नहीं किया जाता है, तो उस प्रोजेक्ट में काम करने वाले एजेंट, कंटेनर शुरू करने, टोकन बनाने या टेलीमेट्री स्ट्रीमिंग के दौरान काम नहीं करेंगे. साथ ही, Central Agent Gateway से तुरंत HTTP 403 Forbidden मिलेगा.

• टियर 2: Business Tools और A2A Services (principal:// के ज़रिए बारीकी से कंट्रोल किया गया ऐक्सेस, नियम 2 और 3 में): Reasoning Engine के अलग-अलग इंस्टेंस के लिए, कम से कम ऐक्सेस देने की सख्त नीति लागू की गई है. इसे कॉमन एक्सप्रेशन लैंग्वेज (सीईएल) की शर्तों के साथ लागू किया गया है. ये शर्तें, रजिस्टर की गई Agent Registry की खास सेवाओं (destination.agent_registry.agent.name) को टारगेट करती हैं.

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

• PROJECT_GOVERNANCE में सेंट्रलाइज़्ड एजेंट गेटवे (centralized-agw)
• सख्त ENFORCE मोड (failOpen: false) में, IAP v2 ऑथराइज़ेशन सर्विस एक्सटेंशन और Authz नीति
• बुनियादी IAM यूनिफ़ाइड ऐक्सेस पॉलिसी (uap-rules.json) और प्रोजेक्ट पॉलिसी बाइंडिंग
• क्रॉस-प्रोजेक्ट सर्विस एजेंट के लिए IAM की अनुमतियां (ar_agw_cross_project_sa)
• शेयर किया गया सेंट्रल Google Cloud Storage (GCS) स्टेजिंग बकेट
• PROJECT_SELLERS में बर्गर और पिज़्ज़ा बेचने वाले अलग-अलग एजेंट
• PROJECT_CONCIERGE में डाइनैमिक REST ऑटो डिस्कवरी की सुविधा के साथ, खरीदारी में मदद करने वाला एजेंट
• क्रॉस-प्रोजेक्ट एमटीएलएस यूआरएल की मदद से, सेंट्रल एजेंट रजिस्ट्री में सेवा के रजिस्ट्रेशन
• लाइव पुष्टि और Cloud Logging ऑडिट के साथ, डाइनैमिक आईएपी वर्शन 2 के इग्रेस डेटा ट्रैफ़िक की नीति से जुड़े अपडेट

इमेज 3. लागू करने का सिलसिलेवार क्रम

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

• सेंट्रलाइज़्ड गेटवे के लिए, क्रॉस-प्रोजेक्ट सर्विस एजेंट की आईएएम अनुमतियां कॉन्फ़िगर करने का तरीका
• मल्टी-प्रोजेक्ट एनवायरमेंट में, सेंट्रल एजेंट गेटवे के ज़रिए एजेंट रनटाइम इग्रेस को कैसे रूट करें
• Service Extensions (iapPolicyVersion: "V2") का इस्तेमाल करके, Identity-Aware Proxy (IAP v2) को एजेंट गेटवे की अनुमति देने का तरीका
• रजिस्टर किए गए एजेंट रजिस्ट्री डेस्टिनेशन (destination.agent_registry.*) को कंट्रोल करने वाले कॉमन एक्सप्रेशन लैंग्वेज (सीईएल) के नियमों के साथ, आईएएम यूनिफ़ाइड ऐक्सेस पॉलिसी (यूएपी) को बनाने और बाइंड करने का तरीका
• एजेंट रजिस्ट्री के लिए रनटाइम ऑटोडिस्कवरी का इस्तेमाल करके, हार्डकोड किए गए एजेंट आईडी और यूआरएल हटाने का तरीका
• रीयल पेरीमीटर ज़ीरो-ट्रस्ट ब्लॉकिंग (HTTP 403 Forbidden) की जांच करने और Cloud Logging में लाइव नीति के अपडेट की पुष्टि करने का तरीका

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

• बिलिंग की सुविधा वाले तीन Google Cloud प्रोजेक्ट:
  • PROJECT_GOVERNANCE: सेंट्रल गवर्नेंस, गेटवे, रजिस्ट्री, और आईएएम ऐक्सेस से जुड़ी नीतियां
  • PROJECT_CONCIERGE: खरीदारी में मदद करने वाला एजेंट
  • PROJECT_SELLERS: बर्गर और पिज़्ज़ा विशेषज्ञ विक्रेता एजेंट
• ऐसा IAM उपयोगकर्ता या सेवा खाता जिसके पास तीनों प्रोजेक्ट के लिए, roles/owner या एडमिन के तौर पर अनुमतियां हों
• Google Cloud संगठन (SPIFFE ट्रस्ट डोमेन मैपिंग के लिए)
• Google Cloud Shell या कोई लोकल मशीन, जिसमें gcloud सीएलआई, python (3.11+), और uv इंस्टॉल हो

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

2. सेटअप

भले ही, यह आर्किटेक्चर Google Cloud के तीन अलग-अलग क्लाउड प्रोजेक्ट में फैला हो, लेकिन PROJECT_GOVERNANCE पर सेट किए गए एक Cloud Shell टर्मिनल से, टर्मिनल डिप्लॉयमेंट के सभी कमांड, रिपॉज़िटरी डाउनलोड, और स्टेजिंग ऑपरेशन को पूरी तरह से लागू किया जा सकता है. हर डिप्लॉयमेंट स्क्रिप्ट और gcloud कमांड, सीएलआई फ़्लैग (--project) के ज़रिए, साफ़ तौर पर सही डेस्टिनेशन प्रोजेक्ट को टारगेट करता है.

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

• shell.cloud.google.com पर Cloud Shell या
• एक लोकल टर्मिनल, जिसमें gcloud सीएलआई इंस्टॉल हो

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

# set terminal project context to Central Governance Project
gcloud config set project SET_YOUR_GOVERNANCE_PROJECT_ID_HERE

# login to gcloud cli
gcloud auth login

# login for application default credentials
gcloud auth application-default login

gcloud सीएलआई को अपडेट करें (सुझाया गया)

# update gcloud components
gcloud components update --quiet

ध्यान दें: कुछ सुविधाओं के लिए, gcloud beta के निर्देशों का इस्तेमाल किया जाता है. अगर इंस्टॉल नहीं है, तो इसे चालू करने के लिए gcloud components install beta चलाएं.

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

अपने प्रोजेक्ट के हिसाब से आइडेंटिफ़ायर डालें.

# 1. Project Identifiers
export PROJECT_GOVERNANCE="SET_YOUR_GOVERNANCE_PROJECT_ID_HERE"
export PROJECT_CONCIERGE="SET_YOUR_CONCIERGE_PROJECT_ID_HERE"
export PROJECT_SELLERS="SET_YOUR_SELLERS_PROJECT_ID_HERE"

ये शेल वैरिएबल अपने-आप जनरेट हो जाएंगे.

# 2. Regional & Gateway Settings
export REGION="us-central1"
export AGW_NAME="centralized-agw"
export UAP_POLICY_NAME="uap-policy-${AGW_NAME}"
export UAP_BINDING_NAME="uap-binding-${AGW_NAME}"

# 3. Retrieve Project Numbers
export PROJECT_NUMBER_GOVERNANCE=$(gcloud projects describe ${PROJECT_GOVERNANCE} --format="value(projectNumber)")
export PROJECT_NUMBER_CONCIERGE=$(gcloud projects describe ${PROJECT_CONCIERGE} --format="value(projectNumber)")
export PROJECT_NUMBER_SELLERS=$(gcloud projects describe ${PROJECT_SELLERS} --format="value(projectNumber)")

# 4. Obtain Organization ID
export ORG_ID=$(gcloud projects get-ancestors ${PROJECT_GOVERNANCE} --format="value(id, type)" | grep organization | awk '{print $1}')

# 5. Set Application Default Credentials (ADC) Quota Project
gcloud auth application-default set-quota-project ${PROJECT_GOVERNANCE}

echo "Governance Project: ${PROJECT_GOVERNANCE} (${PROJECT_NUMBER_GOVERNANCE})"
echo "Concierge Project:  ${PROJECT_CONCIERGE} (${PROJECT_NUMBER_CONCIERGE})"
echo "Sellers Project:    ${PROJECT_SELLERS} (${PROJECT_NUMBER_SELLERS})"
echo "Organization ID:    ${ORG_ID}"
echo "UAP Policy Name:    ${UAP_POLICY_NAME}"
echo "UAP Binding Name:   ${UAP_BINDING_NAME}"

कॉन्फ़िगरेशन फ़ाइलों के लिए लोकल डायरेक्ट्री बनाना

# create config folder
mkdir -p cfg

Unified Access Policies के लिए, ऐक्सेस नीति के एडमिन की भूमिका असाइन करना

ध्यान दें: अगर आपके उपयोगकर्ता खाते के पास PROJECT_GOVERNANCE पर पहले से ही roles/owner है, तो आपके पास ऐक्सेस से जुड़ी नीतियां बनाने और उन्हें बाइंड करने के लिए ज़रूरी अनुमतियां पहले से ही मौजूद हैं.

अगर आपके पास कम से कम ऐक्सेस है, तो यूनिफ़ाइड ऐक्सेस की नीतियां बनाने और उन्हें अपडेट करने के लिए, आपके पास roles/iam.accessPolicyAdmin होना चाहिए. साथ ही, किसी प्रोजेक्ट टारगेट के साथ नीति बाइंडिंग अटैच करने के लिए, आपके पास roles/resourcemanager.projectIamAdmin होना चाहिए:

# grant Access Policy Admin and Project IAM Admin to current user in Governance Project
for ROLE in "roles/iam.accessPolicyAdmin" "roles/resourcemanager.projectIamAdmin"; do
  gcloud projects add-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="user:$(gcloud config get-value account)" \
    --role="${ROLE}" \
    --condition=None
done

IAP v2 के लिए, Cloud Audit Logs में डेटा ऐक्सेस लॉग चालू करना

डिफ़ॉल्ट रूप से, Google Cloud डेटा ऐक्सेस ऑडिट लॉग को बंद कर देता है, ताकि स्टोरेज के लिए अनचाहे शुल्क न देने पड़ें. IAP v2, अनुमति से जुड़े फ़ैसलों (granted=true और granted=false) को डेटा ऐक्सेस ऑडिट लॉग के तौर पर दिखाता है. इसलिए, PROJECT_GOVERNANCE में iap.googleapis.com के लिए ADMIN_READ, DATA_READ, और DATA_WRITE लॉगिंग चालू करें:

# 1. export current IAM policy for PROJECT_GOVERNANCE
gcloud projects get-iam-policy ${PROJECT_GOVERNANCE} \
  --format=json > cfg/gov_iam_policy.json

# 2. append auditConfigs for iap.googleapis.com
python3 -c "
import json
with open('cfg/gov_iam_policy.json') as f:
    policy = json.load(f)
audit_configs = [c for c in policy.get('auditConfigs', []) if c.get('service') != 'iap.googleapis.com']
audit_configs.append({
    'service': 'iap.googleapis.com',
    'auditLogConfigs': [
        {'logType': 'ADMIN_READ'},
        {'logType': 'DATA_READ'},
        {'logType': 'DATA_WRITE'}
    ]
})
policy['auditConfigs'] = audit_configs
with open('cfg/gov_iam_policy.json', 'w') as f:
    json.dump(policy, f, indent=2)
"

# 3. apply updated policy
gcloud projects set-iam-policy ${PROJECT_GOVERNANCE} cfg/gov_iam_policy.json

# 4. verify auditConfigs applied
gcloud projects get-iam-policy ${PROJECT_GOVERNANCE} --format="yaml(auditConfigs)"

ज़रूरी Google Cloud API चालू करना

# enable google apis (agent platform & security bundle, part 1)
for PROJ in ${PROJECT_GOVERNANCE} ${PROJECT_CONCIERGE} ${PROJECT_SELLERS}; do
  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 \
    agentidentity.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 \
    --project=${PROJ}
done

# enable google apis (agent platform bundle, part 2)
for PROJ in ${PROJECT_GOVERNANCE} ${PROJECT_CONCIERGE} ${PROJECT_SELLERS}; do
  gcloud services enable \
    securitycenter.googleapis.com \
    saasservicemgmt.googleapis.com \
    storage.googleapis.com \
    telemetry.googleapis.com \
    texttospeech.googleapis.com \
    --project=${PROJ}
done

# enable google apis (foundational & agent runtime build bundle, part 3)
for PROJ in ${PROJECT_GOVERNANCE} ${PROJECT_CONCIERGE} ${PROJECT_SELLERS}; do
  gcloud services enable \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com \
    cloudresourcemanager.googleapis.com \
    iamcredentials.googleapis.com \
    serviceusage.googleapis.com \
    run.googleapis.com \
    orgpolicy.googleapis.com \
    --project=${PROJ}
done

सभी प्रोजेक्ट के लिए एपीआई चालू होने की पुष्टि करना

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

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

# validate that all required APIs are enabled across all 3 projects
python3 - << 'EOF'
import subprocess
import os
import sys

REQUIRED_APIS = [
    "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",
    "agentidentity.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",
    "securitycenter.googleapis.com",
    "saasservicemgmt.googleapis.com",
    "storage.googleapis.com",
    "telemetry.googleapis.com",
    "texttospeech.googleapis.com",
    "artifactregistry.googleapis.com",
    "cloudbuild.googleapis.com",
    "cloudresourcemanager.googleapis.com",
    "iamcredentials.googleapis.com",
    "serviceusage.googleapis.com",
    "run.googleapis.com",
    "orgpolicy.googleapis.com"
]

projects = {
    "GOVERNANCE": os.environ.get("PROJECT_GOVERNANCE", ""),
    "CONCIERGE": os.environ.get("PROJECT_CONCIERGE", ""),
    "SELLERS": os.environ.get("PROJECT_SELLERS", "")
}

enabled = {}
for role, proj in projects.items():
    if not proj:
        print(f"Error: Environment variable for {role} is not set.")
        sys.exit(1)
    res = subprocess.run(
        ["gcloud", "services", "list", "--enabled", f"--project={proj}", "--format=value(config.name)"],
        capture_output=True, text=True, check=True
    )
    enabled[role] = set(res.stdout.strip().splitlines())

print(f"\n{'API Name':<36} | {'GOVERNANCE':<12} | {'CONCIERGE':<12} | {'SELLERS':<12}")
print("-" * 78)

all_synced = True
for api in REQUIRED_APIS:
    g_status = "ENABLED" if api in enabled["GOVERNANCE"] else "MISSING"
    c_status = "ENABLED" if api in enabled["CONCIERGE"] else "MISSING"
    s_status = "ENABLED" if api in enabled["SELLERS"] else "MISSING"
    if "MISSING" in (g_status, c_status, s_status):
        all_synced = False
    print(f"{api:<36} | {g_status:<12} | {c_status:<12} | {s_status:<12}")

print("-" * 78)
if all_synced:
    print("✅ All 29 required APIs are ENABLED and synchronized across all three projects.\n")
else:
    print("❌ Discrepancies detected. Please re-run the enablement commands for missing services.\n")
    sys.exit(1)
EOF

पुष्टि के आउटपुट का सैंपल:

आपको सभी एपीआई चालू दिखेंगे.

✅ All 30 required APIs are ENABLED and synchronized across all three projects.

संगठन की नीतियां कॉन्फ़िगर करना

Google Cloud संगठन की डिफ़ॉल्ट नीतियां, ऐसी पाबंदियां लागू करती हैं जिनसे संसाधनों (constraints/iam.managed.disableAccessPolicyBinding) के लिए, IAM v3 ऐक्सेस नीति की बाइंडिंग सीमित हो जाती हैं.

प्रोजेक्ट लेवल पर, संगठन की नीति से जुड़ी किसी भी पाबंदी को बदलने के लिए, enforce: false को 'अनुमति दें' पर सेट करें.

# disable iam v3 constraint (allow v3 access policies)
gcloud org-policies set-policy /dev/stdin << EOF
name: projects/${PROJECT_NUMBER_GOVERNANCE}/policies/iam.managed.disableAccessPolicyBinding
spec:
  rules:
  - enforce: false
EOF

# verify org policy constraints on project
gcloud org-policies describe iam.managed.disableAccessPolicyBinding \
  --project=${PROJECT_GOVERNANCE} --effective

इसके साथ ही, सेटअप का हिस्सा पूरा हो गया है... अब मुख्य Google API रजिस्टर करें सेक्शन पर जाएं.

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

Google के मुख्य एपीआई के एंडपॉइंट की सेवा को रजिस्टर करना

एजेंट गेटवे के लिए, Google API के यूआरएल को सेंट्रल एजेंट रजिस्ट्री में रजिस्टर करना ज़रूरी है. इससे agent_gateway_config के साथ कॉन्फ़िगर किए गए एजेंट, इग्रेस डेटा ट्रैफ़िक को Google Cloud की मुख्य बैकएंड सेवाओं (जैसे, aiplatform, IAM क्रेडेंशियल, और टेलीमेट्री) पर सुरक्षित तरीके से रूट कर सकते हैं.

एजेंट रजिस्ट्री में core-gapi-services बनाएं

# register core google api endpoints in agent registry with standard and :443 port variants
gcloud agent-registry services create core-gapi-services \
  --project=${PROJECT_GOVERNANCE} \
  --location=${REGION} \
  --display-name="gapi.core.services" \
  --description="Core Google Cloud APIs and Service Endpoints" \
  --endpoint-spec-type=no-spec \
  --interfaces=protocolBinding=JSONRPC,url=https://telemetry.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://telemetry.mtls.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://aiplatform.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://aiplatform.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://aiplatform.mtls.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://aiplatform.mtls.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://cloudresourcemanager.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://cloudresourcemanager.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://cloudresourcemanager.mtls.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://cloudresourcemanager.mtls.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://iamcredentials.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://iamcredentials.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://iamcredentials.mtls.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://iamcredentials.mtls.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://agentregistry.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://agentregistry.mtls.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://agentregistry.googleapis.com:443 \
  --interfaces=protocolBinding=JSONRPC,url=https://agentregistry.mtls.googleapis.com:443

अहम जानकारी: gRPC अथॉरिटी पोर्ट 443 एग्ज़ैक्ट मैचिंग
एजेंट प्लैटफ़ॉर्म (Vertex AI) की क्लाइंट लाइब्रेरी और रीज़निंग इंजन रनटाइम, टीएलएस पर एचटीटीपी/2 का इस्तेमाल करके gRPC कॉल शुरू करते हैं. gRPC क्लाइंट, एचटीटीपी/2 :authority हेडर को hostname:443 के तौर पर फ़ॉर्मैट करते हैं. उदाहरण के लिए, ${REGION}-aiplatform.googleapis.com:443 या agentregistry.googleapis.com:443. Agent Gateway, रजिस्टर किए गए सेवा यूआरएल के साथ एग्ज़ैक्ट प्रीफ़िक्स मैचिंग करता है. इसलिए, साफ़ तौर पर :443 इंटरफ़ेस यूआरएल के बिना किए गए अनुरोधों के नतीजे के तौर पर agentGatewayInfo: {} (रजिस्टर नहीं किया गया डेस्टिनेशन) दिखेगा. साथ ही, IAP उन्हें PERMISSION_DENIED: Egress request is not authorized. के साथ तुरंत खत्म कर देगा. हमेशा डिफ़ॉल्ट होस्टनेम और उनके साफ़ तौर पर बताए गए :443 वैरिएंट, दोनों को रजिस्टर करें.

Capture Core APIs एंडपॉइंट का संसाधन आईडी

# capture the underlying Agent Registry endpoint ID
export ENDPOINT_ID=$(gcloud agent-registry services describe core-gapi-services \
  --project=${PROJECT_GOVERNANCE} \
  --location=${REGION} \
  --format="value(registryResource)" | awk -F'/' '{print $NF}')
echo "Core APIs Endpoint ID: ${ENDPOINT_ID}"

एजेंट की पहचान में principalSet और principal के बीच का अंतर समझना

Google Cloud IAM और Gemini Enterprise Agent प्लैटफ़ॉर्म में, एजेंट कंटेनर को चलाने के लिए जारी की गई मशीन आइडेंटिटी, क्रिप्टोग्राफ़िक तरीके से प्रमाणित SPIFFE यूआरएन का इस्तेमाल करती हैं. इनकी जांच, Identity-Aware Proxy (IAP v2) करता है. IAM Unified Access Policies को कॉन्फ़िगर करते समय, किसी खास principal या एट्रिब्यूट पर आधारित principalSet को टारगेट किया जा सकता है:

डाइमेंशन	principal:// (सिंगल मशीन आइडेंटिटी)	principalSet:// (एट्रिब्यूट के आधार पर बनाया गया ग्रुप)
IAM सिंटैक्स	principal://...	principalSet://...
जानकारी का लेवल	बारीकी से (इंस्टेंस-लेवल): इससे किसी एक खास रीज़निंग इंजन कंटेनर इंस्टेंस की पहचान की जाती है.	कोर्स-ग्रेन्ड (प्रोजेक्ट-लेवल): यह प्रोजेक्ट के किसी सामान्य एट्रिब्यूट को शेयर करने वाले सभी रीज़निंग इंजन की पहचान करता है.
यूआरएन पैटर्न	principal://agents.global.org-${ORG_ID}.system.id.goog/resources/aiplatform/projects/${PROJECT_NUMBER}/locations/${REGION}/reasoningEngines/${ENGINE_ID}	principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER}
Agent Platform में इस्तेमाल का उदाहरण	टियर 2 (कारोबार के लिए टूल और A2A): इसमें कुछ खास ऑर्केस्ट्रेटर एजेंट को टारगेट डोमेन के टूल इस्तेमाल करने की अनुमति दी जाती है. जैसे, खरीदारी में मदद करने वाला एजेंट $\rightarrow$ बर्गर बेचने वाला एजेंट.	टियर 1 (बुनियादी इंफ़्रास्ट्रक्चर): किसी प्रोजेक्ट में मौजूद सभी एजेंट को Google Cloud API (core-gapi-services) के लिए, इग्रेस ऐक्सेस देना.
लाइफ़साइकल पर असर	अगर किसी एजेंट को मिटाकर फिर से बनाया जाता है, तो उसके नए इंजन आईडी के लिए, आईएएम नीति की बाइंडिंग को अपडेट करना ज़रूरी है.	यह उस प्रोजेक्ट में नए डिप्लॉय किए गए एजेंट पर अपने-आप लागू हो जाता है. इसके लिए, आईएएम को अपडेट करने की ज़रूरत नहीं होती.

यूनिफ़ाइड ऐक्सेस पॉलिसी (यूएपी / आईएपी v2) के साथ डिक्लेरेटिव गवर्नेंस

IAP v1 के लेगसी वर्शन में, इग्रेस डेटा ट्रैफ़िक की नीतियां सीधे तौर पर अलग-अलग एजेंट रजिस्ट्री संसाधनों से अटैच की जाती थीं. इसके लिए, gcloud beta iap web add-iam-policy-binding का इस्तेमाल किया जाता था. आईएपी v2 और यूनिफ़ाइड ऐक्सेस नीतियों के तहत, हर संसाधन के लिए अलग-अलग बाइंडिंग को हटा दिया जाता है. इसके बजाय, एक ही, सेंट्रलाइज़्ड IAM ऐक्सेस नीति (cfg/uap-rules.json) का इस्तेमाल किया जाता है.

core-gapi-services के लिए, बुनियादी इग्रेस ऑथराइज़ेशन को सेक्शन 5 में यूनिफ़ाइड ऐक्सेस पॉलिसी में नियम 1 के तौर पर कॉन्फ़िगर किया जाएगा. इससे यह पक्का किया जा सकेगा कि डिप्लॉयमेंट से पहले, सभी एजेंट कंटेनर के लिए बुनियादी इग्रेस रूट तय किए गए हों.

प्रिंसिपल आइडेंटिफ़ायर और Workload Identity के काम करने के तरीके के बारे में ज़्यादा तकनीकी जानकारी के लिए, ये लेख पढ़ें:

• Google Cloud IAM: प्रिंसिपल आइडेंटिफ़ायर और प्रिंसिपल सेट
• एजेंट आइडेंटिटी की सुविधा कैसे काम करती है
• एजेंट गेटवे के लिए, IAM की यूनिफ़ाइड ऐक्सेस नीतियों को कॉन्फ़िगर करना

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

4. एजेंट गेटवे

सेंट्रलाइज़्ड एजेंट गेटवे डिप्लॉय करें

$PROJECT_GOVERNANCE प्रोजेक्ट में, AGENT_TO_ANYWHERE इग्रेस मोड में सेंट्रलाइज़्ड एजेंट गेटवे (centralized-agw) को डिप्लॉय करें.

गेटवे कॉन्फ़िगरेशन मेनिफ़ेस्ट तय करना

इग्रेस डेटा ट्रैफ़िक को मैनेज करने के लिए, cfg/${AGW_NAME}.yaml बनाएं:

# generate agent gateway config yaml
cat > cfg/${AGW_NAME}.yaml << EOF
name: ${AGW_NAME}
protocols:
  - MCP
googleManaged:
  governedAccessPath: AGENT_TO_ANYWHERE
registries:
  - "//agentregistry.googleapis.com/projects/${PROJECT_GOVERNANCE}/locations/${REGION}"
EOF

इंपोर्ट एजेंट गेटवे का कॉन्फ़िगरेशन

# import and create agent gateway
gcloud network-services agent-gateways import ${AGW_NAME} \
  --source="cfg/${AGW_NAME}.yaml" \
  --location=${REGION} \
  --project=${PROJECT_GOVERNANCE}

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

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

आउटपुट का सैंपल:

agentGatewayCard:
  mtlsEndpoint: projects/${AGW_TP_ID}/regions/us-central1/serviceAttachments/unitkind1-swp-mtls-psc-sa
  rootCertificates:
  - |
    -----BEGIN CERTIFICATE-----
    MIIDwzCCAqugAwIBAgITNQuWGopdOZaHdcK7r7AYFhonqDANBgkqhkiG9w0BAQsF
    ...
    -----END CERTIFICATE-----
  serviceExtensionsServiceAccount: service-${PROJ_NO}@gcp-sa-dep.iam.gserviceaccount.com
createTime: 'YYYY-MM-DDT12:34:56.789098765Z'
googleManaged:
  governedAccessPath: AGENT_TO_ANYWHERE
name: projects/${PROJECT_GOVERNANCE}/locations/us-central1/agentGateways/centralized-agw
protocols:
- MCP
registries:
- //agentregistry.googleapis.com/projects/${PROJECT_GOVERNANCE}/locations/us-central1
updateTime: 'YYYY-MM-DDT12:34:56.789098765Z'

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

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

एजेंट गेटवे ऑथराइज़ेशन और बुनियादी यूएपी को कॉन्फ़िगर करना

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

अनुमति देने के आर्किटेक्चर की खास जानकारी

इमेज 4. अनुमति देने के आर्किटेक्चर की खास जानकारी

अनुमति देने के आर्किटेक्चर में, एक-दूसरे से जुड़ी तीन लेयर होती हैं:

1. आईएपी सर्विस एक्सटेंशन (authzExtension): यह एक रीजनल रिसॉर्स है, जिसे service: iap.googleapis.com, metadata: iapPolicyVersion: "V2", और failOpen: false के साथ कॉन्फ़िगर किया गया है. इससे पेरीमीटर ज़ीरो-ट्रस्ट को सख्ती से लागू किया जा सकता है.
2. गेटवे ऑथराइज़ेशन पॉलिसी (authzPolicy): यह एक रीजनल रिसॉर्स है, जो policyProfile: REQUEST_AUTHZ और action: CUSTOM का इस्तेमाल करके आपके एजेंट गेटवे को टारगेट करता है. साथ ही, ऑथराइज़ेशन की जांच को आईएपी ऑथराइज़ेशन एक्सटेंशन पर रूट करता है.
3. IAM Unified Access Policy & Binding (accessPolicy & policyBinding): ग्लोबल IAM v3 संसाधन, जिसका आकलन आईएपी करता है. यह कॉलर की SPIFFE आइडेंटिटी और सीईएल कैटलॉग की शर्तों के आधार पर, यूनिवर्सल अनुमति iap.googleapis.com/resources.egressViaIAP की पुष्टि करता है.

पहला चरण: IAP v2 Authz एक्सटेंशन बनाना और इंपोर्ट करना

ENFORCE मोड में iapPolicyVersion: "V2" और failOpen: false के साथ सर्विस एक्सटेंशन मेनिफ़ेस्ट बनाएं:

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

Authz एक्सटेंशन इंपोर्ट करें:

# import IAP v2 authz extension
gcloud service-extensions authz-extensions import ${AGW_NAME}-svc-ext-authz-iap \
  --source=cfg/${AGW_NAME}-svc-ext-authz-iap.yaml \
  --location=${REGION} \
  --project=${PROJECT_GOVERNANCE}

पुष्टि करें कि Authz एक्सटेंशन चालू है:

# describe authz extension
gcloud service-extensions authz-extensions describe ${AGW_NAME}-svc-ext-authz-iap \
  --location=${REGION} \
  --project=${PROJECT_GOVERNANCE}

आउटपुट का सैंपल:

createTime: 'YYYY-MM-DDT12:34:56.789098765Z'
failOpen: false
metadata:
  iapPolicyVersion: V2
name: projects/${PROJECT_GOVERNANCE}/locations/us-central1/authzExtensions/centralized-agw-svc-ext-authz-iap
service: iap.googleapis.com
timeout: 1s

दूसरा चरण: गेटवे ऑथराइज़ेशन पॉलिसी बनाना और इंपोर्ट करना

अनुमति देने की नीति का ऐसा कॉन्फ़िगरेशन बनाएं जो एजेंट गेटवे से अटैच हो और अनुरोध की पुष्टि करने की ज़िम्मेदारी, IAP Authz एक्सटेंशन को सौंपे:

# create authz policy manifest
cat > cfg/${AGW_NAME}-authz-policy-profile-iap.yaml << EOF
name: ${AGW_NAME}-authz-policy-profile-iap
target:
  resources:
    - "projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agentGateways/${AGW_NAME}"
policyProfile: REQUEST_AUTHZ
action: CUSTOM
customProvider:
  authzExtension:
    resources:
      - "projects/${PROJECT_GOVERNANCE}/locations/${REGION}/authzExtensions/${AGW_NAME}-svc-ext-authz-iap"
EOF

अनुमति के लिए नीति इंपोर्ट करें:

# import 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} \
  --project=${PROJECT_GOVERNANCE}

अनुमति देने की चालू नीति की पुष्टि करें:

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

तीसरा चरण: यूनिफ़ाइड ऐक्सेस की शुरुआती नीति बनाना (नियम 1: Google के मुख्य एपीआई)

"स्टार्टअप ब्लॉकर" को रोकने का नियम:

• Agent Gateway, ENFORCE मोड (failOpen: false) में काम करता है. इसलिए, agent_gateway_config के साथ शुरू होने वाला कोई भी एजेंट कंटेनर, अपने स्टार्टअप कॉल (aiplatform, telemetry, iamcredentials) को गेटवे के ज़रिए रूट करेगा.
• अगर इन बुनियादी कॉल की अनुमति देने के लिए कोई नीति सेट नहीं की गई है, तो एजेंट कंटेनर चालू होते ही क्रैश हो जाएंगे.
• एजेंट को डिप्लॉय करने से पहले, आईएएम ऐक्सेस नीति में नियम 1 को सेट करना और उसे PROJECT_GOVERNANCE से बाइंड करना ज़रूरी है!

cfg/uap-rules.json बनाएं. इसके लिए, पहले नियम का इस्तेमाल करके, तीनों प्रोजेक्ट principalSet को core-gapi-services को ऐक्सेस करने की अनुमति दें:

# create initial unified access policy rules manifest
cat > cfg/uap-rules.json << EOF
[
  {
    "description": "Rule 1: Allow agent runtimes across all 3 projects to reach Core Google APIs",
    "effect": "ALLOW",
    "principals": [
      "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_GOVERNANCE}",
      "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}",
      "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_SELLERS}"
    ],
    "operation": {
      "permissions": [
        "iap.googleapis.com/resources.egressViaIAP"
      ]
    },
    "conditions": {
      "iap.googleapis.com": {
        "expression": \
        "destination.is_registered == true && \
         destination.agent_registry.resource_type == 'ENDPOINT' && ( \
         destination.agent_registry.endpoint.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/endpoints/core-gapi-services' || \
         destination.agent_registry.endpoint.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/endpoints/${ENDPOINT_ID}' || \
         destination.agent_registry.endpoint.name == 'projects/${PROJECT_NUMBER_GOVERNANCE}/locations/${REGION}/endpoints/${ENDPOINT_ID}')"
      }
    }
  }
]
EOF

चौथा चरण: IAM ऐक्सेस नीति बनाना और उसे बाइंड करना

ग्लोबल IAM ऐक्सेस नीति बनाएं:

# create global IAM access policy
gcloud iam access-policies create ${UAP_POLICY_NAME} \
  --details-rules=cfg/uap-rules.json \
  --project=${PROJECT_GOVERNANCE} \
  --location=global

ऐक्सेस की नीति को PROJECT_GOVERNANCE से बाइंड करें:

# bind access policy to governance project
gcloud iam policy-bindings create ${UAP_BINDING_NAME} \
  --policy="projects/${PROJECT_GOVERNANCE}/locations/global/accessPolicies/${UAP_POLICY_NAME}" \
  --target-resource="//cloudresourcemanager.googleapis.com/projects/${PROJECT_GOVERNANCE}" \
  --project=${PROJECT_GOVERNANCE} \
  --location=global

पुष्टि करें कि नीति बाइंडिंग चालू है:

# verify policy binding
gcloud iam policy-bindings describe ${UAP_BINDING_NAME} \
  --project=${PROJECT_GOVERNANCE} \
  --location=global

आउटपुट का सैंपल:

name: projects/${PROJECT_GOVERNANCE}/locations/global/policyBindings/uap-binding-centralized-agw
policy: projects/${PROJECT_GOVERNANCE}/locations/global/accessPolicies/uap-policy-centralized-agw
policyKind: ACCESS_POLICY
target:
  resource: //cloudresourcemanager.googleapis.com/projects/${PROJECT_GOVERNANCE}

Google Cloud API के बुनियादी इग्रेस डेटा ट्रैफ़िक को अब तीनों प्रोजेक्ट में, स्ट्रिक्ट ENFORCE मोड में सुरक्षित तरीके से अनुमति दी गई है.

गेटवे ऑथराइज़ेशन सेटअप करने की प्रोसेस पूरी हो गई है... अब क्रॉस-प्रोजेक्ट IAM अनुमतियां कॉन्फ़िगर करें सेक्शन पर जाएं.

6. क्रॉस-प्रोजेक्ट आईएएम

क्रॉस-प्रोजेक्ट आईएएम अनुमतियां कॉन्फ़िगर करना

इस मल्टी-प्रोजेक्ट टोपोलॉजी में, एजेंट रनटाइम, स्पोक प्रोजेक्ट (PROJECT_CONCIERGE और PROJECT_SELLERS) में मौजूद होते हैं. वहीं, सेंट्रल एजेंट गेटवे और एजेंट रजिस्ट्री, PROJECT_GOVERNANCE में मौजूद होती हैं.

Google Cloud प्रोजेक्ट, सुरक्षा के लिहाज़ से अलग-अलग होते हैं. इसलिए, एक प्रोजेक्ट से दूसरे प्रोजेक्ट को ऐक्सेस करने की अनुमति, साफ़ तौर पर दो ऑपरेशनल लेयर पर दी जानी चाहिए:

1. कंट्रोल प्लेन (डिप्लॉयमेंट का समय): --agent-gateway-config के साथ कॉन्फ़िगर किए गए एजेंट कंटेनर को डिप्लॉय करते समय, स्पोक प्रोजेक्ट के एजेंट रनटाइम सर्विस एजेंट ([e-mail]) को कंटेनर को सेंट्रल गेटवे से अटैच करना होगा. हम PROJECT_GOVERNANCE में networkservices.agentGateways.use, get, और operations.get की अनुमति देने वाली, कम से कम अनुमतियों वाली कस्टम भूमिका (ar_agw_cross_project_sa) बनाते हैं.
2. डेटा प्लेन (रनटाइम एक्ज़ीक्यूशन):
   • कैटलॉग डिस्कवरी: टारगेट एजेंट एंडपॉइंट को डाइनैमिक तौर पर रिज़ॉल्व करने के लिए, स्पोक आइडेंटिटी को PROJECT_GOVERNANCE में roles/agentregistry.viewer की ज़रूरत होती है.
   • टारगेट इन्वोकेशन: सहायता उपलब्ध कराने वाले एजेंट को PROJECT_SELLERS में roles/aiplatform.user की ज़रूरत होती है, ताकि वह विक्रेता के गहराई से विश्लेषण इंजन के लिए क्वेरी चला सके.

PROJECT_GOVERNANCE में कस्टम आईएएम रोल बनाएं

# create custom role in central governance project
gcloud iam roles create ar_agw_cross_project_sa \
  --project=${PROJECT_GOVERNANCE} \
  --title="Runtime Agent Gateway Cross-Project SA" \
  --description="Custom role for cross-project service agents to access Central Agent Gateway" \
  --permissions="networkservices.agentGateways.get,networkservices.agentGateways.use,networkservices.operations.get" \
  --stage="GA"

एजेंट रनटाइम सर्विस एजेंट को कस्टम रोल असाइन करना

# 1. ensure aiplatform service identities are provisioned across all projects
for PROJ in ${PROJECT_GOVERNANCE} ${PROJECT_CONCIERGE} ${PROJECT_SELLERS}; do
  gcloud beta services identity create --service=aiplatform.googleapis.com --project=${PROJ}
done

# 2. derive aiplatform service agent emails
export CONCIERGE_AI_SA="service-${PROJECT_NUMBER_CONCIERGE}@gcp-sa-aiplatform.iam.gserviceaccount.com"
export CONCIERGE_RE_SA="service-${PROJECT_NUMBER_CONCIERGE}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"
export CONCIERGE_COMPUTE_SA="${PROJECT_NUMBER_CONCIERGE}[e-mail]"

export SELLERS_AI_SA="service-${PROJECT_NUMBER_SELLERS}@gcp-sa-aiplatform.iam.gserviceaccount.com"
export SELLERS_RE_SA="service-${PROJECT_NUMBER_SELLERS}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"
export SELLERS_COMPUTE_SA="${PROJECT_NUMBER_SELLERS}[e-mail]"

# 3. grant custom role & network viewer to Concierge and Sellers Service Agents
for SA in ${CONCIERGE_AI_SA} ${SELLERS_AI_SA}; do
  gcloud projects add-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="serviceAccount:${SA}" \
    --role="projects/${PROJECT_GOVERNANCE}/roles/ar_agw_cross_project_sa" \
    --condition=None

  gcloud projects add-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="serviceAccount:${SA}" \
    --role="roles/networkservices.viewer" \
    --condition=None
done

# 4. grant agent registry viewer on Governance Project for dynamic autodiscovery
for MEMBER in "serviceAccount:${CONCIERGE_AI_SA}" "serviceAccount:${CONCIERGE_RE_SA}" "serviceAccount:${CONCIERGE_COMPUTE_SA}" "serviceAccount:${SELLERS_AI_SA}" "serviceAccount:${SELLERS_RE_SA}" "serviceAccount:${SELLERS_COMPUTE_SA}" "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}" "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_SELLERS}"; do
  gcloud projects add-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="${MEMBER}" \
    --role="roles/agentregistry.viewer" \
    --condition=None
done

# 5. grant agent project viewer on Governance Project for dynamic autodiscovery
for SA in ${CONCIERGE_COMPUTE_SA} ${CONCIERGE_AI_SA}; do
  gcloud projects add-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="serviceAccount:${SA}" \
    --role="roles/viewer" \
    --condition=None
done

# 6. grant aitplatform user on Sellers project to Concierge for cross-project A2A invocation
for MEMBER in "serviceAccount:${CONCIERGE_AI_SA}" "serviceAccount:${CONCIERGE_RE_SA}" "serviceAccount:${CONCIERGE_COMPUTE_SA}" "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}"; do
  gcloud projects add-iam-policy-binding ${PROJECT_SELLERS} \
    --member="${MEMBER}" \
    --role="roles/aiplatform.user" \
    --condition=None
done

इससे क्रॉस-प्रोजेक्ट आईएएम सेटअप पूरा हो जाता है... इसके बाद, सेलर और कंसीयज एजेंट डिप्लॉय करें सेक्शन पर जाएं.

7. एजेंट रनटाइम

विक्रेता और सहायता उपलब्ध कराने वाले एजेंट को डिप्लॉय करना

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

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

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

# copy multi-agent application files to current working directory
cp -r temp_agw_multiproject/codelabs/agw-multiproject ./cross-project-multiagent

# remove temporary directory
rm -rf temp_agw_multiproject

# install dependencies
uv sync --directory ./cross-project-multiagent

शेयर की गई सेंट्रल स्टेजिंग बकेट बनाना

# create shared central staging bucket
gcloud storage buckets create gs://${PROJECT_GOVERNANCE}-shared-staging \
  --project=${PROJECT_GOVERNANCE} \
  --location=${REGION}

# grant cross-project read/write access to runtime service agents
gcloud storage buckets add-iam-policy-binding gs://${PROJECT_GOVERNANCE}-shared-staging \
  --member="serviceAccount:service-${PROJECT_NUMBER_CONCIERGE}@gcp-sa-aiplatform.iam.gserviceaccount.com" \
  --role="roles/storage.objectAdmin"

gcloud storage buckets add-iam-policy-binding gs://${PROJECT_GOVERNANCE}-shared-staging \
  --member="serviceAccount:service-${PROJECT_NUMBER_SELLERS}@gcp-sa-aiplatform.iam.gserviceaccount.com" \
  --role="roles/storage.objectAdmin"

क्रॉस-प्रोजेक्ट एजेंट गेटवे बाइंडिंग कैसे काम करती है

इस चरण में, सेलर एजेंट को स्पोक प्रोजेक्ट (PROJECT_SELLERS) में डिप्लॉय किया जाएगा. साथ ही, उन्हें PROJECT_GOVERNANCE में सेंट्रल एजेंट गेटवे के ज़रिए इग्रेस डेटा ट्रैफ़िक को रूट करने के लिए कॉन्फ़िगर किया जाएगा:

# !-- for example purposes -- NOT a command to execute --!
# snippet from deploy_burger.py
burger_config = {
    "staging_bucket": staging_bucket_uri,
    "gcs_dir_name": "burger_agent",
    "display_name": "burger-seller-agent-adk",
    "identity_type": "AGENT_IDENTITY",
    "agent_gateway_config": {
        "agent_to_anywhere_config": {
            "agent_gateway": f"projects/{args.governance_project}/locations/{args.region}/agentGateways/{args.gateway}"
        }
    },
}
deployed_burger = client.agent_engines.create(agent=burger_playground, config=burger_config)

शेयर की गई स्टेजिंग बकेट को अलग करना (gcs_dir_name):

• जब अलग-अलग प्रोजेक्ट के कई एजेंट, एक ही सेंट्रल स्टेजिंग बकेट (gs://${PROJECT_GOVERNANCE}-shared-staging) को शेयर करते हैं, तो Agent Platform (Vertex AI) SDK टूल की पैकेजिंग यूटिलिटी, आर्टफ़ैक्ट को डिफ़ॉल्ट रूप से agent_engine/ में स्टेज करती है.
• डायरेक्ट्री आइसोलेशन के बिना, एक साथ या क्रम से एजेंट डिप्लॉय करने पर, एक-दूसरे की पिकल की गई डिपेंडेंसी और पैकेज मेनिफ़ेस्ट ओवरराइट हो जाएंगे. हर एजेंट के कॉन्फ़िगरेशन डिक्शनरी में, हमेशा एक अलग "gcs_dir_name" तय करें. उदाहरण के लिए, "burger_agent", "pizza_agent", और "concierge_agent".

हमारी Unified Access Policy में नियम 1 पहले से मौजूद है. इसलिए, Google Cloud API को कंटेनर शुरू करने के अनुरोध, बिना किसी रुकावट के गेटवे से भेजे जा सकते हैं.

बर्गर और पिज़्ज़ा बेचने वाले एजेंट को PROJECT_SELLERS पर डिप्लॉय करना

# 1. deploy Burger Seller Agent to PROJECT_SELLERS
uv run --directory ./cross-project-multiagent python deploy_burger.py \
  --project=${PROJECT_SELLERS} \
  --region=${REGION} \
  --governance-project=${PROJECT_GOVERNANCE} \
  --gateway=projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agentGateways/${AGW_NAME}

# 2. deploy Pizza Seller Agent to PROJECT_SELLERS
uv run --directory ./cross-project-multiagent python deploy_pizza.py \
  --project=${PROJECT_SELLERS} \
  --region=${REGION} \
  --governance-project=${PROJECT_GOVERNANCE} \
  --gateway=projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agentGateways/${AGW_NAME}

सेलर गेटवे रूटिंग की पुष्टि करना

# retrieve deployed seller reasoning engine IDs
export BURGER_ENGINE_ID=$(grep BURGER_SELLER_AGENT_ID cross-project-multiagent/burger_agent.env | awk -F'/' '{print $NF}')
export PIZZA_ENGINE_ID=$(grep PIZZA_SELLER_AGENT_ID cross-project-multiagent/pizza_agent.env | awk -F'/' '{print $NF}')

echo "Burger Engine ID: ${BURGER_ENGINE_ID}"
echo "Pizza Engine ID:  ${PIZZA_ENGINE_ID}"

# inspect runtime configuration for both Seller Agents
for ENGINE_ID in ${BURGER_ENGINE_ID} ${PIZZA_ENGINE_ID}; do
  curl -s -X GET "https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_SELLERS}/locations/${REGION}/reasoningEngines/${ENGINE_ID}" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json" \
    | jq '{displayName: .displayName, identityType: .spec.identityType, effectiveIdentity: .spec.effectiveIdentity, agentGatewayConfig: .spec.deploymentSpec.agentGatewayConfig}'
done

खरीदारी में मदद करने वाले एजेंट को PROJECT_CONCIERGE पर डिप्लॉय करें

# deploy Purchasing Concierge to PROJECT_CONCIERGE
uv run --directory ./cross-project-multiagent python deploy_concierge_adk.py \
  --project=${PROJECT_CONCIERGE} \
  --region=${REGION} \
  --staging-bucket=gs://${PROJECT_GOVERNANCE}-shared-staging \
  --gateway-name=${AGW_NAME} \
  --gateway-project=${PROJECT_GOVERNANCE}

परचेज़िंग गेटवे रूटिंग की पुष्टि करना

# retrieve Concierge engine ID
export CONCIERGE_ENGINE_ID=$(grep CONCIERGE_AGENT_ID cross-project-multiagent/concierge_agent.env | awk -F'/' '{print $NF}')
echo "Concierge Engine ID: ${CONCIERGE_ENGINE_ID}"

# inspect runtime configuration for Purchasing Concierge
curl -s -X GET "https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  | jq '{displayName: .displayName, identityType: .spec.identityType, effectiveIdentity: .spec.effectiveIdentity, agentGatewayConfig: .spec.deploymentSpec.agentGatewayConfig}'

आउटपुट में, Concierge एजेंट की रनटाइम आइडेंटिटी और प्रोजेक्ट के साथ-साथ, Governance प्रोजेक्ट के Agent Gateway से बाइंडिंग दिखनी चाहिए.

{
  "displayName": "purchasing-concierge-adk",
  "identityType": "AGENT_IDENTITY",
  "effectiveIdentity": "agents.global.org-${ORG_ID}.system.id.goog/resources/aiplatform/projects/${PROJECT_CONCIERGE}/locations/us-central1/reasoningEngines/${CONCIERGE_ENGINE_ID}",
  "agentGatewayConfig": {
    "agentToAnywhereConfig": {
      "agentGateway": "projects/${PROJECT_GOVERNANCE}/locations/us-central1/agentGateways/centralized-agw"
    }
  }
}

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

8. क्रॉस-प्रोजेक्ट रजिस्ट्री

सेंट्रल एजेंट रजिस्ट्री में एजेंट रजिस्टर करना

क्रॉस-प्रोजेक्ट रीजनल एमटीएलएस एंडपॉइंट और अंकों वाले प्रोजेक्ट नंबर का इस्तेमाल करके, PROJECT_GOVERNANCE में सेंट्रल एजेंट रजिस्ट्री में तीनों एजेंट रजिस्टर करें.

एजेंट रजिस्ट्री में, सेवाओं को नॉन-एटूए एजेंट के तौर पर रजिस्टर करना

# 1. register Burger Seller Agent
gcloud agent-registry services create burger-seller-agent \
  --project=${PROJECT_GOVERNANCE} \
  --location=${REGION} \
  --display-name="Burger Seller Agent" \
  --description="Specialist agent that sells burgers and fries" \
  --agent-spec-type=no-spec \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com:443/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com:443/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com:443/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com:443/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${BURGER_ENGINE_ID}:query

# 2. register Pizza Seller Agent
gcloud agent-registry services create pizza-seller-agent \
  --project=${PROJECT_GOVERNANCE} \
  --location=${REGION} \
  --display-name="Pizza Seller Agent" \
  --description="Specialist agent that sells pizzas and pasta" \
  --agent-spec-type=no-spec \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com:443/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com:443/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com:443/v1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com:443/v1beta1/projects/${PROJECT_NUMBER_SELLERS}/locations/${REGION}/reasoningEngines/${PIZZA_ENGINE_ID}:query

# 3. register Purchasing Concierge Agent
gcloud agent-registry services create purchasing-concierge-adk \
  --project=${PROJECT_GOVERNANCE} \
  --location=${REGION} \
  --display-name="Purchasing Concierge Agent" \
  --description="Orchestrator concierge agent that routes purchasing requests" \
  --agent-spec-type=no-spec \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com:443/v1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.googleapis.com:443/v1beta1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com/v1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com/v1beta1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com:443/v1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query \
  --interfaces=protocolBinding=JSONRPC,url=https://${REGION}-aiplatform.mtls.googleapis.com:443/v1beta1/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}:query

अंडरलाइंग एजेंट रजिस्ट्री आईडी कैप्चर करना

# capture underlying Agent Registry Agent UUIDs
export BURGER_AGENT_ID=$(gcloud agent-registry services describe burger-seller-agent --project=${PROJECT_GOVERNANCE} --location=${REGION} --format="value(registryResource)" | awk -F'/' '{print $NF}')
export PIZZA_AGENT_ID=$(gcloud agent-registry services describe pizza-seller-agent --project=${PROJECT_GOVERNANCE} --location=${REGION} --format="value(registryResource)" | awk -F'/' '{print $NF}')
export CONCIERGE_AGENT_ID=$(gcloud agent-registry services describe purchasing-concierge-adk --project=${PROJECT_GOVERNANCE} --location=${REGION} --format="value(registryResource)" | awk -F'/' '{print $NF}')

echo "Burger Agent ID:    ${BURGER_AGENT_ID}"
echo "Pizza Agent ID:     ${PIZZA_AGENT_ID}"
echo "Concierge Agent ID: ${CONCIERGE_AGENT_ID}"

IAPv2 CATALOG ATTRIBUTE EVALUATION: इन सेवाओं को --agent-spec-type=no-spec के साथ रजिस्टर किया गया था. इसलिए, इन्हें Agent संसाधनों के तौर पर कैटलॉग किया गया है. IAP v2 के तहत, यूनिफ़ाइड ऐक्सेस नीतियां, सीईएल एक्सप्रेशन का आकलन करती हैं. ये एक्सप्रेशन, इनसे मैच करते हैं:

• destination.agent_registry.resource_type == 'AGENT'
• destination.agent_registry.agent.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agents/${BURGER_AGENT_ID}' (या आसान सर्विस पाथ)

रजिस्ट्री कॉन्फ़िगरेशन की प्रोसेस पूरी हो गई है... अब A2A इग्रेस नीतियों को कॉन्फ़िगर करें सेक्शन पर जाएं.

9. UAP की नीतियां

Unified Access Policy में, A2A इग्रेस डेटा ट्रैफ़िक की नीतियां कॉन्फ़िगर करना

एजेंट गेटवे के डिफ़ॉल्ट रूप से अस्वीकार करें आर्किटेक्चर के तहत, सख्त लागू करें मोड में:

1. पहला नियम (Google Cloud के बुनियादी एपीआई): तीनों प्रोजेक्ट में मौजूद एजेंट कंटेनर को core-gapi-services तक पहुंचने की अनुमति देता है.
2. नियम 2 (बर्गर सेलर एजेंट: अनुमति दें): यह नियम, खरीदारी में मदद करने वाले एजेंट के इंस्टेंस को खास तौर पर बर्गर सेलर एजेंट को शुरू करने की अनुमति देता है.
3. पिज़्ज़ा बेचने वाला एजेंट (डिफ़ॉल्ट रूप से अस्वीकार किया गया): इसे नीति के नियमों से जान-बूझकर बाहर रखा गया है. ENFORCE मोड (failOpen: false) में, अगर Concierge, Pizza Seller को शुरू करने की कोशिश करता है, तो उसे गेटवे पेरीमीटर पर HTTP 403 Forbidden के साथ तुरंत बंद कर दिया जाएगा.

Concierge एजेंट की पहचान सेट अप करना

# formulate the exact SPIFFE machine identity for the Concierge Agent
export CONCIERGE_SPIFFE_PRINCIPAL="principal://agents.global.org-${ORG_ID}.system.id.goog/resources/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}"
echo "Concierge SPIFFE Principal: ${CONCIERGE_SPIFFE_PRINCIPAL}"

नियम 1 और 2 के साथ अपडेट मेनिफ़ेस्ट

मौजूदा नियमों को बदले बिना ऐक्सेस नीति को सुरक्षित तरीके से अपडेट करने के लिए, नियम 1 (Google के मुख्य एपीआई) और नियम 2 (बर्गर सेलर एजेंट) वाले पूरे मेनिफ़ेस्ट को तय करें:

# create consolidated policy manifest with Rule 1 and Rule 2
cat > cfg/uap-rules-consolidated.json << EOF
[
  {
    "description": "Rule 1: Allow agent runtimes across all 3 projects to reach Core Google APIs",
    "effect": "ALLOW",
    "principals": [
      "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_GOVERNANCE}",
      "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}",
      "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_SELLERS}"
    ],
    "operation": {
      "permissions": [
        "iap.googleapis.com/resources.egressViaIAP"
      ]
    },
    "conditions": {
      "iap.googleapis.com": {
        "expression": \
        "destination.is_registered == true && \
         destination.agent_registry.resource_type == 'ENDPOINT' && ( \
         destination.agent_registry.endpoint.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/endpoints/core-gapi-services' || \
         destination.agent_registry.endpoint.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/endpoints/${ENDPOINT_ID}' || \
         destination.agent_registry.endpoint.name == 'projects/${PROJECT_NUMBER_GOVERNANCE}/locations/${REGION}/endpoints/${ENDPOINT_ID}')"
      }
    }
  },
  {
    "description": "Rule 2: Allow Purchasing Concierge to invoke Burger Seller Agent via Central Gateway",
    "effect": "ALLOW",
    "principals": [
      "${CONCIERGE_SPIFFE_PRINCIPAL}",
      "principal://agents.global.org-${ORG_ID}.system.id.goog/attribute.agentIdentity/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}",
      "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.agentIdentity/projects/${PROJECT_NUMBER_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}"
    ],
    "operation": {
      "permissions": [
        "iap.googleapis.com/resources.egressViaIAP"
      ]
    },
    "conditions": {
      "iap.googleapis.com": {
        "expression": \
        "destination.is_registered == true && \
         destination.agent_registry.resource_type == 'AGENT' && ( \
         destination.agent_registry.agent.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agents/burger-seller-agent' || \
         destination.agent_registry.agent.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agents/${BURGER_AGENT_ID}' || \
         destination.agent_registry.agent.name == 'projects/${PROJECT_NUMBER_GOVERNANCE}/locations/${REGION}/agents/${BURGER_AGENT_ID}')"
      }
    }
  }
]
EOF

ऐक्सेस की अपडेट की गई नीति लागू करें

--details-rules का इस्तेमाल करके, नियमों के इकट्ठा किए गए मेनिफ़ेस्ट को डिक्लेरेटिव तरीके से लागू करें:

# update IAM access policy with consolidated manifest (Rule 1 + Rule 2)
gcloud iam access-policies update ${UAP_POLICY_NAME} \
  --details-rules=cfg/uap-rules-consolidated.json \
  --project=${PROJECT_GOVERNANCE} \
  --location=global

नियमों को ओवरराइट करने से बचें:
--details-rules और --add-details-rules के बीच का अंतर ध्यान में रखें. --details-rules के साथ gcloud iam access-policies update को चलाने पर, नियमों का पूरा सेट बदल जाता है. अगर आपने --details-rules के साथ सिर्फ़ नियम 2 वाली फ़ाइल पास की, तो नियम 1 (Google के मुख्य एपीआई) को बदल दिया जाएगा. इससे Gemini और एजेंट रजिस्ट्री के लिए आउटबाउंड कनेक्टिविटी टूट जाएगी. अपने कॉन्फ़िगरेशन मेनिफ़ेस्ट में, नियमों की पूरी सूची हमेशा बनाए रखें या एक नियम जोड़ते समय --add-details-rules का इस्तेमाल करें.

IAM ऐक्सेस नीति की जानकारी की पुष्टि करना

# inspect updated access policy
gcloud iam access-policies describe ${UAP_POLICY_NAME} \
  --project=${PROJECT_GOVERNANCE} \
  --location=global

आउटपुट का सैंपल:

details:
  rules:
  - conditions:
      iap.googleapis.com:
        expression: destination.is_registered == true && destination.agent_registry.resource_type
          == 'ENDPOINT' && (destination.agent_registry.endpoint.name == 'projects/${PROJECT_GOVERNANCE}/locations/us-central1/endpoints/core-gapi-services'
          || destination.agent_registry.endpoint.name == 'projects/${PROJECT_NUMBER_GOVERNANCE}/locations/us-central1/endpoints/${ENDPOINT_ID}')
    description: 'Rule 1: Allow agent runtimes across all 3 projects to reach Core
      Google APIs'
    effect: ALLOW
    operation:
      permissions:
      - iap.googleapis.com/resources.egressViaIAP
    principals:
    - principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_GOVERNANCE}
    - principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}
    - principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_SELLERS}
  - conditions:
      iap.googleapis.com:
        expression: (destination.is_registered == true) && (destination.agent_registry.resource_type
          == 'AGENT') && (destination.agent_registry.agent.name == 'projects/${PROJECT_GOVERNANCE}/locations/us-central1/agents/burger-seller-agent'
          || destination.agent_registry.agent.name == 'projects/${PROJECT_NUMBER_GOVERNANCE}/locations/us-central1/agents/${BURGER_AGENT_ID}')
    description: 'Rule 2: Allow Purchasing Concierge to invoke Burger Seller Agent
      via Central Gateway'
    effect: ALLOW
    operation:
      permissions:
      - iap.googleapis.com/resources.egressViaIAP
    principals:
    - principal://agents.global.org-${ORG_ID}.system.id.goog/resources/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}/locations/us-central1/reasoningEngines/${CONCIERGE_ENGINE_ID}
name: projects/${PROJECT_GOVERNANCE}/locations/global/accessPolicies/uap-policy-centralized-agw

डिफ़ॉल्ट रूप से अस्वीकार किए जाने की स्थिति: ध्यान दें कि नियमों की सूची में pizza-seller-agent मौजूद नहीं है. स्ट्रिक्ट ENFORCE मोड में, अगर Concierge, Pizza Agent से क्वेरी करने की कोशिश करता है, तो Central Agent Gateway पर HTTP 403 Forbidden के साथ उसे ब्लॉक कर दिया जाएगा.

इससे नीति का सेटअप पूरा हो जाता है... इसके बाद, गवर्नेंस से जुड़ी नीतियों की जांच करें और उनकी पुष्टि करें सेक्शन पर जाएं.

10. नीतियों की पुष्टि करना

Cloud Logging की मदद से, गवर्नेंस से जुड़ी नीतियों की जांच करना और उनकी पुष्टि करना

इस सेक्शन में, Agent Runtime AI Playground में क्रॉस-प्रोजेक्ट एजेंट-टू-एजेंट (A2A) इंटरैक्शन की जांच की जाएगी. साथ ही, स्ट्रिक्ट ENFORCE मोड में रीयल पेरीमीटर HTTP 403 Forbidden ब्लॉकिंग को देखा जाएगा. इसके अलावा, यूनिफ़ाइड ऐक्सेस पॉलिसी में लाइव बदलाव किया जाएगा और ऑर्डर को तुरंत मंज़ूरी देने की पुष्टि की जाएगी.

नीति लागू होने में देरी:
यूनिफ़ाइड ऐक्सेस नीतियों में किए गए बदलावों को सभी एज प्रॉक्सी पर लागू होने में दो से तीन मिनट लग सकते हैं. किसी नीति को अपडेट करने के बाद, क्वेरी की जांच करने से पहले कुछ मिनट इंतज़ार करें. तुरंत क्वेरी करने पर, हो सकता है कि पिछली नीति का ही आकलन किया जाए और 403 Forbidden दिखे.

पहला चरण: PROJECT_CONCIERGE में Agent Runtime एआई प्लेग्राउंड खोलें

1. Google Cloud Console खोलें.
2. सबसे ऊपर मौजूद प्रोजेक्ट सिलेक्टर बार में, PROJECT_CONCIERGE पर स्विच करें.
3. नेविगेशन मेन्यू में, Agent Platform > Agents > Deployments पर जाएं.
4. purchasing-concierge-adk पर क्लिक करें.
5. स्क्रीन की दाईं ओर, इंटरैक्टिव चैट इंटरफ़ेस खोलने के लिए, Playground को चुनें.

दूसरा चरण: बर्गर ऑर्डर की जांच करना (नियम 2 मैच -> 200 OK)

Playground चैट विंडो में, ऑर्डर से जुड़ा यह प्रॉम्प्ट सबमिट करें:

I would like 10 Classic Cheeseburgers. Place this order now.

अगर पुष्टि करने के लिए जवाब देना ज़रूरी है, तो यह जवाब सबमिट करें:

Confirmed, please place the order.

इसके अलावा, Cloud Shell / टर्मिनल से प्रोग्राम के हिसाब से टेस्ट करें:

uv run --directory ./cross-project-multiagent python -c "
import vertexai
from vertexai.preview import reasoning_engines
vertexai.init(project='${PROJECT_CONCIERGE}', location='${REGION}')
agent = reasoning_engines.ReasoningEngine('projects/${PROJECT_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}')
response = agent.query(input={'message': 'I would like 22 Spicy Cajun Burgers please. Place this order now.'})
print(response)
"

अगर आपको पुष्टि करने के लिए जवाब चाहिए, तो इस निर्देश का इस्तेमाल करें:

uv run --directory ./cross-project-multiagent python -c "
import vertexai
from vertexai.preview import reasoning_engines
vertexai.init(project='${PROJECT_CONCIERGE}', location='${REGION}')
agent = reasoning_engines.ReasoningEngine('projects/${PROJECT_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}')
response = agent.query(input='Yes please place the order now.')
print(response['text'])
"

पर्दे के पीछे क्या होता है:

1. डाइनैमिक डिस्कवरी: सेशन शुरू होने के दौरान, Purchasing Concierge ने PROJECT_GOVERNANCE में सेंट्रल एजेंट रजिस्ट्री से क्वेरी की. यह क्वेरी, core-gapi-services में एजेंट गेटवे के ज़रिए की गई थी. इस गेटवे को नियम 1 के तहत अनुमति मिली है. इसका मकसद, burger-seller-agent के लिए रीजनल एमटीएलएस एंडपॉइंट का पता लगाना था.
2. इंटेंट रिज़ॉल्यूशन और A2A इन्वोकेशन: Purchasing Concierge में मौजूद Gemini, खाने के ऑर्डर के इंटेंट को पार्स करता है. इसके बाद, वह https://${REGION}-aiplatform.mtls.googleapis.com/.../reasoningEngines/${BURGER_ENGINE_ID} को आउटबाउंड आरपीसी भेजकर, बर्गर सेलर एजेंट को कॉल करता है.
3. गेटवे इंटरसेप्शन और SPIFFE प्रोपेगेशन: इग्रेस ट्रैफ़िक को agent_gateway_config कैप्चर करता है और PROJECT_GOVERNANCE में सेंट्रल एजेंट गेटवे पर भेजता है. इसमें Concierge की क्रिप्टोग्राफ़िक SPIFFE आइडेंटिटी (principal://...) शामिल होती है.
4. आईएपी v2 की नीति का आकलन: सेंट्रल एजेंट गेटवे, आईएपी की अनुमति देने वाले एक्सटेंशन (authzExtension) को शुरू करता है. आईएपी v2, आईएएम की यूनिफ़ाइड ऐक्सेस पॉलिसी में मौजूद नियम 2 का आकलन करता है. कॉलर ${CONCIERGE_SPIFFE_PRINCIPAL} से मैच करता है और टारगेट burger-seller-agent से मैच करता है. इसलिए, आईएपी ALLOW (granted: true) दिखाता है.
5. क्रॉस-प्रोजेक्ट एक्ज़ीक्यूशन: एजेंट गेटवे, अनुमति वाले अनुरोध को क्रॉस-प्रोजेक्ट के ज़रिए PROJECT_SELLERS में भेजता है. यहां बर्गर सेलर रीज़निंग इंजन, ऑर्डर को प्रोसेस करता है और पुष्टि करता है.

उम्मीद के मुताबिक जवाब:

Your order for 10 Classic Cheeseburger(s) has been placed!
Here is a summary of your order:
- 10x Classic Cheeseburger @ IDR 85,000/each = IDR 850,000

Total: IDR 850,000
Your Order ID is: e8f9c732-f347-4cc4-acff-cfe09ccbeddd

तीसरा चरण: Agent Gateway और IAP v2 के ऑडिट लॉग की जांच करना (एचटीटीपी 200 / अनुमति है)

PROJECT_GOVERNANCE में एजेंट गेटवे के अनुरोध के लॉग के लिए क्वेरी करें:

ध्यान दें: Cloud Logging में डेटा डालने में आम तौर पर 10 से 30 सेकंड लगते हैं. अगर एजेंट क्वेरी को ट्रिगर करने के तुरंत बाद क्वेरी का जवाब नहीं मिलता है, तो 15 से 20 सेकंड इंतज़ार करें और फिर से कमांड चलाएं.

# query Agent Gateway logs for successful 200 OK requests
gcloud logging read "
  logName=\"projects/${PROJECT_GOVERNANCE}/logs/networkservices.googleapis.com%2Fgateway_requests\"
  AND jsonPayload.authzPolicyInfo.result=\"ALLOWED\"
" \
  --project="${PROJECT_GOVERNANCE}" \
  --limit=10 \
  --format="table(
    timestamp.date('%H:%M:%S'):label=TIME,
    httpRequest.requestMethod:label=METHOD,
    httpRequest.status:label=STATUS,
    jsonPayload.authzPolicyInfo.result:label=AUTHZ,
    httpRequest.requestUrl:label=URL
  )"

लॉग में, दोनों स्पोक प्रोजेक्ट (PROJECT_CONCIERGE और PROJECT_SELLERS) से आने वाले आउटबाउंड ट्रैफ़िक को कैप्चर किया जाना चाहिए. इसमें इग्रेस फ़ील्ड के तौर पर, Gemini के रीज़निंग कॉल (generateContent), Cloud Trace टेलीमेट्री (/v1/traces), और आईएएम क्रेडेंशियल लुकअप शामिल होने चाहिए. इन्हें नियम 1 (core-gapi-services) के तहत, पारदर्शी तरीके से इंटरसेप्ट और अनुमति दी जाती है.

नीति के वर्शन POLICY_VERSION_V2 की पुष्टि करने के लिए, IAP v2 क्लाउड ऑडिट डेटा ऐक्सेस लॉग के बारे में क्वेरी करें:

# query IAP v2 audit logs with shortened principal and resource fields
gcloud logging read "
  logName=\"projects/${PROJECT_GOVERNANCE}/logs/cloudaudit.googleapis.com%2Fdata_access\"
  AND protoPayload.serviceName=\"iap.googleapis.com\"
" \
  --project="${PROJECT_GOVERNANCE}" \
  --limit=5 \
  --format="table(
    timestamp.date('%H:%M:%S'):label=TIME,
    protoPayload.authenticationInfo.principalSubject.sub('\.global\..*\/reasoningEngines\/', '.[...]/reasoningEngines/'):label=CALLER,
    protoPayload.authorizationInfo[0].granted:label=GRANTED,
    protoPayload.metadata.destination.agent_registry.resource_type.basename():label=TYPE,
    protoPayload.metadata.destination.agent_registry.resource_id.basename():label=RESOURCE_ID,
    protoPayload.authorizationInfo[0].permission.basename():label=PERMISSION
  )"

आउटपुट का सैंपल:

TIME      CALLER                                                            GRANTED  TYPE      RESOURCE_ID     PERMISSION
HH:MM:SS  principal://agents.[...]/reasoningEngines/${CONCIERGE_ENGINE_ID}  True     Endpoint  ${ENDPOINT_ID}  resources.egressViaIAP
HH:MM:SS  principal://agents.[...]/reasoningEngines/${BURGER_ENGINE_ID}     True     Endpoint  ${ENDPOINT_ID}  resources.egressViaIAP
HH:MM:SS  principal://agents.[...]/reasoningEngines/${CONCIERGE_ENGINE_ID}  True     Endpoint  ${ENDPOINT_ID}  resources.egressViaIAP
HH:MM:SS  principal://agents.[...]/reasoningEngines/${BURGER_ENGINE_ID}     True     Endpoint  ${ENDPOINT_ID}  resources.egressViaIAP

चौथा चरण: पिज़्ज़ा ऑर्डर करने की सुविधा को टेस्ट करना (डिफ़ॉल्ट रूप से ऐक्सेस नहीं दिया गया -> एचटीटीपी 403 फ़ॉरबिडन लागू किया गया)

Playground की उसी चैट विंडो में, पिज़्ज़ा ऑर्डर करने के लिए यह प्रॉम्प्ट सबमिट करें:

I would like 10 BBQ Chicken Pizzas. Place this order now.

अगर पुष्टि करने के लिए जवाब देना ज़रूरी है, तो यह जवाब सबमिट करें:

Confirmed, please place the order.

इसके अलावा, Cloud Shell / टर्मिनल से प्रोग्राम के हिसाब से टेस्ट करें:

uv run --directory ./cross-project-multiagent python -c "
import vertexai
from vertexai.preview import reasoning_engines
vertexai.init(project='${PROJECT_CONCIERGE}', location='${REGION}')
agent = reasoning_engines.ReasoningEngine('projects/${PROJECT_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}')
response = agent.query(input='I would like 8 Hawaiian pizzas, please. Place this order now.')
print(response)
"

अगर आपको पुष्टि करने के लिए जवाब चाहिए, तो इस निर्देश का इस्तेमाल करें:

uv run --directory ./cross-project-multiagent python -c "
import vertexai
from vertexai.preview import reasoning_engines
vertexai.init(project='${PROJECT_CONCIERGE}', location='${REGION}')
agent = reasoning_engines.ReasoningEngine('projects/${PROJECT_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}')
response = agent.query(input='Yes please place the order now.')
print(response['text'])
"

उम्मीद के मुताबिक जवाब:

I apologize, but I am unable to process that request at the moment. It seems
there was an issue connecting to the pizza seller agent. Please try again later.

पर्दे के पीछे क्या होता है:

1. डाइनैमिक डिस्कवरी: खरीदारी में मदद करने वाले एजेंट ने स्टार्टअप के दौरान, सेंट्रल एजेंट रजिस्ट्री से pizza-seller-agent एंडपॉइंट को रिज़ॉल्व किया.
2. इंटेंट रिज़ॉल्यूशन और A2A को शुरू करना: खरीदारी में मदद करने वाले एजेंट में मौजूद Gemini, पिज़्ज़ा ऑर्डर करने के अनुरोध को PROJECT_SELLERS में मौजूद पिज़्ज़ा सेलर एंडपॉइंट पर भेजने की कोशिश करता है.
3. गेटवे इंटरसेप्शन: आउटबाउंड आरपीसी को agent_gateway_config कैप्चर करता है और सेंट्रल एजेंट गेटवे पर भेजता है.
4. IAP v2 की नीति का आकलन (डिफ़ॉल्ट रूप से ऐक्सेस अस्वीकार करना): सेंट्रल एजेंट गेटवे, IAP v2 को शुरू करता है. यूनिफ़ाइड ऐक्सेस पॉलिसी में pizza-seller-agent से मैच करने वाला कोई नियम मौजूद नहीं है. इसलिए, आईएपी DENY (granted: false) दिखाता है.
5. सख्त पेरीमीटर ब्लॉक: Authz एक्सटेंशन ENFORCE मोड (failOpen: false) में होने की वजह से, सेंट्रल एजेंट गेटवे आउटबाउंड कनेक्शन को तुरंत बंद कर देता है और HTTP 403 Forbidden दिखाता है. ट्रैफ़िक गेटवे से बाहर नहीं जाता और PROJECT_SELLERS तक नहीं पहुंचता.

पांचवां चरण: ब्लॉक किए गए अनुरोधों (एचटीटीपी 403 / अस्वीकार किया गया) के लिए, एजेंट गेटवे लॉग की जांच करना

# query Agent Gateway logs for blocked 403 requests
gcloud logging read "
  logName=\"projects/${PROJECT_GOVERNANCE}/logs/networkservices.googleapis.com%2Fgateway_requests\"
  AND httpRequest.status=403
" \
  --project="${PROJECT_GOVERNANCE}" \
  --limit=5 \
  --format="table(
    timestamp.date('%H:%M:%S'):label=TIME,
    httpRequest.requestMethod:label=METHOD,
    httpRequest.status:label=STATUS,
    jsonPayload.authzPolicyInfo.result:label=AUTHZ,
    httpRequest.requestUrl:label=URL
  )"

अस्वीकार किए गए लॉग आउटपुट का सैंपल:

TIME      METHOD  STATUS  AUTHZ   URL
HH:MM:SS  POST    403     DENIED  https://us-central1-aiplatform.mtls.googleapis.com/v1beta1/projects/${PROJECT_SELLERS}/locations/us-central1/reasoningEngines/${PIZZA_ENGINE_ID}:query

अनुरोध अस्वीकार किए जाने के फ़ैसले के लिए, IAP v2 के डेटा ऐक्सेस ऑडिट लॉग की क्वेरी करें:

# query IAP v2 audit logs with shortened principal and resource fields
gcloud logging read "
  logName=\"projects/${PROJECT_GOVERNANCE}/logs/cloudaudit.googleapis.com%2Fdata_access\"
  AND protoPayload.serviceName=\"iap.googleapis.com\"
" \
  --project="${PROJECT_GOVERNANCE}" \
  --limit=5 \
  --format="table(
    timestamp.date('%H:%M:%S'):label=TIME,
    protoPayload.authenticationInfo.principalSubject.sub('\.global\..*\/reasoningEngines\/', '.[...]/reasoningEngines/'):label=CALLER,
    protoPayload.authorizationInfo[0].granted:label=GRANTED,
    protoPayload.metadata.destination.agent_registry.resource_type.basename():label=TYPE,
    protoPayload.metadata.destination.agent_registry.resource_id.basename():label=RESOURCE_ID,
    protoPayload.authorizationInfo[0].permission.basename():label=PERMISSION
  )"

मंज़ूरी न मिलने पर ऑडिट लॉग के आउटपुट का सैंपल:

TIME      CALLER                                                            GRANTED  TYPE      RESOURCE_ID     PERMISSION
HH:MM:SS  principal://agents.[...]/reasoningEngines/${PIZZA_ENGINE_ID}      True     Endpoint  ${REGISTRY_ID}  resources.egressViaIAP
HH:MM:SS  principal://agents.[...]/reasoningEngines/${PIZZA_ENGINE_ID}      True     Endpoint  ${REGISTRY_ID}  resources.egressViaIAP
HH:MM:SS  principal://agents.[...]/reasoningEngines/${CONCIERGE_ENGINE_ID}  False    Agent     ${REGISTRY_ID}  resources.egressViaIAP
HH:MM:SS  principal://agents.[...]/reasoningEngines/${PIZZA_ENGINE_ID}      True     Endpoint  ${REGISTRY_ID}  resources.egressViaIAP

छठा चरण: पिज़्ज़ा एजेंट को डाइनैमिक तौर पर इग्रेस ऐक्सेस देना

नियम 1 (मुख्य एपीआई), नियम 2 (बर्गर विक्रेता एजेंट), और अब नियम 3 (पिज़्ज़ा विक्रेता एजेंट) को शामिल करने के लिए, नया cfg/uap-rules-update-3.json बनाएं

# create addendum to update policy manifest with Rule 3 for Pizza Agent
cat > cfg/uap-rules-update-3.json << EOF
[
  {
    "description": "Rule 3: Allow Purchasing Concierge to invoke Pizza Seller Agent via Central Gateway",
    "effect": "ALLOW",
    "principals": [
      "${CONCIERGE_SPIFFE_PRINCIPAL}"
    ],
    "operation": {
      "permissions": [
        "iap.googleapis.com/resources.egressViaIAP"
      ]
    },
    "conditions": {
      "iap.googleapis.com": {
        "expression": \
        "destination.is_registered == true && \
         destination.agent_registry.resource_type == 'AGENT' && ( \
         destination.agent_registry.agent.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agents/pizza-seller-agent' || \
         destination.agent_registry.agent.name == 'projects/${PROJECT_GOVERNANCE}/locations/${REGION}/agents/${PIZZA_AGENT_ID}' || \
         destination.agent_registry.agent.name == 'projects/${PROJECT_NUMBER_GOVERNANCE}/locations/${REGION}/agents/${PIZZA_AGENT_ID}')"
      }
    }
  }
]
EOF

नीति में किए गए अपडेट को लाइव लागू करें:

# update IAM access policy with Pizza rule
gcloud iam access-policies update ${UAP_POLICY_NAME} \
  --add-details-rules=cfg/uap-rules-update-3.json \
  --project=${PROJECT_GOVERNANCE} \
  --location=global

नीति लागू होने में लगने वाला समय:
ऐक्सेस नीति को अपडेट करने के बाद, फिर से जांच करने से पहले दो से तीन मिनट इंतज़ार करें. अगर तुरंत जांच की जाती है, तो हो सकता है कि पिछली नीति अब भी चालू हो और 403 Forbidden दिखा रही हो.

सातवां चरण: पिज़्ज़ा एजेंट से फिर से क्वेरी करना (तुरंत 200 OK रिस्पॉन्स मिलना)

Playground की चैट विंडो में, पिज़्ज़ा ऑर्डर करने का प्रॉम्प्ट फिर से सबमिट करें:

I would like 10 BBQ Chicken Pizzas. Place this order now.

अगर पुष्टि करने के लिए जवाब देना ज़रूरी है, तो यह जवाब सबमिट करें:

Confirmed, please place the order.

इसके अलावा, Cloud Shell / टर्मिनल से प्रोग्राम के हिसाब से टेस्ट करें:

uv run --directory ./cross-project-multiagent python -c "
import vertexai
from vertexai.preview import reasoning_engines
vertexai.init(project='${PROJECT_CONCIERGE}', location='${REGION}')
agent = reasoning_engines.ReasoningEngine('projects/${PROJECT_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}')
response = agent.query(input='I would like 11 Veggie pizzas, please. Place this order now.')
print(response)
"

अगर आपको पुष्टि करने के लिए जवाब चाहिए, तो इस निर्देश का इस्तेमाल करें:

uv run --directory ./cross-project-multiagent python -c "
import vertexai
from vertexai.preview import reasoning_engines
vertexai.init(project='${PROJECT_CONCIERGE}', location='${REGION}')
agent = reasoning_engines.ReasoningEngine('projects/${PROJECT_CONCIERGE}/locations/${REGION}/reasoningEngines/${CONCIERGE_ENGINE_ID}')
response = agent.query(input='Yes please place the order now.')
print(response['text'])
"

उम्मीद के मुताबिक जवाब:

Your order has been placed!

**Order ID:** 8d6c13d7-31dc-4d80-b6a7-80d1e50b6411

**Order Details:**
*   10 x BBQ Chicken Pizza @ IDR 130,000 each = IDR 1,300,000

**Total: IDR 1,300,000**

पर्दे के पीछे क्या होता है:

1. डाइनैमिक पॉलिसी रीफ़्रेश: आईएएम यूनिफ़ाइड ऐक्सेस पॉलिसी को अपडेट करने पर, यह आईएपी इवैलुएशन इंजन में तुरंत लागू हो जाती है. इसके लिए, किसी भी कंटेनर को फिर से डिप्लॉय करने की ज़रूरत नहीं होती और न ही कोई डाउनटाइम होता है.
2. A2A को शुरू करना: Concierge, Central Agent Gateway के ज़रिए अनुरोध भेजता है.
3. IAP v2 की नीति का आकलन (अनुमति): IAP v2, तीसरे नियम से मैच करता है. साथ ही, कॉलर की पहचान और टारगेट सीईएल एक्सप्रेशन की पुष्टि करता है. इसके बाद, ALLOW (granted: true) दिखाता है.
4. क्रॉस-प्रोजेक्ट एक्ज़ीक्यूशन: Central Agent Gateway, अनुमति वाले ट्रैफ़िक को PROJECT_SELLERS में प्रॉक्सी करता है. यहां पिज़्ज़ा सेलर, ऑर्डर को प्रोसेस करता है.

आठवां चरण: अनुमति पा चुके पिज़्ज़ा के अनुरोधों के लिए, एजेंट गेटवे लॉग की जांच करना

# query Agent Gateway logs for successful 200 OK requests
gcloud logging read "
  logName=\"projects/${PROJECT_GOVERNANCE}/logs/networkservices.googleapis.com%2Fgateway_requests\"
  AND jsonPayload.authzPolicyInfo.result=\"ALLOWED\"
" \
  --project="${PROJECT_GOVERNANCE}" \
  --limit=10 \
  --format="table(
    timestamp.date('%H:%M:%S'):label=TIME,
    httpRequest.requestMethod:label=METHOD,
    httpRequest.status:label=STATUS,
    jsonPayload.authzPolicyInfo.result:label=AUTHZ,
    httpRequest.requestUrl:label=URL
  )"

अनुमति मिलने के बाद लॉग आउटपुट का सैंपल:

TIME      METHOD  STATUS  AUTHZ    URL
HH:MM:SS  POST    200     ALLOWED  https://aiplatform.mtls.googleapis.com/v1beta1/projects/${PROJECT_SELLERS}/locations/global/publishers/google/models/gemini-3.5-flash:generateContent
HH:MM:SS  POST    200     ALLOWED  https://us-central1-aiplatform.mtls.googleapis.com/v1beta1/projects/${PROJECT_SELLERS}/locations/us-central1/reasoningEngines/${PIZZA_ENGINE_ID}:query

नीति उल्लंघन ठीक करने के तरीके की पुष्टि हो गई है: ध्यान दें कि पिज़्ज़ा सेलर रीज़निंग इंजन (.../reasoningEngines/${PIZZA_ENGINE_ID}:query) को टारगेट करने वाले अनुरोध यूआरएल को पांचवें चरण में पहले STATUS: 403 और AUTHZ: DENIED मिला था. हालांकि, अब तीसरे नियम को डाइनैमिक तौर पर लागू करने के बाद, उसे STATUS: 200 और AUTHZ: ALLOWED मिल गया है. एजेंट को रीस्टार्ट करने या पॉड को रीसाइकल करने की ज़रूरत नहीं पड़ी.

इससे टेस्टिंग और पुष्टि की प्रोसेस पूरी हो जाती है... इसके बाद, क्लीन अप सेक्शन पर जाएं.

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

इस कोडलैब में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते पर शुल्क लगने से बचने के लिए, टियरडाउन के चरणों को डिपेंडेंसी के उल्टे क्रम में पूरा करें:

1. रीज़निंग इंजन के डिप्लॉयमेंट हटाना

रीज़निंग इंजन मिटाने के लिए, दोनों रनटाइम प्रोजेक्ट में शामिल cleanup_old_deployments.py स्क्रिप्ट को चलाएं. साथ ही, ज़्यादा समय तक चलने वाली कार्रवाइयों के पूरा होने का इंतज़ार करें:

# delete all Reasoning Engines deployed in Concierge and Sellers projects
uv run --directory ./cross-project-multiagent python cleanup_old_deployments.py --project=${PROJECT_CONCIERGE} --region=${REGION}
uv run --directory ./cross-project-multiagent python cleanup_old_deployments.py --project=${PROJECT_SELLERS} --region=${REGION}

इसके अलावा, रीज़निंग इंजन को इनलाइन भी लिस्ट किया जा सकता है और मिटाया जा सकता है:

uv run --directory ./cross-project-multiagent python -c '
import vertexai
import os
from vertexai.preview import reasoning_engines

region = os.environ.get("REGION", "us-central1")
for proj in [os.environ.get("PROJECT_CONCIERGE"), os.environ.get("PROJECT_SELLERS")]:
    if not proj:
        continue
    print(f"Cleaning reasoning engines in {proj}...")
    vertexai.init(project=proj, location=region)
    for eng in reasoning_engines.ReasoningEngine.list():
        print(f"  Deleting {eng.resource_name} ({eng.display_name})...")
        eng.delete()
'

2. एजेंट रजिस्ट्री की सेवाएं मिटाना

# delete agent registry services in Central Governance Project
for SERVICE in burger-seller-agent pizza-seller-agent purchasing-concierge-adk core-gapi-services; do
  gcloud agent-registry services delete ${SERVICE} \
    --project=${PROJECT_GOVERNANCE} \
    --location=${REGION} \
    --quiet || true
done

3. IAM Unified Access Policy बाइंडिंग और ऐक्सेस की नीति मिटाना

डिपेंडेंसी ऑर्डर नोट: ऐक्सेस नीति को मिटाने से पहले, आपको प्रोजेक्ट रिसॉर्स से ऐक्सेस नीति को अटैच करने वाली नीति बाइंडिंग को मिटाना होगा.

# 1. delete IAM policy binding
gcloud -q iam policy-bindings delete ${UAP_BINDING_NAME} \
  --project=${PROJECT_GOVERNANCE} \
  --location=global || true

# 2. delete IAM access policy
gcloud -q iam access-policies delete ${UAP_POLICY_NAME} \
  --project=${PROJECT_GOVERNANCE} \
  --location=global || true

4. एजेंट गेटवे और सुरक्षा नीतियां मिटाना

# 1. delete authorization policy
gcloud beta network-security authz-policies delete ${AGW_NAME}-authz-policy-profile-iap \
  --location=${REGION} \
  --project=${PROJECT_GOVERNANCE} --quiet || true

# 2. delete authorization extension
gcloud service-extensions authz-extensions delete ${AGW_NAME}-svc-ext-authz-iap \
  --location=${REGION} \
  --project=${PROJECT_GOVERNANCE} --quiet || true

प्रोपेगेशन में देरी: एजेंट रनटाइम डिप्लॉयमेंट को मिटाने के तुरंत बाद एजेंट गेटवे को मिटाने पर, एजेंट प्लैटफ़ॉर्म को इंटरनल नेटवर्क अटैचमेंट रिलीज़ करने में एक से दो मिनट लगते हैं. अगर आपको FAILED_PRECONDITION: Resource ... is already > being used by resource(s) ... reasoningEngines/... मिलता है, तो 60 से 90 सेकंड तक इंतज़ार करें. इसके बाद, agent-gateways delete कमांड को फिर से चलाएं.

# 3. delete agent gateway
gcloud network-services agent-gateways delete ${AGW_NAME} \
  --project=${PROJECT_GOVERNANCE} \
  --location=${REGION} --quiet || true

5. क्रॉस-प्रोजेक्ट आईएएम बाइंडिंग और कस्टम रोल हटाना

# 1. remove custom role and network viewer bindings for spoke service agents
for NUM in "${PROJECT_NUMBER_CONCIERGE}" "${PROJECT_NUMBER_SELLERS}"; do
  SA="service-${NUM}@gcp-sa-aiplatform.iam.gserviceaccount.com"
  
  gcloud projects remove-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="serviceAccount:${SA}" \
    --role="projects/${PROJECT_GOVERNANCE}/roles/ar_agw_cross_project_sa" --quiet || true

  gcloud projects remove-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="serviceAccount:${SA}" \
    --role="roles/networkservices.viewer" --quiet || true
done

# 2. remove registry viewer permissions across both spoke projects
for NUM in "${PROJECT_NUMBER_CONCIERGE}" "${PROJECT_NUMBER_SELLERS}"; do
  for MEMBER in \
    "serviceAccount:service-${NUM}@gcp-sa-aiplatform.iam.gserviceaccount.com" \
    "serviceAccount:service-${NUM}@gcp-sa-aiplatform-re.iam.gserviceaccount.com" \
    "serviceAccount:${NUM}[e-mail]" \
    "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${NUM}"; do
      gcloud projects remove-iam-policy-binding ${PROJECT_GOVERNANCE} \
        --member="${MEMBER}" \
        --role="roles/agentregistry.viewer" --quiet || true
  done
done

# 3. remove project viewer permissions
for MEMBER in \
  "serviceAccount:${PROJECT_NUMBER_CONCIERGE}[e-mail]" \
  "serviceAccount:service-${PROJECT_NUMBER_CONCIERGE}@gcp-sa-aiplatform.iam.gserviceaccount.com"; do
    gcloud projects remove-iam-policy-binding ${PROJECT_GOVERNANCE} \
      --member="${MEMBER}" \
      --role="roles/viewer" --quiet || true
done

# 4. remove spoke-to-spoke delegation in Sellers project
for MEMBER in \
  "serviceAccount:service-${PROJECT_NUMBER_CONCIERGE}@gcp-sa-aiplatform.iam.gserviceaccount.com" \
  "serviceAccount:service-${PROJECT_NUMBER_CONCIERGE}@gcp-sa-aiplatform-re.iam.gserviceaccount.com" \
  "serviceAccount:${PROJECT_NUMBER_CONCIERGE}[e-mail]" \
  "principalSet://agents.global.org-${ORG_ID}.system.id.goog/attribute.platformContainer/aiplatform/projects/${PROJECT_NUMBER_CONCIERGE}"; do
    gcloud projects remove-iam-policy-binding ${PROJECT_SELLERS} \
      --member="${MEMBER}" \
      --role="roles/aiplatform.user" --quiet || true
done

# 5. delete custom IAM role after all bindings have been unlinked
gcloud iam roles delete ar_agw_cross_project_sa \
  --project=${PROJECT_GOVERNANCE} --quiet || true

अगर आपने सेटअप के दौरान roles/iam.accessPolicyAdmin और roles/resourcemanager.projectIamAdmin असाइन किया है, तो कम से कम ऐक्सेस देने की सुविधा को वापस लाने के लिए, उन्हें अपने सक्रिय उपयोगकर्ता खाते से हटाएं:

# 6. remove Access Policy Admin and Project IAM Admin roles from user
for ROLE in "roles/iam.accessPolicyAdmin" "roles/resourcemanager.projectIamAdmin"; do
  gcloud projects remove-iam-policy-binding ${PROJECT_GOVERNANCE} \
    --member="user:$(gcloud config get-value account)" \
    --role="${ROLE}" \
    --condition=None --quiet || true
done

6. ऑडिट डेटा लॉगिंग और संगठन की नीति से जुड़ी पाबंदियों को पहले जैसा करना

# 1. Export current Central Governance IAM policy
gcloud projects get-iam-policy ${PROJECT_GOVERNANCE} --format=json > cfg/gov_iam_policy.json

# 2. Filter out iap.googleapis.com from auditConfigs
python3 -c "
import json
with open('cfg/gov_iam_policy.json') as f:
    policy = json.load(f)

if 'auditConfigs' in policy:
    # Remove iap.googleapis.com; if nothing else remains, clear the list
    policy['auditConfigs'] = [
        ac for ac in policy['auditConfigs'] if ac.get('service') != 'iap.googleapis.com'
    ]

with open('cfg/gov_iam_policy.json', 'w') as f:
    json.dump(policy, f, indent=2)
"

# 3. Apply the updated policy to revert audit logging to default
gcloud projects set-iam-policy ${PROJECT_GOVERNANCE} cfg/gov_iam_policy.json

7. संगठन की नीति से जुड़ी पाबंदियों को पहले जैसा करना

# revert iam v3 access policy binding org policy on project to org level setting
gcloud org-policies delete iam.managed.disableAccessPolicyBinding --project=${PROJECT_GOVERNANCE}

8. शेयर की गई GCS स्टेजिंग बकेट और लोकल आर्टफ़ैक्ट मिटाना

# delete central staging bucket
gcloud storage rm -r gs://${PROJECT_GOVERNANCE}-shared-staging

# remove local configuration manifests, environment files, and application
rm -rf cfg/ cross-project-multiagent/ *.env

इसके साथ ही, क्लीनअप का हिस्सा खत्म होता है... अब निष्कर्ष पर चलते हैं!

12. नतीजा

बधाई हो! आपने Vertex AI Agent Runtime, Central Agent Gateway, Agent Registry, और IAM Unified Access Policies (UAP) का इस्तेमाल करके, Google Cloud पर मल्टी-प्रोजेक्ट एजेंट-टू-एजेंट (A2A) आर्किटेक्चर को डिप्लॉय और मैनेज किया है.

मुख्य कॉन्सेप्ट की खास जानकारी

• सेंट्रलाइज़्ड इग्रेस पेरीमीटर: agentGatewayConfig का इस्तेमाल करके, PROJECT_GOVERNANCE में मौजूद सेंट्रल एजेंट गेटवे के ज़रिए, रूट किए गए स्पोक रनटाइम कंटेनर (PROJECT_CONCIERGE, PROJECT_SELLERS).
• डिक्लेरेटिव गवर्नेंस (UAP): हर संसाधन के लिए अलग-अलग बाइंडिंग को, ऑडिट की जा सकने वाली एक IAM ऐक्सेस नीति से बदल दिया गया है. इसका आकलन, IAP v2 के गेटवे पर किया जाता है.
• क्रिप्टोग्राफ़िक आइडेंटिटी: लंबे समय तक इस्तेमाल की जाने वाली कुंजियों के बजाय, कंटेनर SPIFFE आइडेंटिटी (principal://...) का इस्तेमाल करके, कम से कम खास अधिकार वाले इग्रेस डेटा ट्रैफ़िक को लागू किया गया.
• डाइनैमिक सर्विस डिस्कवरी: सेंट्रल एजेंट रजिस्ट्री के ज़रिए रनटाइम के दौरान, पीयर एजेंट एंडपॉइंट को रिज़ॉल्व किया गया. इससे हार्डकोड किए गए यूआरएल और प्रोजेक्ट आईडी की ज़रूरत नहीं पड़ी.
• रनटाइम के दौरान नीति में बदलाव करने की सुविधा: नीति में अपडेट करके, pizza-seller-agent को रीयल टाइम में डिफ़ॉल्ट रूप से अस्वीकार (403 Forbidden) से अनुमति है (200 OK) पर सेट किया गया. इसके लिए, कंटेनर को रीस्टार्ट करने की ज़रूरत नहीं पड़ी.

कॉस्मोपप का कहना है: "एजेंट बहुत बढ़िया हैं—वे सभी क्रॉस-प्रोजेक्ट काम करते हैं, जबकि मैं अपने मुख्य मकसद पर ध्यान देता हूं: झपकी लेना!"

अगले चरण और दस्तावेज़

• Gemini Enterprise Agent Platform के बारे में खास जानकारी
• एजेंट गेटवे को कॉन्फ़िगर और डिप्लॉय करना
• एजेंट की पहचान और SPIFFE अटेस्टेशन के बारे में ज़्यादा जानकारी
• IAM यूनिफ़ाइड ऐक्सेस नीतियां और सीईएल एट्रिब्यूट
• Agent Registry Service Catalog के बारे में खास जानकारी
• Model Armor Guardrails और संवेदनशील डेटा की सुरक्षा
• एजेंट गेटवे के साथ Private Service Connect इंटरफ़ेस (पीएससी-आई)