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

1. परिचय

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

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

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

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

  1. एजेंट गेटवे (networkservices.googleapis.com): यह मैनेज किया जाने वाला, क्षेत्रीय नेटवर्क और नीति लागू करने वाली प्रॉक्सी है. AGENT_TO_ANYWHERE इग्रेस मोड में काम करने वाला यह कॉम्पोनेंट, एजेंट से बाहर जाने वाले ट्रैफ़िक को रोकता है. साथ ही, अनुमति की जांच के लिए सुरक्षा एक्सटेंशन को ज़िम्मेदारी सौंपता है और प्रोजेक्ट की सीमाओं के हिसाब से अनुरोधों को रूट करता है.
  2. एजेंट रजिस्ट्री (agentregistry.googleapis.com): यह एंटरप्राइज़ की एक ही सेवा कैटलॉग होती है. यह संगठन में उपलब्ध सभी टूल, एमसीपी सर्वर, और पीयर एजेंट की एक ही जगह पर मौजूद, जांच की गई डायरेक्ट्री उपलब्ध कराता है. इससे, हार्डकोड किए गए एंडपॉइंट के बिना, डाइनैमिक रनटाइम ऑटोडिस्कवरी की सुविधा मिलती है.
  3. Agent Identity & IAP v2 Governance (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 के पास है. इसमें सेंट्रल एजेंट गेटवे, सेंट्रल एजेंट रजिस्ट्री, और IAM की यूनीफ़ाइड ऐक्सेस नीतियां होस्ट की जाती हैं.
  • उपयोगकर्ता ऑर्केस्ट्रेटर प्रोजेक्ट (PROJECT_CONCIERGE): इसका मालिकाना हक, खरीदारी करने वाली टीम के पास होता है. इसमें खरीदारी में मदद करने वाला एजेंट होस्ट किया जाता है. यह एजेंट, वेंडर का डाइनैमिक तरीके से पता लगाता है और ग्राहक के ऑर्डर को रूट करता है.
  • डोमेन वेंडर प्रोजेक्ट (PROJECT_SELLERS): इसका मालिकाना हक बाहरी या विभागीय वेंडर के पास होता है. इसमें बर्गर सेलर एजेंट और पिज़्ज़ा सेलर एजेंट को होस्ट किया जाता है.

figure1

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

एक से ज़्यादा प्रोजेक्ट के लिए, एक ही जगह से सभी सेटिंग मैनेज करने की सुविधा क्यों ज़रूरी है?

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

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

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

figure2

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

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

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

  • टियर 1: Google Cloud के बुनियादी एपीआई (पहले नियम में principalSet:// के ज़रिए, मोटे तौर पर): प्रोजेक्ट के हिसाब से, इग्रेस डेटा ट्रैफ़िक की अनुमति. इससे स्पोक प्रोजेक्ट में मौजूद सभी एजेंट रनटाइम, स्टैंडर्ड Google APIs (aiplatform, iamcredentials, telemetry, agentregistry) को ऐक्सेस कर सकते हैं. ऐसा खोज, टोकन जनरेट करने, और अनुमान लगाने के लिए किया जा सकता है.
  • टियर 2: कारोबार के टूल और A2A सेवाएं (नियम 2 और 3 में principal:// के ज़रिए ज़्यादा बारीकी से कंट्रोल किया जाता है): इसमें, कम से कम विशेषाधिकारों के साथ ऐक्सेस दिया जाता है. यह ऐक्सेस, Reasoning Engine के अलग-अलग इंस्टेंस से जुड़ा होता है. इसे कॉमन एक्सप्रेशन लैंग्वेज (सीईएल) की शर्तों के साथ लागू किया जाता है. ये शर्तें, रजिस्टर की गई Agent Registry की खास सेवाओं (destination.agent_registry.agent.name) को टारगेट करती हैं.

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

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

figure3

तीसरी इमेज. लागू करने का क्रम

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

  • सेंट्रलाइज़्ड गेटवे के लिए, क्रॉस-प्रोजेक्ट सेवा एजेंट की IAM अनुमतियां कैसे कॉन्फ़िगर करें
  • मल्टी-प्रोजेक्ट एनवायरमेंट में, एजेंट रनटाइम के इग्रेस को सेंट्रल एजेंट गेटवे के ज़रिए कैसे रूट करें
  • 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 प्रोजेक्ट की कमांड-लाइन ऐक्सेस करें:

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

# 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

# update gcloud components
gcloud components update --quiet

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

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

# 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

यूनिफ़ाइड ऐक्सेस की नीतियों के लिए, ऐक्सेस की नीति के एडमिन की भूमिका असाइन करना

# 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 Data Access 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 के मुख्य एपीआई रजिस्टर करें सेक्शन पर जाएं.

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

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

Agent Gateway को Google API के यूआरएल, Central Agent Registry में रजिस्टर करने होते हैं. इससे 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://iamcredentials.googleapis.com \
  --interfaces=protocolBinding=JSONRPC,url=https://iamcredentials.mtls.googleapis.com \
  --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

कोर एपीआई के एंडपॉइंट रिसॉर्स आईडी को कैप्चर करना

# 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 Platform में, एजेंट कंटेनर को जारी की गई मशीन आइडेंटिटी, क्रिप्टोग्राफ़िक तौर पर पुष्टि किए गए SPIFFE यूआरएन का इस्तेमाल करती हैं. इनका आकलन Identity-Aware Proxy (IAP v2) करता है. आईएम यूनीफ़ाइड ऐक्सेस नीतियां कॉन्फ़िगर करते समय, किसी खास principal या एट्रिब्यूट पर आधारित principalSet को टारगेट किया जा सकता है:

डाइमेंशन

principal:// (सिंगल मशीन आइडेंटिटी)

principalSet:// (एट्रिब्यूट के आधार पर ग्रुप किया गया)

IAM सिंटैक्स

principal://...

principalSet://...

डेटा की बारीकी

ज़्यादा जानकारी वाला (इंस्टेंस-लेवल): इससे, Reasoning Engine के किसी कंटेनर इंस्टेंस की पहचान की जाती है.

कोर्स-ग्रेन्ड (प्रोजेक्ट-लेवल): यह एक ही प्रोजेक्ट एट्रिब्यूट को शेयर करने वाले सभी रीज़निंग इंजन की पहचान करता है.

यूआरएन पैटर्न

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}

एजेंट प्लैटफ़ॉर्म में इस्तेमाल का उदाहरण

टियर 2 (कारोबार से जुड़े टूल और A2A): टारगेट डोमेन टूल (जैसे, खरीदारी में मदद करने वाला एजेंट $\rightarrow$ बर्गर सेलर) को शुरू करने के लिए, कुछ ऑर्केस्ट्रेटर एजेंट को अनुमति देना.

टियर 1 (बुनियादी इंफ़्रास्ट्रक्चर): किसी प्रोजेक्ट में मौजूद सभी एजेंट को Google Cloud API (core-gapi-services) का इग्रेस ऐक्सेस देना.

लाइफ़साइकल पर असर

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

यह उस प्रोजेक्ट में डिप्लॉय किए गए नए एजेंट पर अपने-आप लागू हो जाता है. इसके लिए, IAM को अपडेट करने की ज़रूरत नहीं होती.

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

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

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

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

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

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. अनुमति देना

एजेंट गेटवे के लिए अनुमति देने की सुविधा और यूएपी की बुनियादी सेटिंग कॉन्फ़िगर करना

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

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

figure4

चौथी इमेज. अनुमति देने की प्रोसेस के बारे में खास जानकारी

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

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

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

सख्त ENFORCE मोड में iapPolicyVersion: "V2" और failOpen: false का इस्तेमाल करके, Service Extension मेनिफ़ेस्ट बनाएं:

# 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}

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

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

# 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 ऐक्सेस नीति बनाना और उसे बाइंड करना

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

# 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 के साथ कॉन्फ़िगर किए गए एजेंट कंटेनर को डिप्लॉय करते समय, स्पोक प्रोजेक्ट के एजेंट रनटाइम सेवा एजेंट (service-@gcp-sa-aiplatform.iam.gserviceaccount.com) को कंटेनर को सेंट्रल गेटवे से अटैच करना होगा. हम 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 में कस्टम IAM भूमिका बनाना

# 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}-compute@developer.gserviceaccount.com"

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}-compute@developer.gserviceaccount.com"

# 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

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

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

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

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

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

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

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

# remove temporary directory
rm -rf temp_agw_cuj_arun_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)

नियम 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}'

आउटपुट में, कंसीयर्ज एजेंट के रनटाइम की पहचान और प्रोजेक्ट दिखना चाहिए. साथ ही, गवर्नेंस प्रोजेक्ट के एजेंट गेटवे से बाइंडिंग की जानकारी भी दिखनी चाहिए.

{
  "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 में, तीनों एजेंट को सेंट्रल एजेंट रजिस्ट्री में रजिस्टर करें. इसके लिए, क्रॉस-प्रोजेक्ट रीजनल एमटीएलएस एंडपॉइंट और अंकों वाले प्रोजेक्ट नंबर का इस्तेमाल करें.

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

# 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.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

# 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.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

# 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.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

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

# 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}"

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

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

यूनीफ़ाइड ऐक्सेस नीति में A2A Egress Policies कॉन्फ़िगर करना

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

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

कॉन्सीयर्ज़ एजेंट की पहचान तय करना

# 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 (कोर एपीआई) और अब नियम 2 (बर्गर सेलर एजेंट) को शामिल करने के लिए, नया cfg/uap-rules-update-2.json बनाएं:

# create addendum to update policy manifest with Rule 2 for Burger Agent
cat > cfg/uap-rules-update-2.json << EOF
[
  {
    "description": "Rule 2: Allow Purchasing Concierge to invoke Burger 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/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

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

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

आईएएम ऐक्सेस नीति की जानकारी की पुष्टि करना

# 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

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

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

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

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

पहला चरण: PROJECT_CONCIERGE में Agent Runtime AI Playground खोलें

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

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

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 ने burger-seller-agent के लिए रीजनल mTLS एंडपॉइंट का पता लगाने के लिए, PROJECT_GOVERNANCE में Central Agent Registry से क्वेरी की. यह क्वेरी, core-gapi-services के ज़रिए की गई. को Agent Gateway के ज़रिए, नियम 1 के तहत अनुमति मिली हुई है.
  2. इंटेंट रिज़ॉल्यूशन और A2A इनवोकेशन: Purchasing Concierge में मौजूद Gemini, खाने के ऑर्डर के इंटेंट को पार्स करता है. इसके बाद, आउटबाउंड आरपीसी के ज़रिए Burger Seller Agent को https://${REGION}-aiplatform.mtls.googleapis.com/.../reasoningEngines/${BURGER_ENGINE_ID} के लिए इनवोक करता है.
  3. गेटवे इंटरसेप्शन और SPIFFE का प्रसार: agent_gateway_config, इग्रेस डेटा ट्रैफ़िक को कैप्चर करता है और उसे PROJECT_GOVERNANCE में मौजूद सेंट्रल एजेंट गेटवे पर भेजता है. इसमें कॉन्सियर्ज की क्रिप्टोग्राफ़िक SPIFFE पहचान (principal://...) शामिल होती है.
  4. IAP v2 की नीति का आकलन: सेंट्रल एजेंट गेटवे, IAP ऑथराइज़ेशन एक्सटेंशन (authzExtension) को शुरू करता है. IAP v2, IAM की यूनिफ़ाइड ऐक्सेस नीति में मौजूद दूसरे नियम का आकलन करता है. कॉलर ${CONCIERGE_SPIFFE_PRINCIPAL} से मेल खाता है और टारगेट burger-seller-agent से मेल खाता है. इसलिए, IAP 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

तीसरा चरण: एजेंट गेटवे और IAP v2 के ऑडिट लॉग की जांच करें (HTTP 200 / ALLOWED)

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

# 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), और IAM क्रेडेंशियल लुकअप के लिए इग्रेस फ़ील्ड होने चाहिए. इन सभी को पारदर्शी तरीके से इंटरसेप्ट किया जाता है और नियम 1 (core-gapi-services) से अनुमति मिलती है.

नीति के वर्शन POLICY_VERSION_V2 की पुष्टि करने के लिए, IAP v2 के Cloud Audit Data Access लॉग क्वेरी करें:

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

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

# 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

सातवां चरण: पिज़्ज़ा एजेंट से फिर से क्वेरी करना (तुरंत 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. डाइनैमिक नीति रीफ़्रेश: IAM की यूनिफ़ाइड ऐक्सेस नीति को अपडेट करने पर, यह IAP के आकलन इंजन में तुरंत लागू हो जाती है. इससे कोई डाउनटाइम नहीं होता और किसी भी कंटेनर को फिर से डिप्लॉय करने की ज़रूरत नहीं पड़ती.
  2. A2A इनवोकेशन: सहायता उपलब्ध कराने वाला एजेंट, अनुरोध को सेंट्रल एजेंट गेटवे के ज़रिए भेजता है.
  3. IAP v2 की नीति का आकलन (अनुमति): IAP v2, तीसरे नियम से मेल खाता है. यह कॉलर की पहचान और टारगेट CEL एक्सप्रेशन की पुष्टि करता है. इसके बाद, 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://us-central1-aiplatform.mtls.googleapis.com/v1beta1/projects/${PROJECT_SELLERS}/locations/us-central1/publishers/google/models/gemini-2.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

टेस्टिंग और पुष्टि की प्रक्रिया पूरी हो गई है... अब साफ़ करें सेक्शन पर जाएं.

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 की यूनिफ़ाइड ऐक्सेस नीति की बाइंडिंग और ऐक्सेस नीति मिटाना

# 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

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

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

# 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}-compute@developer.gserviceaccount.com" \
    "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}-compute@developer.gserviceaccount.com" \
  "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}-compute@developer.gserviceaccount.com" \
  "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 की यूनिफ़ाइड ऐक्सेस नीतियां (यूएपी) का इस्तेमाल करके, Google Cloud पर मल्टी-प्रोजेक्ट एजेंट-टू-एजेंट (A2A) आर्किटेक्चर डिप्लॉय और मैनेज किया हो.

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

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

cosmopup

Cosmopup का कहना है: "एजेंट बहुत अच्छे हैं. ये अलग-अलग प्रोजेक्ट पर काम करते हैं, ताकि मैं अपने मुख्य मकसद पर फ़ोकस कर सकूं: झपकी लेना!"

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