Gemini Enterprise के साथ एजेंट गेटवे का पूरा ट्रैफ़िक वीपीसी इग्रेस और बाहरी एमसीपी सर्वर के लिए Cloud NAT स्टैटिक आईपी

1. परिचय

इस कोडलैब में, agent-to-anywhere (egress) मोड में Agent Gateway का इस्तेमाल करके, Gemini Enterprise के लिए स्टैटिक आईपी इग्रेस कनेक्टिविटी के बारे में बताया गया है. आपको Gemini Enterprise ऐप्लिकेशन को कॉन्फ़िगर करना होगा, ताकि वह कस्टम मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) सर्वर को चालू कर सके. यह सर्वर, सोर्स आईपी की सख्त तौर पर अनुमति वाली सूची और OAuth 2.0 पुष्टि करने की सुविधा से सुरक्षित होता है. इसके लिए, कनेक्टिविटी टेंप्लेट कॉन्फ़िगरेशन का इस्तेमाल करके, सभी आउटबाउंड ट्रैफ़िक को एजेंट गेटवे के ज़रिए रूट करना होगा. Private Service Connect (PSC) नेटवर्क अटैचमेंट, एजेंट गेटवे को वीपीसी नेटवर्क से कनेक्ट करता है. साथ ही, Cloud NAT, इंटरनेट इग्रेस ट्रैफ़िक के लिए एक स्टेबल बाहरी आईपी पता उपलब्ध कराता है.

डिफ़ॉल्ट रूप से, Gemini Enterprise से सार्वजनिक इंटरनेट एंडपॉइंट के लिए आउटबाउंड कनेक्शन, डाइनैमिक और शेयर किए गए Google के आईपी पते के पूल से शुरू होते हैं. इन्हें, ग्राहक के मालिकाना हक वाले आईपी पते की अनुमति वाली सूची के किसी एक नियम से नहीं जोड़ा जा सकता. ALL_TRAFFIC मोड में AgentConnectivityTemplate के साथ एजेंट गेटवे को पेयर करने से, एजेंट का सारा आउटबाउंड ट्रैफ़िक VPC नेटवर्क में रूट हो जाता है. यहां Cloud NAT, इंटरनेट से जुड़े कनेक्शन को आपके कंट्रोल में मौजूद रिज़र्व किए गए स्टैटिक बाहरी IPv4 पते में बदल देता है. साथ ही, एजेंट रजिस्ट्री और Identity-Aware Proxy (IAP) के ज़रिए, एमसीपी टूल के केंद्रीकृत गवर्नेंस को बनाए रखता है.

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

  • एजेंट कनेक्टिविटी टेंप्लेट (vpcEgress: ALL_TRAFFIC) और एजेंट गेटवे, एजेंट रजिस्ट्री एंडपॉइंट की पुष्टि के साथ, इग्रेस (agent-to-anywhere) मोड में काम कर रहा हो
  • वीपीसी नेटवर्क, पीएससी नेटवर्क अटैचमेंट, Cloud Router, और Cloud NAT गेटवे, जो रिज़र्व किए गए स्टैटिक एक्सटर्नल IPv4 पते से जुड़ा हो
  • Caddy TLS के ज़रिए फ़्रंट किए गए, स्ट्रीम किए जा सकने वाले बाहरी एचटीटीपी एमसीपी रिसॉर्स सर्वर (mcp-sprockets). इस पर फ़ायरवॉल के नियम लागू होते हैं, जो इसे Cloud NAT के स्टैटिक आईपी तक सीमित रखते हैं. साथ ही, यह उपयोगकर्ता के सौंपे गए Google OAuth 2.0 बियरर टोकन की पुष्टि https://oauth2.googleapis.com/tokeninfo के ख़िलाफ़ करता है
  • Google Auth Platform की OAuth 2.0 सहमति स्क्रीन और वेब ऐप्लिकेशन के OAuth 2.0 क्लाइंट क्रेडेंशियल (accounts.google.com और oauth2.googleapis.com/token)
  • एजेंट रजिस्ट्री एमसीपी सर्वर कैटलॉग एंट्री और टूल स्पेसिफ़िकेशन (toolspec.json)
  • Identity-Aware Proxy (IAP) की अनुमति देने वाला एक्सटेंशन और एजेंट गेटवे के लिए, अनुमति देने से जुड़ी गेटवे नीति
  • Gemini Enterprise ऐप्लिकेशन, एजेंट गेटवे से जुड़ा होता है. साथ ही, यह एजेंट रजिस्ट्री से इंपोर्ट किए गए OAuth 2.0 कस्टम एमसीपी सर्वर डेटा स्टोर से कनेक्ट होता है

figure1

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

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

  • AgentConnectivityTemplate के साथ vpcEgress: ALL_TRAFFIC को कॉन्फ़िगर करके, एजेंट गेटवे से बाहर जाने वाले सभी ट्रैफ़िक को वीपीसी नेटवर्क में कैसे भेजा जाता है
  • किसी पीएससी नेटवर्क अटैचमेंट सबनेट पर, स्टैटिक एक्सटर्नल IPv4 पते को रिज़र्व करने और उसे Cloud NAT से बाइंड करने का तरीका
  • स्ट्रीम किए जा सकने वाले बाहरी एचटीटीपी एमसीपी रिसॉर्स सर्वर को कैसे डिप्लॉय करें. यह सर्वर, Google OAuth 2.0 के बियरर टोकन (oauth2.googleapis.com/tokeninfo) की पुष्टि करता है और इसके इनग्रेस फ़ायरवॉल को Cloud NAT के स्टैटिक आईपी (${NAT_EXT_IP}/32) तक सीमित करता है
  • Google Identity OAuth 2.0 क्लाइंट क्रेडेंशियल को कॉन्फ़िगर करने का तरीका. साथ ही, एजेंट रजिस्ट्री में एमसीपी सर्वर और उसके टूल स्कीमा को रजिस्टर करने का तरीका
  • रजिस्टर्ड OAuth 2.0 एमसीपी सर्वर को Gemini Enterprise से कनेक्ट करने और उपयोगकर्ता की ओर से सौंपे गए टूल कॉल को एजेंट गेटवे के ज़रिए रूट करने का तरीका
  • सीएलआई कमांड और Cloud Logging का इस्तेमाल करके, स्टैटिक आईपी ट्रांसलेशन, असली उपयोगकर्ता की OAuth 2.0 पहचान की पुष्टि (authenticated_user), और गेटवे की नीति लागू करने की पुष्टि कैसे करें

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

  • बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट
  • Gemini Enterprise का चालू लाइसेंस या 30 दिनों के लिए मुफ़्त में आज़माने की सुविधा
  • नेटवर्किंग सेवाएं, संगठन की नीतियां, Gemini Enterprise, और एजेंट प्लैटफ़ॉर्म के संसाधनों को उपलब्ध कराने के लिए IAM अनुमतियां
  • Google Cloud सीएलआई (gcloud), curl, और jq के साथ POSIX के साथ काम करने वाला शेल (bash या zsh) इंस्टॉल होना चाहिए

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

2. कॉन्सेप्ट

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

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

  1. नेटवर्क इन्फ़्रास्ट्रक्चर: स्टैटिक बाहरी IPv4 पते रिज़र्व करें. साथ ही, इग्रेस वीपीसी, पीएससी अटैचमेंट सबनेट, पीएससी नेटवर्क अटैचमेंट, Cloud Router, Cloud NAT गेटवे, और बाहरी एमसीपी नेटवर्क फ़ायरवॉल के नियम उपलब्ध कराएं.
  2. एजेंट कनेक्टिविटी टेंप्लेट और एजेंट गेटवे: एजेंट रजिस्ट्री इंटिग्रेशन (registries) के साथ, इग्रेस मोड (AGENT_TO_ANYWHERE) में AgentConnectivityTemplate (vpcEgress: ALL_TRAFFIC) और रीजनल AgentGateway को डिप्लॉय करें.
  3. अनुमति देने से जुड़ी नीतियां: IAP की अनुमति देने वाले एक्सटेंशन (AuthzExtension), गेटवे की अनुमति देने से जुड़ी नीति (AuthzPolicy), और IAM v3 की यूनिफ़ाइड ऐक्सेस नीति (AccessPolicy और PolicyBinding) को कॉन्फ़िगर करें.
  4. एमसीपी सर्वर को डिप्लॉय और रजिस्टर करें: बाहरी mcp-sprockets OAuth 2.0 रिसॉर्स सर्वर को Caddy TLS के पीछे डिप्लॉय करें. इसके Google OAuth 2.0 tokeninfo एनफ़ोर्समेंट की पुष्टि करें. इसके इनग्रेस फ़ायरवॉल को Cloud NAT स्टैटिक आईपी (${NAT_EXT_IP}/32) के लिए लॉक डाउन करें. साथ ही, एजेंट रजिस्ट्री में सेवा और टूल की खास बातों (get_sprockets और get_sprocket_by_id) को रजिस्टर करें.
  5. Gemini Enterprise ऐप्लिकेशन और OAuth 2.0 क्लाइंट: Google Identity provider, बिना शुल्क आज़माने का लाइसेंस, और OAuth 2.0 की सहमति स्क्रीन और वेब ऐप्लिकेशन क्लाइंट क्रेडेंशियल (OAUTH_CLIENT_ID और OAUTH_CLIENT_SECRET) कॉन्फ़िगर करें. Gemini Enterprise ऐप्लिकेशन (Engine) बनाएं और आउटबाउंड इग्रेस को Agent Gateway (agentGatewaySetting) से बाइंड करें.
  6. कस्टम एमसीपी डेटा कनेक्टर इंपोर्ट करें: auth_type: "OAUTH" के साथ कॉन्फ़िगर किया गया REGISTRY_MCP डेटा कनेक्टर (:setUpDataConnector) बनाएँ और उसे चालू करें. इससे, रजिस्टर किए गए एमसीपी सर्वर के डेटा स्टोर को Gemini Enterprise ऐप्लिकेशन से लिंक किया जा सकेगा.
  7. पुष्टि करें: उपयोगकर्ता की सहमति के लिए, OAuth 2.0 फ़्लो को एक बार पूरा करें. Gemini Enterprise assistant के ज़रिए एमसीपी टूल चालू करें (egress_source_ip और authenticated_user, दोनों की पुष्टि करें). साथ ही, Cloud Logging में नीति लागू करने और स्टैटिक आईपी NAT ट्रांसलेशन की पुष्टि करें.

सेंट्रल IdP + OAuth से सुरक्षित एमसीपी रिसॉर्स सर्वर आर्किटेक्चर

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

OAuth 2.0 की भूमिका

इस कोडलैब में मौजूद कॉम्पोनेंट

ज़िम्मेदारी

संसाधन का मालिक

असली उपयोगकर्ता (${USER_IDENTITY})

यह कुकी, Gemini Enterprise के वेब ऐप्लिकेशन में साइन इन करती है. साथ ही, एक बार इस्तेमाल होने वाले 3-लेग वाले OAuth 2.0 ऑथराइज़ेशन फ़्लो के दौरान सहमति देती है.

OAuth 2.0 क्लाइंट

Gemini Enterprise custom_mcp डेटा कनेक्टर

यह कुकी OAUTH_CLIENT_ID और OAUTH_CLIENT_SECRET को सेव करती है. साथ ही, oauth2.googleapis.com/token पर ऑथराइज़ेशन कोड को एक्सचेंज करती है. यह उपयोगकर्ता के OAuth 2.0 टोकन को सुरक्षित रखती है. साथ ही, एमसीपी टूल से किए जाने वाले हर आउटबाउंड कॉल पर Authorization: Bearer [access_token] दिखाता है.

अनुमति देने वाला सर्वर

Google Identity OAuth 2.0 (accounts.google.com और oauth2.googleapis.com/token)

यह कुकी, ब्राउज़र पर सहमति देने के लिए रीडायरेक्ट करने के दौरान उपयोगकर्ता की पुष्टि करती है. साथ ही, Gemini Enterprise को OAuth 2.0 ऐक्सेस और रीफ़्रेश टोकन जारी करती है.

संसाधन सर्वर

एक्सटर्नल mcp-sprockets सर्वर (https://mcp.[MCP_EXT_IP].sslip.io/mcp)

यह अपने वीपीसी फ़ायरवॉल (${NAT_EXT_IP}/32) का इस्तेमाल करके, लेयर 3 नेटवर्क आइडेंटिटी लागू करता है. साथ ही, https://oauth2.googleapis.com/tokeninfo के ख़िलाफ़ Authorization: Bearer [access_token] हेडर की पुष्टि करके, लेयर 7 उपयोगकर्ता की पहचान लागू करता है.

ब्राउज़र से सहमति लेने के लिए रीडायरेक्ट (accounts.google.com) और बैक-चैनल टोकन एक्सचेंज (oauth2.googleapis.com/token) की प्रोसेस, Google के मैनेज किए गए OAuth 2.0 एंडपॉइंट के ख़िलाफ़ होती है. इसलिए, बाहरी एमसीपी सर्वर फ़ायरवॉल को सिर्फ़ रनटाइम एमसीपी JSON-RPC अनुरोध (POST /mcp) मिलते हैं. ये अनुरोध, क्लाउड NAT के ज़रिए एजेंट गेटवे से मिलते हैं. इससे, इसके इनग्रेस फ़ायरवॉल को सिर्फ़ ${NAT_EXT_IP}/32 के लिए लॉक किया जा सकता है.

Discovery Engine रिसॉर्स मॉडल

Gemini Enterprise ऐप्लिकेशन (Discovery Engine API में इसे Engine संसाधन के तौर पर दिखाया गया है) एक सेंट्रल ऑर्केस्ट्रेशन लेयर है. साथ ही, यह असली उपयोगकर्ताओं के लिए बातचीत वाला इंटरफ़ेस है. यह उपयोगकर्ता के चैट सेशन मैनेज करता है. साथ ही, एंटरप्राइज़ डेटा के आधार पर जनरेटिव मॉडल तैयार करता है और डाइनैमिक टूल को लागू करने में मदद करता है.

Gemini Enterprise के ऐप्लिकेशन, डेटा स्टोर के ज़रिए डेटा और सिस्टम के साथ इंटरैक्ट करते हैं:

  • नॉलेज डेटा स्टोर: इसमें स्टैटिक कॉन्टेंट (जैसे, Cloud Storage, Google Drive, BigQuery) को इंडेक्स किया जाता है, ताकि उसे रीट्रिवल-ऑगमेंटेड जनरेशन (आरएजी) के लिए इस्तेमाल किया जा सके.
  • डेटा कनेक्टर (कार्रवाई करने वाली कंपनियां): डाइनैमिक तीसरे पक्ष या कस्टम एपीआई से कनेक्ट करें. कस्टम एमसीपी सर्वर डेटा स्टोर, मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) के ज़रिए तय किए गए टूल दिखाता है. इससे मॉडल को बातचीत के दौरान, बाहरी फ़ंक्शन को डाइनैमिक तरीके से कॉल करने की सुविधा मिलती है.

Gemini Enterprise से डेटा बाहर भेजने की सुविधा

Gemini Enterprise, कस्टम एमसीपी सर्वर टूल के अनुरोधों को एजेंट गेटवे पर तब भेजता है, जब Engine पर agentGatewaySetting और DataConnector पर use_agent_gateway_egress: true, दोनों कॉन्फ़िगर किए गए हों.

figure2

दूसरी इमेज. Gemini Enterprise के डेटा को बाहर भेजने का आर्किटेक्चर

Gemini Enterprise ऐप्लिकेशन, टूल को चार मुख्य कैटगरी में व्यवस्थित करता है:

  1. विजेट (default_search_widget_config):
    • यह वेब क्लाइंट इंटरफ़ेस को दिखाता है. विजेट, उपयोगकर्ता से प्रॉम्प्ट पाता है. साथ ही, जब किसी टूल को अनुमति की ज़रूरत होती है, तब उपयोगकर्ता की सहमति के लिए OAuth 2.0 को एक बार रीडायरेक्ट करता है. इसके अलावा, यह इंजन के साथ चैट सेशन शुरू करता है.
  2. Core Assistant (assistants/default_assistant/agents/default/core_assistant):
    • यह इंजन में बातचीत के आधार पर तर्क देने वाला मुख्य एजेंट होता है. उपयोगकर्ता की क्वेरी का आकलन करते समय, Core Assistant उपलब्ध टूल की जांच करता है. साथ ही, कार्रवाई करने का काम, सिंथेसाइज़ किए गए Agent Gateway के सब-एजेंट को सौंपता है.
  3. डेटा स्टोर और डेटा कनेक्टर:
    • DataStore: :setUpDataConnector के चलने पर, इसे एक खास Collection में उपलब्ध कराया जाता है. यह इंपोर्ट किए गए एजेंट रजिस्ट्री टूल के स्कीमा (get_sprockets, get_sprocket_by_id), आर्ग्युमेंट टाइप, और एजेंट के निर्देशों को Gemini Enterprise Engine से लिंक करता है (dataStoreIds).
    • DataConnector: यह रिमोट एमसीपी सर्वर (instance_uri) से REGISTRY_MCP ऐक्शन कनेक्शन (createBapConnection: true) को मैनेज करता है. साथ ही, एजेंट रजिस्ट्री एमसीपी सर्वर रिसॉर्स (registry_mcp_server_name) को हल करता है, उपयोगकर्ता के वॉल्ट किए गए OAuth 2.0 बियरर टोकन (Authorization: Bearer [access_token]) को अटैच करता है, और एजेंट गेटवे इग्रेस (use_agent_gateway_egress: true) को चालू करता है.
  4. एजेंट की पहचान, एजेंट रजिस्ट्री, और एजेंट गेटवे:
    • जब डेटा कनेक्टर, आउटबाउंड टूल कॉल भेजता है, तो वह ट्रैफ़िक को agentGatewaySetting में बताए गए गेटवे पर भेजता है. Core Assistant, SPIFFE आइडेंटिटी टोकन बनाता है. यह टोकन, इसकी वर्कलोड आइडेंटिटी की पुष्टि करता है: principal://agents.global.org-.../agents/default/core_assistant.
    • Agent Gateway, registries फ़ील्ड का इस्तेमाल करके Agent Registry के साथ इंटिग्रेट होता है. इससे डेस्टिनेशन एंडपॉइंट और रजिस्टर किए गए टूल स्कीमा को डाइनैमिक तरीके से हल किया जाता है. साथ ही, IAP का इस्तेमाल करके अनुमति देने से जुड़ी नीतियों का आकलन किया जाता है. इसके अलावा, अनुमति वाले अनुरोधों को वीपीसी नेटवर्क में फ़ॉरवर्ड किया जाता है. ऐसा करते समय, उपयोगकर्ता के Authorization: Bearer हेडर को सुरक्षित रखा जाता है. इसके लिए, AgentConnectivityTemplate का इस्तेमाल किया जाता है.

गेटवे वीपीसी कनेक्टिविटी और स्टैटिक आईपी NAT

Agent Gateway, agentConnectivityTemplate पर मौजूद AgentConnectivityTemplate रिसॉर्स का इस्तेमाल करके, वीपीसी नेटवर्क कनेक्टिविटी को सपोर्ट करता है. टेंप्लेट egressNetworkConfig से यह तय होता है कि पीएससी नेटवर्क अटैचमेंट के ज़रिए, आपके वीपीसी में ट्रैफ़िक कैसे आता है:

  • PRIVATE_RANGES_ONLY (डिफ़ॉल्ट): यह सिर्फ़ RFC 1918, RFC 6598, और क्लास E के निजी आईपी पतों को पीएससी नेटवर्क अटैचमेंट के ज़रिए रूट करता है. इंटरनेट से जुड़ा ट्रैफ़िक, आपके वीपीसी को बायपास करता है और सीधे Google के डिफ़ॉल्ट इंटरनेट इग्रेस से बाहर निकलता है.
  • ALL_TRAFFIC (इस कोडलैब में इस्तेमाल किया गया है): यह एजेंट गेटवे से निकलने वाले सभी आउटबाउंड ट्रैफ़िक को आपके वीपीसी सबनेट में भेजता है. इसमें सार्वजनिक इंटरनेट और बाहरी पार्टनर के एमसीपी एंडपॉइंट शामिल हैं. यह ट्रैफ़िक, पीएससी नेटवर्क अटैचमेंट (10.10.10.2) के ज़रिए भेजा जाता है.

ALL_TRAFFIC मोड में काम करते समय, पीएससी अटैचमेंट सबनेट के लिए दो कॉन्फ़िगरेशन ज़रूरी होते हैं:

  • निजी Google ऐक्सेस (--enable-private-ip-google-access): इससे यह पक्का किया जाता है कि Google Cloud API (*.googleapis.com) को किए जाने वाले इंटरनल कॉल, Google नेटवर्क में निजी तौर पर रूट होते रहें.
  • Cloud Router और Cloud NAT (MANUAL_ONLY): इंटरनेट से जुड़ा ट्रैफ़िक, पीएससी अटैचमेंट सबनेट में Cloud NAT के ज़रिए डिफ़ॉल्ट रूट (0.0.0.0/0) को फ़ॉलो करता है. Cloud NAT, आपके रिज़र्व किए गए स्टैटिक बाहरी IPv4 पते (${NAT_EXT_IP}) के लिए, सोर्स नेटवर्क एड्रेस ट्रांसलेशन (एसएनएटी) करता है. इसलिए, बाहरी फ़ायरवॉल, इनकमिंग ऐक्सेस को सिर्फ़ ${NAT_EXT_IP}/32 तक सीमित कर सकते हैं.

सीमाएं और ज़रूरी शर्तें

  • सिर्फ़ StreamableHTTP के लिए: लेगसी Server-Sent Events (SSE) ट्रांसपोर्ट काम नहीं करता. एमसीपी सर्वर को StreamableHTTP का इस्तेमाल करना होगा.
  • संगठन की नीति को अनदेखा करना: डेटा कनेक्टर को रजिस्टर करने से पहले, आपको कस्टम एमसीपी डेटा स्टोर के लिए संगठन की नीति को अनदेखा करना होगा.
  • क्षेत्र के हिसाब से अलाइनमेंट: Gemini Enterprise, ऐप्लिकेशन की जगह, एजेंट गेटवे, और एजेंट रजिस्ट्री के बीच क्षेत्र के हिसाब से अलाइनमेंट लागू करता है:

Gemini Enterprise ऐप्लिकेशन की जगह की जानकारी

एजेंट गेटवे और NAT की जगह

एजेंट रजिस्ट्री की जगह की जानकारी

global

us-central1

us-central1, us या global

us

us-central1

us-central1 या us

eu

europe-west1

europe-west1 या eu

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

3. सेटअप

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

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

डोमेन

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

प्रोजेक्ट और IAM

roles/orgpolicy.policyAdmin
roles/resourcemanager.projectIamAdmin
roles/iam.accessPolicyAdmin
roles/serviceusage.serviceUsageAdmin
roles/iam.serviceAccountUser

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

roles/networkservices.admin
roles/networksecurity.admin
roles/serviceextensions.admin
roles/iap.admin
roles/compute.networkAdmin
roles/compute.securityAdmin

Gemini Enterprise और रजिस्ट्री

roles/discoveryengine.admin
roles/agentregistry.admin

वर्कलोड

roles/compute.instanceAdmin.v1 (या roles/compute.admin)

जांचने की क्षमता

roles/logging.viewer

इसके अलावा, roles/owner जैसी बुनियादी भूमिका का इस्तेमाल करें. इसे roles/orgpolicy.policyAdmin के साथ जोड़ें, क्योंकि roles/owner अकेले संगठन की नीतियों में बदलाव नहीं कर सकता.

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

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

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

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

# set target project id
gcloud config set project SET_YOUR_PROJECT_ID_HERE

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

# login to gcloud cli
gcloud auth login

# login for gcloud api
gcloud auth application-default login

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

# set custom var for slug (eg, "foo") and region preference
export SLUG="foo"
export REGION="us-central1"
export ZONE="us-central1-a"

echo ${SLUG}
echo ${REGION}
echo ${ZONE}

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

echo ${PROJ_ID}
echo ${PROJ_NO}
echo ${ORG_ID}
echo ${USER_IDENTITY}

# create resource vars for agent platform (automatic)
export AGW_NAME="agw-${SLUG}-${REGION}-ata"
export AGW_URI="projects/${PROJ_ID}/locations/${REGION}/agentGateways/${AGW_NAME}"
export MCP_NAME="mcp-sprockets"

echo ${AGW_NAME}
echo ${AGW_URI}
echo ${MCP_NAME}

# create resource vars for gemini enterprise (automatic)
export GE_LOCATION="global"
export GE_APP_ORG_NAME="${SLUG}, Inc."
export GE_APP_DISPLAY_NAME="${SLUG} ${GE_LOCATION} app"
export GE_APP_NAME="app-${SLUG}-${GE_LOCATION}"
export GE_APP_INIT="${GE_APP_NAME}_$(date +%s)"

echo ${GE_LOCATION}
echo ${GE_APP_ORG_NAME}
echo ${GE_APP_DISPLAY_NAME}
echo ${GE_APP_NAME}
echo ${GE_APP_INIT}

एजेंट की पहचान के लिए भरोसेमंद डोमेन सेट करना

if-then-else स्टेटमेंट से यह पता चलता है कि प्रोजेक्ट किसी संगठन का है या नहीं. इससे प्रिंसिपल एजेंट की पहचान के लिए सही ट्रस्ट डोमेन सेट किया जा सकता है.

# set var for trust domain
if [[ -n "${ORG_ID}" ]]; then
  export TRUST_DOMAIN="agents.global.org-${ORG_ID}.system.id.goog"
else
  export TRUST_DOMAIN="agents.global.proj-${PROJ_NO}.system.id.goog"
fi

echo "trust domain: ${TRUST_DOMAIN}"

बिलिंग और कोटा प्रोजेक्ट सेट करना

# set cli quota project
gcloud config set billing/quota_project ${PROJ_ID}

# set api quota project
gcloud auth application-default set-quota-project ${PROJ_ID}

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

# create config folder
mkdir -p cfg

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

# update gcloud cli
gcloud components update

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

# enable google cloud apis
gcloud services enable \
  agentregistry.googleapis.com \
  aiplatform.googleapis.com \
  cloudapiregistry.googleapis.com \
  cloudresourcemanager.googleapis.com \
  compute.googleapis.com \
  discoveryengine.googleapis.com \
  dns.googleapis.com \
  iam.googleapis.com \
  iap.googleapis.com \
  logging.googleapis.com \
  monitoring.googleapis.com \
  networkconnectivity.googleapis.com \
  networksecurity.googleapis.com \
  networkservices.googleapis.com \
  orgpolicy.googleapis.com \
  serviceextensions.googleapis.com \
  serviceusage.googleapis.com

संगठन की नीतियां

Google Cloud की डिफ़ॉल्ट मैनेज की गई संगठन की नीति से जुड़ी पाबंदियां और सैंडबॉक्स की नीतियां, इस कोडलैब में इस्तेमाल की गई सुविधाओं को सीमित कर सकती हैं:

  • compute.vmExternalIpAccess: यह लॉक-डाउन किए गए सैंडबॉक्स संगठनों में, Compute Engine वीएम पर बाहरी IPv4 पतों को सीमित करता है.
  • discoveryengine.managed.disableCustomMcpServerConnector: यह कस्टम एमसीपी सर्वर (custom_mcp) को डेटा सोर्स के तौर पर इस्तेमाल करने वाले डेटा कनेक्टर बनाने पर पाबंदी लगाता है. यह डिफ़ॉल्ट रूप से लागू होता है.
  • discoveryengine.managed.allowedEgressFqdns: वीपीसी सर्विस कंट्रोल (VPC-SC) चालू होने पर, डेटा कनेक्टर के लिए आउटबाउंड इग्रेस डोमेन (instance_uri FQDN) को सीमित करता है. इसके अलावा, यह तब भी ऐसा करता है, जब प्रोजेक्ट को enforcedProjects में शामिल किया गया हो.
  • discoveryengine.managed.allowedDataSources: वीपीसी-एससी चालू होने पर या प्रोजेक्ट को enforcedProjects में शामिल किए जाने पर, डेटा कनेक्टर के इस्तेमाल की अनुमति वाले टाइप (dataSource) को सीमित करता है.

संगठन की नीति से मिली किसी भी पाबंदी को प्रोजेक्ट लेवल पर बदलें.

कस्टम एमसीपी की पाबंदी बंद करना

# disable data connector constraint (allow custom mcp servers)
gcloud org-policies set-policy "/dev/stdin" <<EOF
name: projects/${PROJ_ID}/policies/discoveryengine.managed.disableCustomMcpServerConnector
spec:
  rules:
  - enforce: false
EOF

डेटा कनेक्टर की शर्तों से जुड़ी पाबंदियां बंद करना

# disable egress fqdn constraint on project
gcloud org-policies set-policy "/dev/stdin" <<EOF
name: projects/${PROJ_ID}/policies/discoveryengine.managed.allowedEgressFqdns
spec:
  rules:
  - enforce: false
EOF

# disable allowed data sources constraint on project
gcloud org-policies set-policy "/dev/stdin" <<EOF
name: projects/${PROJ_ID}/policies/discoveryengine.managed.allowedDataSources
spec:
  rules:
  - enforce: false
EOF

ऐक्सेस की नीति से जुड़ी पाबंदी को बंद करना

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

बाहरी आईपी पतों को अनुमति देना

# allow external ip address for vms on project
gcloud org-policies set-policy "/dev/stdin" <<EOF
name: projects/${PROJ_ID}/policies/compute.vmExternalIpAccess
spec:
  rules:
  - allowAll: true
EOF

संगठन की नीतियों की पुष्टि करना

देखें कि compute.vmExternalIpAccess को allowAll: True पर सेट किया गया हो और अन्य नीतियां enforce: False हों:

# verify effective org policy constraints on project
for policy in \
  discoveryengine.managed.disableCustomMcpServerConnector \
  discoveryengine.managed.allowedEgressFqdns \
  discoveryengine.managed.allowedDataSources \
  iam.managed.disableAccessPolicyBinding \
  compute.vmExternalIpAccess; do
  gcloud org-policies describe ${policy} \
    --project=${PROJ_ID} \
    --effective \
    --format="flattened[no-pad](name.basename(),spec.rules[0])"
done

सेवा एजेंट बाइंडिंग की पुष्टि करें (एहतियाती तौर पर)

नए प्रोजेक्ट में, networkservices.googleapis.com को पहली बार चालू करने पर, Google Cloud अपने-आप Agent Gateway सेवा एजेंट को उपलब्ध कराता है और उसे roles/agentgateway.serviceAgent की अनुमति देता है. अगर किसी ऐसे मौजूदा प्रोजेक्ट का फिर से इस्तेमाल किया जा रहा है जिसमें पहले की गई क्लीनअप प्रोसेस में, डिफ़ॉल्ट सेवा एजेंट बाइंडिंग हटा दी गई हैं, तो फ़ेल-सेफ़ के तौर पर यहां दिए गए कमांड चलाएं. इससे यह पक्का किया जा सकेगा कि पहचान और भूमिका की बाइंडिंग बरकरार है:

# ensure network services service account has been created
gcloud beta services identity create \
  --service=networkservices.googleapis.com \
  --project="${PROJ_ID}"

# ensure network services service account has service agent roles applied
gcloud projects add-iam-policy-binding "${PROJ_ID}" \
  --member="serviceAccount:service-${PROJ_NO}@gcp-sa-agentgateway.iam.gserviceaccount.com" \
  --role="roles/agentgateway.serviceAgent"

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

4. नेटवर्क

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

स्टैटिक एक्सटर्नल आईपी पते रिज़र्व करना

Cloud NAT और बाहरी एमसीपी सर्वर वीएम के लिए, दो रीजनल स्टैटिक बाहरी IPv4 पते रिज़र्व करें:

# reserve static external ipv4 address for cloud nat
gcloud compute addresses create ip-${SLUG}-nat \
  --region=${REGION}

# reserve static external ipv4 address for the mcp server
gcloud compute addresses create ip-${SLUG}-mcp \
  --region=${REGION}

स्टैटिक एक्सटर्नल आईपी पतों की पुष्टि करना

Gemini Enterprise को रिमोट एमसीपी एंडपॉइंट के लिए, सार्वजनिक रूप से भरोसेमंद टीएलएस सर्टिफ़िकेट के साथ एचटीटीपीएस का इस्तेमाल करना होता है. इस लैब के लिए कस्टम डोमेन रजिस्टर करने के बजाय, sslip.io का इस्तेमाल करें. यह एक मुफ़्त वाइल्डकार्ड डीएनएस सेवा है. यह आईपी पते (जैसे, mcp.[IP].sslip.io) वाले किसी भी होस्टनेम को सीधे उस आईपी पर ले जाती है. Let's Encrypt जैसी सर्टिफ़िकेट देने वाली संस्थाएं, सिर्फ़ आईपी पतों के लिए सर्टिफ़िकेट जारी नहीं करती हैं. इसलिए, यह sslip.io होस्टनेम, Caddy रिवर्स प्रॉक्सी को एक मान्य डोमेन नेम देता है, ताकि एमसीपी सर्वर के लिए भरोसेमंद टीएलएस सर्टिफ़िकेट अपने-आप उपलब्ध कराया जा सके.

IPv4 पतों को एक्सपोर्ट करें और बाहरी एमसीपी सर्वर के लिए sslip.io डोमेन नेम और यूआरएल बनाएं:

# export static ip addresses and set vars for domain
export NAT_EXT_IP=$(gcloud compute addresses describe ip-${SLUG}-nat \
  --region=${REGION} \
  --format="value(address)")

export MCP_EXT_IP=$(gcloud compute addresses describe ip-${SLUG}-mcp \
  --region=${REGION} \
  --format="value(address)")

export MCP_DOMAIN="mcp.${MCP_EXT_IP}.sslip.io"
export MCP_URL="https://${MCP_DOMAIN}/mcp"

echo "cloud nat external ip    : ${NAT_EXT_IP}"
echo "mcp server external ip   : ${MCP_EXT_IP}"
echo "mcp url                  : ${MCP_URL}"

आउटपुट का उदाहरण:

cloud nat external ip    : 203.0.113.10
mcp server external ip   : 203.0.113.20
mcp url                  : https://mcp.203.0.113.20.sslip.io/mcp

इंटरनल नेटवर्क बनाना

जब Agent Gateway कनेक्टिविटी टेंप्लेट को networkAttachment के साथ egressNetworkConfig का इस्तेमाल करने के लिए कॉन्फ़िगर किया जाता है, तो पीएससी नेटवर्क अटैचमेंट को होस्ट करने वाले सबनेट में कम से कम /28 सीआईडीआर ब्लॉक होना चाहिए. साथ ही, इसमें निजी Google ऐक्सेस (--enable-private-ip-google-access) चालू होना चाहिए.

एजेंट गेटवे से डेटा बाहर भेजने के लिए, ग्लोबल वीपीसी नेटवर्क बनाएं:

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

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

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

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

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

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

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

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

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

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

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

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

पीएसटीएन नेटवर्क अटैचमेंट का संसाधन यूआरआई पाएं और उसे PSC_NA_URI एनवायरमेंट वैरिएबल में सेव करें. इस यूआरआई का रेफ़रंस, एजेंट गेटवे कॉन्फ़िगरेशन (networkConfig.egress.networkAttachment) में दिया जाएगा. इससे वीपीसी नेटवर्क में नेटवर्क इग्रेस के लिए, पीएससी इंटरफ़ेस को प्रोविज़न किया जा सकेगा:

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

Cloud NAT बनाना

Cloud NAT का इस्तेमाल, एजेंट गेटवे से बाहर जाने वाले ट्रैफ़िक के सोर्स आईपी पते को, सार्वजनिक इंटरनेट पर राउटिंग के लिए रिज़र्व किए गए सार्वजनिक आईपी पते में बदलने के लिए किया जाता है.

सिर्फ़ एजेंट गेटवे के इग्रेस नेटवर्क अटैचमेंट सबनेट के सोर्स, Cloud NAT का इस्तेमाल कर सकते हैं.

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

# create nat
gcloud compute routers nats create nat-${SLUG}-${REGION} \
  --router=cr-nat-${SLUG}-${REGION} \
  --region=${REGION} \
  --nat-custom-subnet-ip-ranges="subnet-${REGION}-agw" \
  --nat-external-ip-pool="ip-${SLUG}-nat" \
  --enable-logging \
  --log-filter=ALL

Cloud NAT की पुष्टि करना

Cloud NAT की स्थिति देखें और पुष्टि करें कि natIP सोर्स कॉन्फ़िगर किया गया है:

# verify cloud nat configuration
gcloud compute routers nats describe nat-${SLUG}-${REGION} \
  --router=cr-nat-${SLUG}-${REGION} \
  --region=${REGION} \
  --format="yaml(name,natIps,subnetworks.name)"

आउटपुट का उदाहरण:

name: nat-foo-us-central1
natIps:
- https://www.googleapis.com/compute/v1/projects/[PROJ_ID]/regions/us-central1/addresses/ip-foo-nat

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

एक्सटर्नल एमसीपी सर्वर वीएम को होस्ट करने के लिए, एक अलग और आइसोलेटेड वीपीसी नेटवर्क बनाएं.

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

# create subnet for mcp server
gcloud compute networks subnets create subnet-${REGION}-mcp \
  --network=vnet-${SLUG}-external \
  --range=240.240.240.0/24 \
  --region=${REGION} \
  --enable-private-ip-google-access

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

एक्सटर्नल वीपीसी नेटवर्क पर, दो इन्ग्रेस फ़ायरवॉल नियम बनाएं:

  • 2001: इससे इनबाउंड टीसीपी पोर्ट 80 की अनुमति मिलती है, ताकि Let's Encrypt, ${MCP_DOMAIN} के लिए ACME HTTP-01 डोमेन की पुष्टि करने की चुनौती को पूरा कर सके.
  • 2002: शुरू में, 0.0.0.0/0 से आने वाले टीसीपी पोर्ट 443 को अनुमति देता है, ताकि टीएलएस की तैयारी और OAuth 2.0 tokeninfo को लागू करने की पुष्टि की जा सके. इसके बाद, इसे ${NAT_EXT_IP}/32 पर लॉक कर दिया जाता है.
# create fw policy
gcloud compute network-firewall-policies create fw-policy-${SLUG}-external --global

# create fw policy rules
gcloud compute network-firewall-policies rules create 2001 \
  --description="allow in any http" \
  --firewall-policy=fw-policy-${SLUG}-external \
  --global-firewall-policy \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:80 \
  --src-ip-ranges=0.0.0.0/0 \
  --dest-ip-ranges=240.240.240.0/24 \
  --enable-logging

gcloud compute network-firewall-policies rules create 2002 \
  --description="allow in any https" \
  --firewall-policy=fw-policy-${SLUG}-external \
  --global-firewall-policy \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:443 \
  --src-ip-ranges=0.0.0.0/0 \
  --dest-ip-ranges=240.240.240.0/24 \
  --enable-logging

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

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

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

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

कनेक्टिविटी टेंप्लेट बनाना

कनेक्टिविटी टेंप्लेट स्पेसिफ़िकेशन में यह जानकारी होती है:

  • egressNetworkConfig.networkAttachment: यह PSC नेटवर्क अटैचमेंट की ओर इशारा करता है. इससे एजेंट गेटवे को आपके वीपीसी नेटवर्क से कनेक्ट किया जाता है.
  • egressNetworkConfig.vpcEgress: इसे ALL_TRAFFIC पर सेट करें, ताकि एजेंट के सभी आउटबाउंड कनेक्शन (इसमें सार्वजनिक इंटरनेट एमसीपी एंडपॉइंट भी शामिल हैं) वीपीसी नेटवर्क में रूट हो जाएं. साथ ही, Cloud NAT के सोर्स आईपी पते के अनुवाद का इस्तेमाल करके बाहर निकल जाएं.

कनेक्टिविटी टेंप्लेट की कॉन्फ़िगरेशन फ़ाइल बनाएं और इंपोर्ट करें:

# create connectivity template config file (vpcEgress: ALL_TRAFFIC)
cat > cfg/act-${AGW_NAME}.yaml << EOF
accessPath: AGENT_TO_ANYWHERE
name: projects/${PROJ_NO}/locations/${REGION}/agentConnectivityTemplates/act-${AGW_NAME}
deploymentModel: CENTRALIZED
egressNetworkConfig:
  networkAttachment: ${PSC_NA_URI}
  vpcEgress: ALL_TRAFFIC
EOF

# import connectivity template file (create template)
gcloud network-services agent-connectivity-templates import act-${AGW_NAME} \
  --source="cfg/act-${AGW_NAME}.yaml" \
  --location=${REGION}

एजेंट गेटवे बनाना

एजेंट गेटवे की खास जानकारी में इनके बारे में बताया गया है:

  • agentConnectivityTemplate: यह कनेक्टिविटी टेंप्लेट की ओर इशारा करता है, ताकि गेटवे, वीपीसी कनेक्टिविटी के लिए पीएससी नेटवर्क अटैचमेंट का इस्तेमाल कर सके.
  • registries: यह गेटवे को क्षेत्रीय एजेंट रजिस्ट्री से जोड़ता है, ताकि कैटलॉग किए गए एमसीपी एंडपॉइंट और टूल स्कीमा को हल किया जा सके.

Agent Gateway की कॉन्फ़िगरेशन फ़ाइल बनाएं और इंपोर्ट करें:

# create agent gateway config file
cat > cfg/${AGW_NAME}.yaml << EOF
name: ${AGW_NAME}
protocols:
  - MCP
googleManaged:
  governedAccessPath: AGENT_TO_ANYWHERE
agentConnectivityTemplate: projects/${PROJ_NO}/locations/${REGION}/agentConnectivityTemplates/act-${AGW_NAME}
registries:
  - "//agentregistry.googleapis.com/projects/${PROJ_ID}/locations/${REGION}"
EOF

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

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

एजेंट रजिस्ट्री और कनेक्टिविटी टेंप्लेट के कॉन्फ़िगरेशन की पुष्टि करें:

# verify agent gateway deployment details
gcloud network-services agent-gateways describe ${AGW_NAME} \
  --location=${REGION} \
  --format="yaml(name,agentConnectivityTemplate,registries)"

आउटपुट का उदाहरण:

agentConnectivityTemplate: projects/[PROJ_NO]/locations/us-central1/agentConnectivityTemplates/act-foo-us-central1
name: projects/[PROJ_ID]/locations/us-central1/agentGateways/agw-foo-us-central1-ata
registries:
- //agentregistry.googleapis.com/projects/[PROJ_ID]/locations/us-central1

गेटवे कनेक्शन की पुष्टि करने के लिए, पीएससी नेटवर्क अटैचमेंट की जांच करें:

# show psc network attachment details
gcloud compute network-attachments describe psc-na-${REGION}-agw \
  --region=${REGION} \
  --format="yaml(connectionEndpoints)"

आउटपुट का उदाहरण:

connectionEndpoints:
- ipAddress: 10.10.10.2
  projectIdOrNum: '[TENANT_PROJ_NO]'
  status: ACCEPTED
  subnetwork: https://www.googleapis.com/compute/v1/projects/[PROJ_ID]/regions/us-central1/subnetworks/subnet-us-central1-agw

अनुमति देने का अधिकार किसी और को सौंपना

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

Agent Gateway में, बुनियादी इनलाइन ALLOW और DENY नियमों का पालन किया जाता है. हालांकि, एंटरप्राइज़ एनवायरमेंट के लिए, एक ही जगह से पहचान के हिसाब से गवर्नेंस की ज़रूरत होती है. IAM की यूनिफ़ाइड ऐक्सेस नीतियों (या ऐक्सेस नीतियों) की मदद से, स्टैंडर्ड IAM v3 ऐक्सेस नीतियों का इस्तेमाल करके, डेटा बाहर भेजने के ऐक्सेस से जुड़े नियमों को मैनेज किया जाता है.

figure3

तीसरी इमेज. अनुमति देने से जुड़ा स्ट्रक्चर

अनुमति देने की प्रोसेस में तीन कॉम्पोनेंट शामिल होते हैं:

  1. गेटवे ऑथराइज़ेशन की नीति (authzPolicy):
    • एजेंट गेटवे को टारगेट करने वाला रीजनल संसाधन.
    • policyProfile: REQUEST_AUTHZ और action: CUSTOM के साथ कॉन्फ़िगर किया गया है, ताकि बाहर जाने वाले सभी अनुरोधों की पुष्टि करने की प्रोसेस को IAP ऑथराइज़ेशन एक्सटेंशन पर भेजा जा सके.
  2. IAP सेवा एक्सटेंशन (authzExtension):
    • यह एक रीजनल संसाधन है, जो Identity-Aware Proxy (iap.googleapis.com) को अनुरोध की अनुमति देने का काम सौंपता है.
    • यह कुकी, ENFORCE मोड में नीतियों का आकलन करती है. इसके लिए, नीति के वर्शन V2 का इस्तेमाल किया जाता है.
  3. IAM की यूनिफ़ाइड ऐक्सेस नीति और बाइंडिंग (accessPolicy & policyBinding):
    • ग्लोबल IAM v3 के ऐसे संसाधन जिनमें ऐक्सेस के बारे में बारीकी से जानकारी देने वाले नियम शामिल हों.
    • यह फ़ंक्शन, कॉल करने वाले एजेंट की SPIFFE प्रिंसिपल आइडेंटिटी की पुष्टि करता है. साथ ही, यूनिवर्सल iap.googleapis.com/resources.egressViaIAP अनुमति की पुष्टि करता है. इसके अलावा, यह डेस्टिनेशन एट्रिब्यूट के हिसाब से, कॉमन एक्सप्रेशन लैंग्वेज (सीईएल) की शर्तों का आकलन करता है.

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

# create authz extension config file
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

# import authz extension config file (create 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}

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

देखें कि ऑथराइज़ेशन एक्सटेंशन चालू है या नहीं:

# list authz extensions
gcloud service-extensions authz-extensions list \
  --location=${REGION} \
  --format="table(
    name.basename():label=NAME,
    createTime.date(tz=LOCAL):label=CREATED,
    service:label=SERVICE,
    metadata:label=METADATA,
    timeout:label=TIMEOUT
  )"

अनुमति की नीति लागू करना

network-security अनुमति देने से जुड़ी नीति का ऐसा कॉन्फ़िगरेशन बनाएं जो एजेंट गेटवे को टारगेट करता हो. साथ ही, अनुरोध की पुष्टि करने की ज़िम्मेदारी, IAP के लिए अनुमति देने वाले एक्सटेंशन को सौंपता हो:

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

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

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

देखें कि अनुमति देने से जुड़ी नीति लागू हो:

# list authz policies
gcloud network-security authz-policies list \
  --location=${REGION} \
  --format="table(
    name.basename():label=NAME,
    action:label=ACTION,
    policyProfile:label=POLICY_PROFILE,
    customProvider.authzExtension.resources[0].basename():label=CUSTOM_PROVIDER_RESOURCE
  )"

IAM ऐक्सेस नीतियां बनाना

Agent Gateway अब अनुमति की जांच करने का काम IAP को सौंपता है. साथ ही, Agent Registry से डेस्टिनेशन मेटाडेटा को हल करता है. इसके बाद, टूल को बाहर से एक्ज़ीक्यूट करने के लिए, IAM की यूनिफ़ाइड ऐक्सेस नीति का नियम तय करें.

IAP, CEL एट्रिब्यूट एक्सप्रेशन का आकलन, एजेंट रजिस्ट्री के इन डेस्टिनेशन एट्रिब्यूट के आधार पर करता है:

  • रजिस्टर किए गए स्टेटस (destination.is_registered):
    • बूलियन (true/false), इससे पता चलता है कि एजेंट रजिस्ट्री में डेस्टिनेशन को कैटलॉग किया गया है या नहीं.
  • MCP सर्वर का नाम (destination.agent_registry.mcp_server.name):
    • एजेंट रजिस्ट्री में रजिस्टर किए गए कैननिकल एमसीपी सर्वर के संसाधन का नाम.
  • एमसीपी तरीका (destination.agent_registry.mcp_server.method):
    • एमसीपी के जिस तरीके का इस्तेमाल किया जा रहा है (जैसे, tools/call, tools/list, initialize).
  • टूल का नाम (destination.agent_registry.mcp_server.tool.name):
    • जिस टूल को चालू किया गया है उसका नाम (जैसे, get_sprocket_by_id या get_sprockets). इससे रजिस्टर किए गए एमसीपी सर्वर पर, टूल के लेवल पर अनुमति दी जा सकती है.

IAM ऐक्सेस की नीति का नियम तय करना

IAM नीति के नियम के मेनिफ़ेस्ट में यह जानकारी दी गई होती है:

  • प्रिंसिपल: यह SPIFFE प्रिंसिपल आइडेंटिटी, Gemini Enterprise के मुख्य असिस्टेंट एजेंट को दिखाती है.
  • अनुमतियां: सभी IAP-गवर्नड इग्रेस ट्रैफ़िक के लिए, यूनिवर्सल iap.googleapis.com/resources.egressViaIAP अनुमति ज़रूरी है.
  • शर्तें: एक सीईएल एक्सप्रेशन (destination.is_registered == true), जो यह पक्का करता है कि एजेंट सिर्फ़ एजेंट रजिस्ट्री में कैटलॉग किए गए एंडपॉइंट को चालू कर सकता है.

नीति के नियम की मेनिफ़ेस्ट फ़ाइल बनाएं:

# create access policy rule file
cat > cfg/uap-policy-${SLUG}-rules.json << EOF
[
  {
    "description": "allow ge assistant to any registered service",
    "effect": "ALLOW",
    "principals": [
      "principal://${TRUST_DOMAIN}/resources/discoveryengine/projects/${PROJ_NO}/locations/global/engines/${GE_APP_INIT}/assistants/default_assistant/agents/default/core_assistant"
    ],
    "operation": {
      "permissions": [
        "iap.googleapis.com/resources.egressViaIAP"
      ]
    },
    "conditions": {
      "iap.googleapis.com": {
        "expression": \
        "destination.is_registered == true"
      }
    }
  }
]
EOF

IAM ऐक्सेस की नीति लागू करना

मैनिफ़ेस्ट फ़ाइल में तय किए गए नियमों का इस्तेमाल करके, ग्लोबल IAM ऐक्सेस की नीति बनाएं:

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

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

देखें कि IAM ऐक्सेस नीति बन गई है या नहीं. साथ ही, नियम की जानकारी की जांच करें:

# show iam access policy details
gcloud iam access-policies describe uap-policy-${SLUG} \
  --project=${PROJ_ID} \
  --location=global

आउटपुट का उदाहरण:

details:
  rules:
  - conditions:
      iap.googleapis.com:
        expression: destination.is_registered == true
    description: allow ge assistant to any registered service
    effect: ALLOW
    operation:
      permissions:
      - iap.googleapis.com/resources.egressViaIAP
    principals:
    - principal://agents.global.org-[ORG_ID].system.id.goog/resources/discoveryengine/projects/[PROJ_NO]/locations/global/engines/app-foo-global_[EPOCH]/assistants/default_assistant/agents/default/core_assistant
name: projects/[PROJ_ID]/locations/global/accessPolicies/uap-policy-foo

आईएएम ऐक्सेस की नीति को प्रोजेक्ट से बाइंड करना

अपने प्रोजेक्ट में मौजूद सभी एजेंट गेटवे पर नीति लागू करने के लिए, एक नीति बाइंडिंग बनाएं. इससे आईएएम ऐक्सेस नीति को प्रोजेक्ट रिसॉर्स से जोड़ा जा सकेगा:

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

IAM ऐक्सेस की नीति के बाइंड होने की पुष्टि करना

नीति के लागू होने के चालू पॉइंट की जांच करें, ताकि यह पक्का किया जा सके कि वे सही नीति और टारगेट से जुड़े हों:

# show policy binding details
gcloud iam policy-bindings describe uap-bind-${SLUG} \
  --project=${PROJ_ID} \
  --location=global

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

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

इस सेक्शन में, आपको बाहरी FastMCP OAuth 2.0 रिसॉर्स सर्वर (mcp-sprockets) को डिप्लॉय करना होगा. यह get_sprockets और get_sprocket_by_id टूल को दिखाता है. साथ ही, यह पुष्टि करनी होगी कि यह https://oauth2.googleapis.com/tokeninfo के ख़िलाफ़, Google OAuth 2.0 के बियरर टोकन की क्रिप्टोग्राफ़िक पुष्टि करता है. इसके बाद, बाहरी फ़ायरवॉल के नियम को Cloud NAT के स्टैटिक आईपी के लिए लॉक कर दें.

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

स्टार्टअप स्क्रिप्ट, Caddy और FastMCP इंस्टॉल करती है. साथ ही, 127.0.0.1:8080 पर mcp-sprockets सर्वर लॉन्च करती है और ${MCP_DOMAIN} पर एचटीटीपीएस की सुविधा देने के लिए Caddy को कॉन्फ़िगर करती है.

जब भी Gemini Enterprise, एमसीपी टूल (जैसे, get_sprockets और get_sprocket_by_id) को कॉल करेगा, तब सर्वर ये काम करेगा:

  1. X-Forwarded-For हेडर (egress_source_ip) से, कॉल करने वाले के सोर्स आईपी को पढ़ता है.
  2. Authorization: Bearer [access_token] हेडर निकालें और Google OAuth 2.0 की पुष्टि करने वाले एंडपॉइंट (https://oauth2.googleapis.com/tokeninfo?access_token=[token]) के ख़िलाफ़ टोकन की पुष्टि करें.
  3. "egress_source_ip" के साथ "authenticated_user" ([user_email]) वैल्यू दिखाएं. इससे यह साबित होगा कि बाहरी MCP सर्वर ने Cloud NAT स्टैटिक आईपी और असली उपयोगकर्ता की Google OAuth 2.0 पहचान, दोनों की पुष्टि की है.
# create startup script for the sprockets mcp server vm
cat > cfg/server-startup.sh << 'EOF'
#!/bin/bash
set -euo pipefail

MCP_DOMAIN=$(curl -s -H "Metadata-Flavor: Google" \
  http://metadata.google.internal/computeMetadata/v1/instance/attributes/mcp-domain)

export DEBIAN_FRONTEND=noninteractive
apt-get update -y
apt-get install -y caddy python3-venv curl

mkdir -p /opt/mcp-sprockets
python3 -m venv /opt/mcp-sprockets/venv
/opt/mcp-sprockets/venv/bin/pip install --upgrade pip
/opt/mcp-sprockets/venv/bin/pip install "fastmcp>=2.14.0" "uvicorn>=0.34.0"

cat <<'PYEOF' > /opt/mcp-sprockets/main.py
import json
import urllib.parse
import urllib.request
from typing import Any, Dict
from fastmcp import FastMCP
from fastmcp.server.dependencies import get_http_headers
from mcp.types import ToolAnnotations

mcp = FastMCP("mcp-sprockets")

SPROCKETS = {
    "SPK-101": {"id": "SPK-101", "model": "ANSI-40-12T", "teeth": 12, "pitch_in": 0.5, "material": "1045 Carbon Steel", "stock": 140, "unit_price": 18.50},
    "SPK-102": {"id": "SPK-102", "model": "ANSI-40-24T", "teeth": 24, "pitch_in": 0.5, "material": "1045 Carbon Steel", "stock": 85, "unit_price": 29.00},
    "SPK-103": {"id": "SPK-103", "model": "ANSI-60-16T", "teeth": 16, "pitch_in": 0.75, "material": "304 Stainless Steel", "stock": 60, "unit_price": 42.00},
    "SPK-104": {"id": "SPK-104", "model": "ANSI-60-32T", "teeth": 32, "pitch_in": 0.75, "material": "304 Stainless Steel", "stock": 35, "unit_price": 68.00},
    "SPK-105": {"id": "SPK-105", "model": "ANSI-80-20T", "teeth": 20, "pitch_in": 1.0, "material": "4140 Alloy Steel", "stock": 50, "unit_price": 95.00}
}

def verify_google_oauth_token(headers: Dict[str, str]) -> str:
    token = headers.get("authorization", "")[7:].strip() if headers.get("authorization", "").lower().startswith("bearer ") else ""
    if not token:
        return "unauthenticated (missing Bearer token)"
    url = "https://oauth2.googleapis.com/tokeninfo?" + urllib.parse.urlencode({"access_token": token})
    with urllib.request.urlopen(url, timeout=5) as resp:
        info = json.loads(resp.read().decode("utf-8"))
        return info.get("email", info.get("sub", "verified-oauth-user"))

@mcp.tool(
    description="list all sprockets in the inventory catalog",
    annotations=ToolAnnotations(
        readOnlyHint=True,
        destructiveHint=False,
        idempotentHint=True,
        openWorldHint=False
    )
)
def get_sprockets() -> Dict[str, Any]:
    headers = get_http_headers(include_all=True)
    caller_ip = headers.get("x-forwarded-for", "unknown").split(",")[0].strip()
    try:
        user_email = verify_google_oauth_token(headers)
    except Exception as exc:
        return {"egress_source_ip": caller_ip, "authenticated_user": None, "error": f"OAuth token verification failed: {exc}"}
    return {
        "egress_source_ip": caller_ip,
        "authenticated_user": user_email,
        "sprockets": list(SPROCKETS.values())
    }

@mcp.tool(
    description="fetch details of a specific sprocket by its ID (eg, SPK-101)",
    annotations=ToolAnnotations(
        readOnlyHint=True,
        destructiveHint=False,
        idempotentHint=True,
        openWorldHint=False
    )
)
def get_sprocket_by_id(sprocket_id: str) -> Dict[str, Any]:
    headers = get_http_headers(include_all=True)
    caller_ip = headers.get("x-forwarded-for", "unknown").split(",")[0].strip()
    try:
        user_email = verify_google_oauth_token(headers)
    except Exception as exc:
        return {"egress_source_ip": caller_ip, "authenticated_user": None, "error": f"OAuth token verification failed: {exc}"}
    sprocket = SPROCKETS.get(sprocket_id.upper())
    if sprocket:
        return {
            "egress_source_ip": caller_ip,
            "authenticated_user": user_email,
            "sprocket": sprocket
        }
    return {
        "egress_source_ip": caller_ip,
        "authenticated_user": user_email,
        "error": f"Sprocket '{sprocket_id}' not found."
    }

app = mcp.http_app(stateless_http=True)
PYEOF

cat <<'SVCEOF' > /etc/systemd/system/mcp-sprockets.service
[Unit]
Description=Sprockets FastMCP Server
After=network.target

[Service]
Type=simple
WorkingDirectory=/opt/mcp-sprockets
ExecStart=/opt/mcp-sprockets/venv/bin/uvicorn main:app --host 127.0.0.1 --port 8080 --forwarded-allow-ips="*"
Restart=always

[Install]
WantedBy=multi-user.target
SVCEOF

systemctl daemon-reload
systemctl enable --now mcp-sprockets.service
systemctl restart mcp-sprockets.service

cat <<CADDYEOF > "/etc/caddy/Caddyfile"
${MCP_DOMAIN} {
    reverse_proxy 127.0.0.1:8080
}
CADDYEOF

systemctl restart caddy
EOF

# create vm instance
gcloud compute instances create vm-${MCP_NAME} \
  --zone=${ZONE} \
  --machine-type=e2-micro \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --shielded-secure-boot \
  --network-interface="subnet=subnet-${REGION}-mcp,address=${MCP_EXT_IP}" \
  --metadata="mcp-domain=${MCP_DOMAIN}" \
  --metadata-from-file="startup-script=cfg/server-startup.sh"

एमसीपी सर्वर के तैयार होने और OAuth 2.0 tokeninfo की पुष्टि करने की प्रोसेस की पुष्टि करना

स्टार्टअप स्क्रिप्ट को FastMCP और Caddy इंस्टॉल करने दें. साथ ही, Let's Encrypt टीएलएस सर्टिफ़िकेट को प्रोविज़न करने दें. इसमें कुछ मिनट लगेंगे.

# poll until caddy serves valid tls and fastmcp responds to tools/list
for i in $(seq 1 30); do
  RESP=$(curl -s -X POST "${MCP_URL}" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json, text/event-stream" \
    -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}' || true)
  if echo "${RESP}" | grep -q "get_sprockets"; then
    echo "mcp server and let's encrypt tls ready"
    break
  fi
  echo "...waiting for mcp server and let's encrypt tls (attempt ${i}/30)..."
  sleep 5
done

sslip.io डीएनएस रिज़ॉल्यूशन, Caddy की ओर से दिया गया Let's Encrypt टीएलएस सर्टिफ़िकेट, और FastMCP tools/list रिस्पॉन्स की पुष्टि करें:

# query mcp server for tools list
curl -v -X POST "${MCP_URL}" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}' \
  2>&1 | grep -E "Connected to|subject:|issuer:|SSL certificate|HTTP/|event:|data:"

आउटपुट का उदाहरण:

* Connected to mcp.203.0.113.20.sslip.io (203.0.113.20) port 443
*  subject: CN=mcp.203.0.113.20.sslip.io
*  issuer: C=US; O=Let's Encrypt; CN=E5
*  SSL certificate verify ok.
> POST /mcp HTTP/2
< HTTP/2 200
event: message
data: {"jsonrpc":"2.0","id":1,"result":{"tools":[{"name":"get_sprockets","description":"list all sprockets in the inventory catalog","inputSchema":{"properties":{},"type":"object"},"annotations":{"destructiveHint":false,"idempotentHint":true,"openWorldHint":false,"readOnlyHint":true}},{"name":"get_sprocket_by_id","description":"fetch details of a specific sprocket by its ID (eg, SPK-101)","inputSchema":{"properties":{"sprocket_id":{"type":"string"}},"required":["sprocket_id"],"type":"object"},"annotations":{"destructiveHint":false,"idempotentHint":true,"openWorldHint":false,"readOnlyHint":true}}]}}

बाहरी फ़ायरवॉल को लॉक करने से पहले, Google OAuth 2.0 बियरर टोकन (gcloud auth print-access-token) पास करके, tools/call टेस्ट चलाएं. इससे यह पुष्टि की जा सकेगी कि mcp-sprockets, https://oauth2.googleapis.com/tokeninfo के ख़िलाफ़ टोकन की पुष्टि करता है और कॉलर के सोर्स आईपी पते के साथ-साथ आपका "authenticated_user" ईमेल दिखाता है:

# query mcp server (test tools/call with google oauth 2.0 bearer token)
curl -s -X POST "${MCP_URL}" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "get_sprocket_by_id",
      "arguments": {"sprocket_id": "SPK-105"}
    }
  }' | sed -n 's/^data: //p' | jq '.result.structuredContent'

आउटपुट का उदाहरण (इसमें फ़ायरवॉल लॉकडाउन से पहले का आपका Cloud Shell आईपी और पुष्टि किया गया Google OAuth ईमेल दिखाया गया है):

{
  "egress_source_ip": "198.51.100.154",
  "authenticated_user": "user@example.com",
  "sprocket": {
    "id": "SPK-105",
    "model": "ANSI-80-20T",
    "teeth": 20,
    "pitch_in": 1.0,
    "material": "4140 Alloy Steel",
    "stock": 50,
    "unit_price": 95.0
  }
}

फ़ायरवॉल को Cloud NAT के स्टैटिक आईपी पर लॉक करना

बाहरी वीपीसी नेटवर्क की फ़ायरवॉल नीति को अपडेट करें, ताकि टीसीपी पोर्ट 443, Cloud NAT के स्टैटिक बाहरी आईपी (${NAT_EXT_IP}/32) से सिर्फ़ ट्रैफ़िक स्वीकार करे:

# create fw policy rule allowing https only from cloud nat static ip
gcloud compute network-firewall-policies rules create 2003 \
  --description="allow in any https from nat ip" \
  --firewall-policy=fw-policy-${SLUG}-external \
  --global-firewall-policy \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:443 \
  --src-ip-ranges="${NAT_EXT_IP}/32" \
  --dest-ip-ranges=240.240.240.0/24 \
  --enable-logging

# delete temporary open fw policy rules
gcloud compute network-firewall-policies rules delete 2001 \
  --firewall-policy=fw-policy-${SLUG}-external \
  --global-firewall-policy

gcloud compute network-firewall-policies rules delete 2002 \
  --firewall-policy=fw-policy-${SLUG}-external \
  --global-firewall-policy

देखें कि बाहरी फ़ायरवॉल की नीति से जुड़े नियम लागू किए गए हों:

# list all rules in the global network firewall policy
gcloud compute network-firewall-policies describe fw-policy-${SLUG}-external \
  --global \
  --flatten="rules[]" \
  --format="table(
    rules.priority:label=RULE,
    rules.action:label=ACTION,
    rules.direction:label=DIRECTION,
    firstof(
      rules.match.srcIpRanges,
      rules.match.srcAddressGroups,
      rules.match.srcSecureTags.name
    ).map().sub('projects/[^/]+/(locations/global/|global/)', '').list():label=SRC,
    firstof(
      rules.targetForwardingRules,
      rules.match.destIpRanges,
      rules.targetType
    ).map().sub('projects/[^/]+/(locations/global/|global/)', '').list():label=DST
  )"

पुष्टि करें कि Cloud NAT के स्टैटिक आईपी पते के बाहर के डायरेक्ट कनेक्शन अब ब्लॉक कर दिए गए हैं:

# query mcp server
curl -i --connect-timeout 5 "${MCP_URL}" \
  || echo "Expected: Direct access blocked (not originating from ${NAT_EXT_IP})"

आउटपुट का उदाहरण:

curl: (28) Connection timed out after 5001 milliseconds
Expected: Direct access blocked (not originating from 203.0.113.10)

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

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

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

इस सेक्शन में, आपको एजेंट रजिस्ट्री में एमसीपी सर्वर और उसके टूल स्कीमा (toolspec.json) को रजिस्टर करना होगा. Agent Gateway के ज़रिए Google APIs और सेवाओं के साथ Gemini Enterprise को इंटरैक्ट करने की सुविधा देने के लिए, आपको एक रजिस्ट्री एंडपॉइंट सेवा (oauth2-googleapis) भी बनानी होगी. इसमें Google के उन API इंटरफ़ेस के बारे में बताया जाएगा जिनका इस्तेमाल Gemini Enterprise, टोकन के लिए ऑथराइज़ेशन कोड को बदलने के लिए करता है.

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

एमसीपी सर्वर पर उपलब्ध टूल के बारे में Gemini Enterprise को बताने के लिए, एजेंट रजिस्ट्री में सेवा रजिस्टर करते समय टूल स्पेसिफ़िकेशन फ़ाइल (cfg/toolspec.json) उपलब्ध कराएं.

एमसीपी टूल की खास जानकारी बनाना

# create tool spec file for the sprockets mcp server
cat <<'EOF' > cfg/toolspec.json
{
  "tools": [
    {
      "name": "get_sprockets",
      "description": "List all sprockets in the inventory catalog.",
      "inputSchema": {
        "type": "object",
        "properties": {}
      },
      "isReadOnly": true,
      "isDestructive": false,
      "isIdempotent": true,
      "isOpenWorld": false
    },
    {
      "name": "get_sprocket_by_id",
      "description": "Fetch details of a specific sprocket by its ID (e.g., SPK-101).",
      "inputSchema": {
        "type": "object",
        "properties": {
          "sprocket_id": {
            "type": "string",
            "description": "The sprocket identifier (e.g., SPK-101, SPK-105)."
          }
        },
        "required": [
          "sprocket_id"
        ]
      },
      "isReadOnly": true,
      "isDestructive": false,
      "isIdempotent": true,
      "isOpenWorld": false
    }
  ]
}
EOF

एमसीपी सर्वर सेवा बनाना

# create registry service (mcp server)
gcloud agent-registry services create ${MCP_NAME} \
  --project=${PROJ_ID} \
  --location=${REGION} \
  --display-name="${MCP_DOMAIN}" \
  --description="MANDATORY SPROCKETS INVENTORY & CATALOG AGENT: You MUST \
ALWAYS invoke this tool (get_sprockets or get_sprocket_by_id) for ANY question \
about sprockets, inventory catalog listings, sprocket IDs (SPK-101 through \
SPK-105), ANSI models (ANSI-40, ANSI-60, ANSI-80), tooth counts, pitch, \
material, stock levels, unit prices, authenticated_user, or egress_source_ip \
verification. NEVER guess or fabricate inventory data yourself and NEVER \
transfer sprocket queries to file_and_coding_agent or web search. Always \
delegate every sprocket or inventory lookup to this tool." \
  --mcp-server-spec-type=tool-spec \
  --mcp-server-spec-content=cfg/toolspec.json \
  --interfaces=protocolBinding=JSONRPC,url="${MCP_URL}"

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

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

# list registry regional mcp servers
gcloud agent-registry mcp-servers list \
  --location=${REGION} \
  --project=${PROJ_ID} \
  --format="table(
    name.basename():label=REGISTRY_ID,
    displayName:label=DISPLAY_NAME,
    interfaces[0].url:label=ENDPOINT_URL,
    tools[].name.list():label=TOOLS
  )"

आउटपुट का उदाहरण:

REGISTRY_ID                                          DISPLAY_NAME               ENDPOINT_URL                          TOOLS
agentregistry-00000000-0000-0000-5c39-1f6e542bb2b8   mcp.203.0.113.20.sslip.io  https://mcp.203.0.113.20.sslip.io/mcp  get_sprockets,get_sprocket_by_id

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

# describe mcp server tool specs
gcloud agent-registry services describe ${MCP_NAME} \
  --location=${REGION} \
  --project=${PROJ_ID} \
  --format="yaml(mcpServerSpec.content.tools)"

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

Gemini Enterprise DataConnector के बैकएंड को Agent Gateway के ज़रिए, Google OAuth 2.0 ऑथराइज़ेशन सर्वर (https://oauth2.googleapis.com/token) को POST अनुरोध भेजने की अनुमति देने के लिए, टोकन एंडपॉइंट को Agent Registry में रजिस्टर करना होगा. इससे IAP destination.is_registered == true का आकलन कर पाएगा. Gemini Enterprise का बैकएंड, ऑथराइज़ेशन फ़्लो में OAuth क्लाइंट के तौर पर काम करता है.

एंडपॉइंट सेवा बनाना

# create registry service (endpoint)
gcloud agent-registry services create oauth2-googleapis \
  --project=${PROJ_ID} \
  --location=${REGION} \
  --display-name="oauth2.googleapis.com" \
  --description="google oauth2 endpoint" \
  --endpoint-spec-type=no-spec \
  --interfaces=protocolBinding=JSONRPC,url=https://oauth2.googleapis.com

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

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

अनुमानित आउटपुट:

DISPLAY_NAME           ENDPOINT_ID                                         URL
oauth2.googleapis.com  agentregistry-00000000-0000-0000-0012-3456789abcde  https://oauth2.googleapis.com

IAM ऐक्सेस की नीति

IAM ऐक्सेस नीति, Gemini Enterprise ऐप्लिकेशन core_assistant एजेंट आइडेंटिटी की ओर से अनुरोध की गई किसी भी रजिस्टर की गई सेवा के लिए, अनुमति देने की नीति तय करती है. इसलिए, OAuth टोकन एक्सचेंज के लिए, IAM नीति के अतिरिक्त बाइंडिंग की ज़रूरत नहीं होती.

  - conditions:
      iap.googleapis.com:
        expression: destination.is_registered == true
    description: allow ge assistant to any registered service
    effect: ALLOW

यह एजेंट रजिस्ट्री का हिस्सा है... अब Gemini Enterprise सेक्शन पर जाएं.

8. Gemini Enterprise

इस सेक्शन में, आइडेंटिटी प्रोवाइडर, बिना शुल्क आज़माने का लाइसेंस, और Google Identity OAuth 2.0 क्लाइंट क्रेडेंशियल कॉन्फ़िगर करें. साथ ही, Gemini Enterprise ऐप्लिकेशन (${GE_APP_ID}) बनाएं, आउटबाउंड इग्रेस को अपने एजेंट गेटवे (${AGW_URI}) से बाइंड करें, और रजिस्टर किए गए sprockets MCP सर्वर को OAuth 2.0 कस्टम एमसीपी डेटा स्टोर के तौर पर कनेक्ट करें.

Gemini Enterprise ऐप्लिकेशन बनाना

नीचे दिए गए तरीके में, Gemini Enterprise ऐप्लिकेशन के संसाधन और कॉन्फ़िगरेशन बनाने के लिए discoveryengine.googleapis.com API का इस्तेमाल किया जाता है. Google Cloud Console के यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करके कॉन्फ़िगर करने के लिए, निर्देशों के लिए ऐप्लिकेशन बनाना लेख पढ़ें.

# create engine (ge app)
curl -s -X POST "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines?engineId=${GE_APP_INIT}" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" -H "Content-Type: application/json" \
  -d @- <<EOF
{
  "displayName": "${GE_APP_DISPLAY_NAME}",
  "dataStoreIds": [],
  "solutionType": "SOLUTION_TYPE_SEARCH",
  "industryVertical": "GENERIC",
  "appType": "APP_TYPE_INTRANET",
  "searchEngineConfig": {
    "searchTier": "SEARCH_TIER_ENTERPRISE",
    "searchAddOns": [
      "SEARCH_ADD_ON_LLM"
    ]
  },
  "commonConfig": {
    "companyName": "${GE_APP_ORG_NAME}"
  },
  "observabilityConfig": {
    "observabilityEnabled": true,
    "sensitiveLoggingEnabled": true
  }
}
EOF

ऐप्लिकेशन बनाने की पुष्टि करना

# fetch engine (ge app) id
export GE_APP_ID=$(curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" -H "X-Goog-User-Project: ${PROJ_ID}" \
  | jq -r --arg name "${GE_APP_DISPLAY_NAME}" '.engines[] | select(.displayName==$name) | .name | split("/") | last')

echo "engine (ge app) id: ${GE_APP_ID}"

बनाया गया कॉन्फ़िगरेशन देखने के लिए, इंजन की जानकारी देखें:

# get engine (ge app) details
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}"

आइडेंटिटी प्रोवाइडर चालू करना

Gemini Enterprise ऐप्लिकेशन पर, असली उपयोगकर्ता की पुष्टि करने के लिए, Google Identity को आइडेंटिटी प्रोवाइडर के तौर पर चालू करें.

यहां दिए गए तरीके में, Gemini Enterprise ऐप्लिकेशन के आइडेंटिटी प्रोवाइडर को कॉन्फ़िगर करने के लिए, discoveryengine.googleapis.com API का इस्तेमाल किया जाता है. Google Cloud Console के यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करके कॉन्फ़िगर करने के लिए, निर्देशों के लिए आइडेंटिटी प्रोवाइडर कॉन्फ़िगर करना लेख पढ़ें.

# set identity provider
curl -s -X PATCH "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/aclConfig" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" -H "Content-Type: application/json" \
  -d @- <<EOF
{
  "idpConfig": {
    "idpType": "GSUITE"
  }
}
EOF

पहचान की पुष्टि करने वाली कंपनी की पुष्टि करना

# show identity provider
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/aclConfig" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}"

आउटपुट "idpType": "GSUITE", Google Identity provider से जुड़ा होता है.

(ज़रूरी नहीं) Gemini Enterprise का बिना किसी शुल्क के आज़माने वाला लाइसेंस चालू करें

अगर किसी ऐसे प्रोजेक्ट का इस्तेमाल किया जा रहा है जिसे Gemini Enterprise के लाइसेंस असाइन किए गए हैं, तो इस चरण को छोड़ दें. अगर बिना लाइसेंस के किसी नए प्रोजेक्ट का इस्तेमाल किया जा रहा है, तो जारी रखें और यह तरीका अपनाएं.

Gemini Enterprise के लिए लाइसेंस कॉन्फ़िगरेशन रिसॉर्स बनाएं, ताकि उपयोगकर्ताओं को 30 दिनों के लिए Gemini Enterprise का ऐक्सेस दिया जा सके. इससे नए ट्रायल के लिए डिफ़ॉल्ट लाइसेंस सेट हो जाएगा. इसलिए, लॉगिन करने वाले किसी भी उपयोगकर्ता को सीट अपने-आप मिल जाएगी:

# configure free trial subscription
curl -s -X POST "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/licenseConfigs?licenseConfigId=free_trial_gemini" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" -H "Content-Type: application/json" \
  -d @- <<EOF
{
  "subscriptionTier": "SUBSCRIPTION_TIER_SEARCH_AND_ASSISTANT",
  "freeTrial": true
}
EOF

पुष्टि करें कि लाइसेंस लागू हो गया है

# show license config
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/licenseConfigs/free_trial_gemini" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}"

"subscriptionTerm": "SUBSCRIPTION_TERM_ONE_MONTH" और "freeTrial": true देखें.

# verify auto-registration enabled on default user store
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/userStores/default_user_store" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}"

../free_trial_gemini" और "enableLicenseAutoRegister": true देखें.

Gemini Enterprise (OAuth 2.0 क्लाइंट) को, उपयोगकर्ता के चुने हुए Google OAuth 2.0 Bearer टोकन को हासिल करने और उसे आपकी ओर से mcp-sprocketsसंसाधन सर्वर को दिखाने की अनुमति देने के लिए, Google Auth Platform OAuth की सहमति वाली स्क्रीन को कॉन्फ़िगर करें. साथ ही, अपने प्रोजेक्ट में वेब ऐप्लिकेशन OAuth 2.0 क्लाइंट आईडी बनाएं.

अपने प्रोजेक्ट में, Google Auth Platform की खास जानकारी के लिए, Google Cloud Console का डायरेक्ट यूआरएल प्रिंट करें:

# print google auth platform consent screen url
echo "https://console.cloud.google.com/auth/overview?project=${PROJ_ID}"
  1. यूआरएल को अपने ब्राउज़र में खोलें. अगर यह आपके प्रोजेक्ट के लिए पहले से कॉन्फ़िगर नहीं किया गया है, तो शुरू करें पर क्लिक करें.
  2. ऐप्लिकेशन की जानकारी में जाकर, ऐप्लिकेशन का नाम को mcp-sprockets-oauth पर सेट करें. इसके बाद, अपने ईमेल पते (${USER_IDENTITY}) को उपयोगकर्ता सहायता के लिए ईमेल पता के तौर पर चुनें. इसके बाद, आगे बढ़ें पर क्लिक करें.
  3. दर्शक में जाकर, इंटरनल (अगर आपका खाता Google Workspace संगठन का है, तो यह विकल्प चुनें) या बाहरी (अगर निजी खाते का इस्तेमाल किया जा रहा है, तो यह विकल्प चुनें) को चुनें. अगर आपने बाहरी विकल्प चुना है, तो **दर्शक के तौर पर टेस्ट करने वाले उपयोगकर्ता** में जाकर ${USER_IDENTITY} जोड़ें. इसके बाद, आगे बढ़ें पर क्लिक करें.
  4. संपर्क जानकारी में जाकर, अपना ईमेल पता डालें. इसके बाद, नीति से जुड़े समझौते को स्वीकार करें और बनाएं पर क्लिक करें.

2. वेब ऐप्लिकेशन OAuth 2.0 क्लाइंट आईडी बनाना

क्लाइंट पेज के लिए, Google Cloud Console का डायरेक्ट यूआरएल प्रिंट करें:

# print google auth platform clients url
echo "https://console.cloud.google.com/auth/clients?project=${PROJ_ID}"
  1. यूआरएल खोलें और + क्लाइंट बनाएं पर क्लिक करें.
  2. ऐप्लिकेशन टाइप के तौर पर वेब ऐप्लिकेशन चुनें और नाम को ge-mcp-sprockets-client पर सेट करें.
  3. इस क्लाइंट का इस्तेमाल, एआई की मदद से काम करने वाला एजेंट करेगा चेकबॉक्स को चुनें. इससे, एआई एजेंट के उन वर्कफ़्लो के लिए OAuth क्लाइंट तय किया जा सकेगा जो उपयोगकर्ताओं की ओर से काम करते हैं.
  4. अनुमति वाले रीडायरेक्ट यूआरआई में जाकर, + यूआरआई जोड़ें पर क्लिक करें. इसके बाद, Gemini Enterprise OAuth कॉलबैक यूआरआई जोड़ें:
    • https://vertexaisearch.cloud.google.com/oauth-redirect
  5. बनाएं पर क्लिक करें. इसके बाद, जनरेट किए गए क्लाइंट आईडी और क्लाइंट सीक्रेट को कॉपी करें. इसके बाद, इन्हें अपने शेल सेशन में एक्सपोर्ट करें:

पिछले चरण में जनरेट किए गए OAuth 2.0 क्लाइंट आईडी और क्लाइंट सीक्रेट को सेट करें:

# set oauth 2.0 client id (paste in id)
export OAUTH_CLIENT_ID="SET_YOUR_OAUTH_CLIENT_ID_HERE"

# set oauth 2.0 client secret (paste in secret)
export OAUTH_CLIENT_SECRET="SET_YOUR_OAUTH_CLIENT_SECRET_HERE"

देखें कि क्लाइंट आईडी सेट है या नहीं:

# print oauth 2.0 client id
echo "oauth client id: ${OAUTH_CLIENT_ID}"

एजेंट गेटवे से बाइंड करना

Gemini Enterprise से भेजे जाने वाले ट्रैफ़िक को एजेंट गेटवे के ज़रिए रूट करने से, एआई एजेंट टूल के सभी अनुरोधों के लिए, एक ही जगह से नीति लागू करने और स्टैटिक आईपी रूटिंग की सीमा तय करने की सुविधा मिलती है:

  • नीति लागू करने की सुविधा: एजेंट गेटवे, इनलाइन प्रॉक्सी के तौर पर काम करता है. यह एजेंट एनवायरमेंट से ट्रैफ़िक के बाहर जाने से पहले, टूल के आउटबाउंड अनुरोधों का आकलन करता है. इसके लिए, यह अनुमति से जुड़ी नीतियों का इस्तेमाल करता है.
  • डिटरमिनिस्टिक वीपीसी और क्लाउड एनएटी इग्रेस: Gemini Enterprise को vpcEgress: ALL_TRAFFIC के साथ कॉन्फ़िगर किए गए एजेंट गेटवे से बाइंड करने पर, यह पक्का होता है कि टूल कॉल, पीएससी नेटवर्क अटैचमेंट के ज़रिए रूट किए जाएं और आपके रिज़र्व किए गए क्लाउड एनएटी स्टैटिक आईपी का इस्तेमाल करके बाहर निकलें.
  • यूनिफ़ाइड ऑडिट: इससे कनेक्ट किए गए सभी एमसीपी सर्वर के लिए, अनुरोध लॉग करने और ऑडिट ट्रेल की सुविधा एक ही जगह पर मिलती है.

इंजन agentGatewaySetting को पैच करके, इन सुविधाओं को चालू करें:

# bind engine (ge app) to agent gateway
curl -s -X PATCH "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}?updateMask=agentGatewaySetting.defaultEgressAgentGateway.name" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" -H "Content-Type: application/json" \
  -d @- <<EOF
{
  "agentGatewaySetting": {
    "defaultEgressAgentGateway": {
      "name": "${AGW_URI}"
    }
  }
}
EOF

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

agentGatewaySetting बाइंडिंग की पुष्टि करने के लिए, ऐप्लिकेशन का कॉन्फ़िगरेशन वापस पाएं:

# verify engine (ge app) agent gateway configuration
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  | jq '{name: .name, displayName: .displayName, agentGatewaySetting: .agentGatewaySetting}'

आउटपुट का उदाहरण:

{
  "name": "projects/[PROJ_NO]/locations/global/collections/default_collection/engines/app-foo-global_[EPOCH]",
  "displayName": "foo global app",
  "agentGatewaySetting": {
    "defaultEgressAgentGateway": {
      "name": "projects/[PROJ_ID]/locations/us-central1/agentGateways/agw-foo-us-central1-ata"
    }
  }
}

कस्टम एमसीपी सर्वर डेटा स्टोर बनाना

इस सेक्शन में, आपको mcp-sprockets सर्वर को Gemini Enterprise से कनेक्ट करना होगा. इसके लिए, Google Identity (https://accounts.google.com/o/oauth2/v2/auth और https://oauth2.googleapis.com/token) के साथ कॉन्फ़िगर किया गया OAuth 2.0 कस्टम एमसीपी डेटा स्टोर बनाना होगा.

Discovery Engine API का इस्तेमाल करके, इस प्रोसेस को दो चरणों में पूरा किया जा सकता है:

  1. बनाएं (:setUpDataConnector): यह Collection संसाधन (${MCP_NAME}-collection-%timestamp) बनाता है, DataConnector (custom_mcp) को auth_type: "OAUTH" से जोड़ता है, और इसके बैकअप DataStore (..._mcp_data) को उपलब्ध कराता है.
  2. चालू करें (PATCH .../dataConnector?updateMask=actionConfig): यह कनेक्टर ऐक्शन रनटाइम (actionState: "ACTIVE") को चालू करता है. इसके लिए, Agent Registry टूल स्पेसिफ़िकेशन और Google Identity OAuth 2.0 पैरामीटर का इस्तेमाल किया जाता है. साथ ही, यह DataStore (dataStoreIds) को आपके Gemini Enterprise Engine से बाइंड करता है.
# fetch mcp server agent registry resource name
export MCP_REGISTRY_URI=$(gcloud agent-registry mcp-servers list \
  --location=${REGION} \
  --project=${PROJ_ID} \
  --filter="displayName:${MCP_DOMAIN}" \
  --format="value(name)")

echo "mcp registry name: ${MCP_REGISTRY_URI}"
echo "mcp url: ${MCP_URL}"

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

# create custom mcp data connector with google identity oauth 2.0 and link to engine
curl -s -X POST "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/${GE_LOCATION}:setUpDataConnector" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
  "collectionId": "${MCP_NAME}-collection-$(date +%s)",
  "collectionDisplayName": "${MCP_NAME}-collection",
  "dataConnector": {
    "dataSource": "custom_mcp",
    "dataSourceVersion": 1,
    "params": {
      "oauth_access_token": "unused"
    },
    "refreshInterval": "86400s",
    "entities": [
      {
        "entityName": "mcp_data"
      }
    ],
    "connectorModes": [
      "FEDERATED"
    ],
    "actionConfig": {
      "isActionConfigured": true,
      "createBapConnection": true,
      "actionParams": {
        "auth_type": "OAUTH",
        "instance_uri": "${MCP_URL}",
        "auth_uri": "https://accounts.google.com/o/oauth2/v2/auth",
        "auth_uri_params": "&access_type=offline&prompt=consent",
        "token_uri": "https://oauth2.googleapis.com/token",
        "client_id": "${OAUTH_CLIENT_ID}",
        "client_secret": "${OAUTH_CLIENT_SECRET}",
        "scopes": "openid email profile",
        "client_secret_basic_override": true,
        "mcp_server_source": "REGISTRY_MCP",
        "registry_mcp_server_name": "${MCP_REGISTRY_URI}",
        "mcp_agent_instructions": "MANDATORY SPROCKETS INVENTORY & CATALOG AGENT: Always invoke get_sprockets or get_sprocket_by_id for any question about sprockets, inventory catalog listings, sprocket IDs (SPK-101 through SPK-105), ANSI models (ANSI-40, ANSI-60, ANSI-80), tooth counts, pitch, material, stock levels, unit prices, authenticated_user, or egress_source_ip verification.",
        "use_agent_gateway_egress": true,
        "agent_gateway_engine": "projects/${PROJ_ID}/locations/global/collections/default_collection/engines/${GE_APP_ID}"
      }
    }
  }
}
EOF

डेटा कनेक्टर बनाने की पुष्टि करना

# fetch collection id
export GE_COLLECTION_ID=$(curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  | jq -r --arg dname "${MCP_NAME}-collection" '.collections[] | select(.displayName == $dname) | .name | split("/") | last' | head -n 1)

echo "ge collection id: ${GE_COLLECTION_ID}"

देखें कि "registry_mcp_server_name" फ़ील्ड में एमसीपी सर्वर के लिए एजेंट रजिस्ट्री का यूयूआईडी मौजूद हो और "auth_type" OAUTH हो:

# show data connector details
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/${GE_COLLECTION_ID}/dataConnector" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  | jq '{name, state, actionState, connectorModes, bapConfig, auth_type: .actionConfig.actionParams.auth_type, registry_mcp_server_name: .actionConfig.actionParams.registry_mcp_server_name}'

Google Cloud Console के यूज़र इंटरफ़ेस (यूआई) में, एमसीपी सर्वर की रजिस्ट्री एंट्री देखें:

echo "mcp server registry page url: https://console.cloud.google.com/agent-platform/agent-registry/mcp-servers/${REGION}/${MCP_REGISTRY_URI##*/}/overview?project=${PROJ_ID}"

डेटा कनेक्टर चालू करना

# activate and bind data connector with google identity oauth 2.0
curl -s -X PATCH "https://discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/global/collections/${GE_COLLECTION_ID}/dataConnector?updateMask=actionConfig" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
  "name": "projects/${PROJ_ID}/locations/global/collections/${GE_COLLECTION_ID}/dataConnector",
  "actionConfig": {
    "isActionConfigured": true,
    "createBapConnection": true,
    "actionParams": {
      "auth_type": "OAUTH",
      "instance_uri": "${MCP_URL}",
      "auth_uri": "https://accounts.google.com/o/oauth2/v2/auth",
      "auth_uri_params": "&access_type=offline&prompt=consent",
      "token_uri": "https://oauth2.googleapis.com/token",
      "client_id": "${OAUTH_CLIENT_ID}",
      "client_secret": "${OAUTH_CLIENT_SECRET}",
      "scopes": "openid email profile",
      "client_secret_basic_override": true,
      "mcp_server_source": "REGISTRY_MCP",
      "registry_mcp_server_name": "${MCP_REGISTRY_URI}",
      "mcp_agent_instructions": "MANDATORY SPROCKETS INVENTORY & CATALOG AGENT: Always invoke get_sprockets or get_sprocket_by_id for any question about sprockets, inventory catalog listings, sprocket IDs (SPK-101 through SPK-105), ANSI models (ANSI-40, ANSI-60, ANSI-80), tooth counts, pitch, material, stock levels, unit prices, authenticated_user, or egress_source_ip verification.",
      "use_agent_gateway_egress": true,
      "agent_gateway_engine": "projects/${PROJ_ID}/locations/global/collections/default_collection/engines/${GE_APP_ID}"
    }
  }
}
EOF

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

# show engine (ge app) details
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  | jq '{name: .name, dataStoreIds: .dataStoreIds, agentGatewaySetting: .agentGatewaySetting}'

लिंक किए गए डेटा स्टोर "dataStoreIds": ["mcp-sprockets-collection-[EPOCH]_mcp_data"] की जांच करें.

# show collection details
curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  | jq --arg app "${GE_APP_ID}" '.collections[] | select(.dataConnector.actionConfig.actionParams.agent_gateway_engine // "" | endswith($app)) | .dataConnector | {name: .name, state: .state, actionState: .actionState, connectorModes: .connectorModes, auth_type: .actionConfig.actionParams.auth_type}'

"state": "ACTIVE" और "auth_type": "OAUTH" देखें.

टूल से जुड़ी कार्रवाइयां

Gemini Enterprise के डैशबोर्ड में mcp-sprockets-collection डेटा स्टोर की जांच करने पर, आपको दिखेगा कि कार्रवाइयां टैब का इस्तेमाल नहीं किया गया है और ↻ कस्टम कार्रवाइयों को फिर से लोड करें बटन बंद है. ऐसा होना सामान्य है.

Google Cloud Console के यूज़र इंटरफ़ेस (यूआई) में, डेटा स्टोर की ज़्यादा जानकारी वाला पेज देखें:

echo "data store details page url: https://console.cloud.google.com/gemini-enterprise/locations/${GE_LOCATION}/collections/${GE_COLLECTION_ID}/connector/details?project=${PROJ_ID}"

कस्टम एमसीपी सर्वर को Gemini Enterprise से कनेक्ट करने के तरीके के आधार पर, टूल डिस्कवरी और गवर्नेंस को इन दो तरीकों में से किसी एक तरीके से मैनेज किया जाता है:

  • डायरेक्ट कस्टम एमसीपी (BYO_MCP वर्कफ़्लो): एजेंट रजिस्ट्री के बिना, Gemini Enterprise में सीधे तौर पर कस्टम एमसीपी सर्वर कॉन्फ़िगर करने पर, डेटा स्टोर खुद टूल कैटलॉग (connectorModes: ["FEDERATED", "ACTIONS"]) को मैनेज करता है. आपको कार्रवाइयां टैब खोलना होगा. इसके बाद, tools/list स्कीमा को फ़ेच करने के लिए, ↻ कस्टम कार्रवाइयां फिर से लोड करें पर क्लिक करना होगा. साथ ही, यूज़र इंटरफ़ेस (यूआई) में अलग-अलग टूल (add और subtract) को मैन्युअल तरीके से चालू या बंद करना होगा.
  • एजेंट रजिस्ट्री से इंपोर्ट करना (REGISTRY_MCP इस कोडलैब में इस्तेमाल किया गया वर्कफ़्लो): एजेंट रजिस्ट्री से एमसीपी सर्वर इंपोर्ट करने पर, एजेंट रजिस्ट्री, एमसीपी एंडपॉइंट, उसके इंटरफ़ेस मेटाडेटा, और उसके टूल कैटलॉग (connectorModes: ["FEDERATED"]) के लिए भरोसेमंद सोर्स के तौर पर काम करती है. Gemini Enterprise, इंजन एजेंट गेटवे सेटिंग के ज़रिए, रनटाइम में रजिस्टर किए गए एमसीपी टूल को अपने-आप चालू कर देता है. इसके लिए, आपको डेटा स्टोर के यूज़र इंटरफ़ेस (यूआई) में जाकर, मैन्युअल तरीके से रिलोड करने या टॉगल करने की ज़रूरत नहीं होती.

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

9. पुष्टि करें

इस सेक्शन में, Google OAuth 2.0 के लिए उपयोगकर्ता की सहमति लेने का फ़्लो एक बार पूरा करें. साथ ही, Gemini Enterprise से बाहरी mcp-sprockets सर्वर पर एमसीपी टूल चालू करें. इसके अलावा, यह पुष्टि करें कि बाहरी एमसीपी सर्वर ने आपके रिज़र्व किए गए Cloud NAT स्टैटिक आईपी (egress_source_ip) और आपकी Google OAuth 2.0 पहचान (authenticated_user), दोनों की पुष्टि की है.

उपयोगकर्ता ऐक्सेस

Gemini Enterprise के वेब ऐप्लिकेशन का यूआरएल बनाएं:

# fetch app user url
export GE_WIDGET_ID=$(curl -s "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}/widgetConfigs/default_search_widget_config" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  -H "Content-Type: application/json" \
  | jq -r '.configId')

export GE_APP_USER_URL="https://vertexaisearch.cloud.google.com/home/cid/${GE_WIDGET_ID}"

echo "app user url: ${GE_APP_USER_URL}"

एजेंट से क्वेरी करने से पहले, आपको OAuth 2.0 की सहमति देने की प्रक्रिया को एक बार पूरा करना होगा. इससे Gemini Enterprise को आपकी Google आइडेंटिटी (${USER_IDENTITY}) के लिए ऐक्सेस टोकन पाने की अनुमति मिल जाती है. इससे Gemini Enterprise, एजेंट गेटवे के ज़रिए टूल के आउटबाउंड कॉल की पुष्टि कर पाता है. इसलिए, बाहरी mcp-sprockets सर्वर हर अनुरोध पर आपकी पहचान की पुष्टि कर सकता है.

  1. अपने ब्राउज़र में ${GE_APP_USER_URL} खोलें और शुरू करें पर क्लिक करें.
  2. चैट बॉक्स में, कनेक्टर आइकॉन (पज़ल पीस आइकॉन) पर क्लिक करें. इसके बाद, mcp-sprockets-collection के बगल में मौजूद अनुमति दें पर क्लिक करें.
  3. एक नई विंडो दिखेगी. इसमें आपको mcp-sprockets-oauth (OAuth के लिए सहमति की स्क्रीन वाले ऐप्लिकेशन का कॉन्फ़िगर किया गया नाम) जारी रखने के लिए खाता चुनने का अनुरोध किया जाएगा. इसके बाद, अपना उपयोगकर्ता खाता (${USER_IDENTITY}) चुनें.
  4. Google OAuth की सहमति वाली स्क्रीन पर, अनुरोध की गई अनुमतियों की समीक्षा करें. इन अनुमतियों से, Google (पहचान की पुष्टि करने वाली सेवा) को आपकी उपयोगकर्ता पहचान (openid, email, profile) को mcp-sprockets-oauth के साथ शेयर करने की अनुमति मिलती है. इसके बाद, जारी रखें पर क्लिक करें.
  5. कनेक्टर आइकॉन पर फिर से क्लिक करें और पुष्टि करें कि mcp-sprockets-collection के लिए टॉगल चालू है. इससे पुष्टि होती है कि अनुमति मिल गई है.

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

Assistant की चैट के यूज़र इंटरफ़ेस से जुड़े टेस्ट

चैट में यह टेस्ट क्वेरी सबमिट करें:

look up sprocket SPK-105 and confirm the model, material, unit_price, authenticated_user, and egress_source_ip

चैट में दूसरी क्वेरी आज़माएँ:

list all sprockets in the inventory catalog and report the authenticated_user and egress_source_ip

पुष्टि करें कि Assistant सही जवाब दे रही हो और इंटरैक्टिव कार्रवाई के उद्धरण वाला बैज दिखा रही हो.

उदाहरण के लिए, हर जवाब के नीचे मौजूद "Sprocket Lookup SPK-105 (5s)एमसीपी टूल का आइकॉनAgent Gatewayसर्कल में सही के निशान वाला आइकॉन" से पता चलता है कि टूल का इस्तेमाल किया गया है.

देखें कि Assistant, स्प्राकेट के स्पेसिफ़िकेशन के साथ-साथ, "authenticated_user" से मेल खाने वाले ${USER_IDENTITY} और आपके रिज़र्व किए गए ${NAT_EXT_IP} से मेल खाने वाले "egress_source_ip" की जानकारी भी दे रही हो.

Assistant streamAssist API की जांच

जब आपका उपयोगकर्ता खाता, OAuth 2.0 कनेक्टर को अनुमति दे देता है, तब default_assistant:streamAssist एपीआई को सीधे तौर पर सीएलआई से भी शुरू किया जा सकता है. साथ ही, यह पुष्टि की जा सकती है कि बाहरी mcp-sprockets सर्वर, आपके Cloud NAT स्टैटिक आईपी (${NAT_EXT_IP}) और पुष्टि की गई Google OAuth 2.0 पहचान (${USER_IDENTITY}) दोनों को दिखाता है:

यह टेस्ट क्वेरी सबमिट करें:

# query engine (ge app) streamAssist
curl -s -X POST "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}/assistants/default_assistant:streamAssist" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r '.[].answer.replies[]?.groundedContent?.content?.text // empty'
{
  "query": {
    "text": "look up sprocket SPK-103 and confirm the model, material, unit_price, authenticated_user, and egress_source_ip"
  },
  "toolsSpec": {
    "vertexAiSearchSpec": {
      "dataStoreSpecs": [
        {
          "dataStore": "projects/${PROJ_NO}/locations/${GE_LOCATION}/collections/default_collection/dataStores/${GE_COLLECTION_ID}_mcp_data"
        }
      ]
    }
  }
}
EOF

आउटपुट का उदाहरण:

Here are the details for sprocket SPK-103 from the inventory catalog:
- Model: ANSI-60-16T
- Material: 304 Stainless Steel
- Unit Price: $42.00
- Authenticated User (Google OAuth 2.0): user@example.com
- Egress Source IP (Cloud NAT): 203.0.113.10

कोई दूसरी क्वेरी डालकर देखें:

# query engine (ge app) streamAssist
curl -s -X POST "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}/assistants/default_assistant:streamAssist" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r '.[].answer.replies[]?.groundedContent?.content?.text // empty'
{
  "query": {
    "text": "find a sprocket model i can get for under \$20 and report the details, authenticated_user, and egress_source_ip"
  },
  "toolsSpec": {
    "vertexAiSearchSpec": {
      "dataStoreSpecs": [
        {
          "dataStore": "projects/${PROJ_NO}/locations/${GE_LOCATION}/collections/default_collection/dataStores/${GE_COLLECTION_ID}_mcp_data"
        }
      ]
    }
  }
}
EOF

Cloud Logging में लॉग की जांच करना

पुष्टि करें कि Gemini Enterprise ने टूल कॉल को Agent Gateway, PSC नेटवर्क अटैचमेंट, और Cloud NAT के ज़रिए रूट किया है. इसके लिए, Cloud Logging में लॉग की जांच करें.

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

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

# show agent gateway logs
gcloud logging read \
  "resource.type=networkservices.googleapis.com/Gateway
   AND resource.labels.location=${REGION}" \
  --project=${PROJ_ID} \
  --limit=8 \
  --format="table(
    timestamp.date('', tz=LOCAL):label=TIMESTAMP,
    httpRequest.status:label=STATUS,
    httpRequest.serverIp:label=SERVER_IP,
    jsonPayload.agentGatewayInfo.mcpInfo.method:label=MCP_METHOD,
    jsonPayload.agentGatewayInfo.mcpInfo.parameter:label=TOOL,
    jsonPayload.authzPolicyInfo.result:label=AUTHZ,
    jsonPayload.agentGatewayInfo.agentRegistryResource.basename():label=REGISTRY_MCP
  )"

आउटपुट का उदाहरण:

TIMESTAMP                STATUS  SERVER_IP         MCP_METHOD                 TOOL                AUTHZ    REGISTRY_MCP
YYYY-MM-DDTHH:MM:SS.ZZZ  200     203.0.113.20:443  tools/call                 get_sprocket_by_id  ALLOWED  agentregistry-00000000-0000-0000-5c39-1f6e542bb2b8
YYYY-MM-DDTHH:MM:SS.ZZZ  200     203.0.113.20:443  tools/list                                     ALLOWED  agentregistry-00000000-0000-0000-5c39-1f6e542bb2b8
YYYY-MM-DDTHH:MM:SS.ZZZ  202     203.0.113.20:443  notifications/initialized                      ALLOWED  agentregistry-00000000-0000-0000-5c39-1f6e542bb2b8
YYYY-MM-DDTHH:MM:SS.ZZZ  200     203.0.113.20:443  initialize                                     ALLOWED  agentregistry-00000000-0000-0000-5c39-1f6e542bb2b8

पुष्टि करें कि आउटपुट में ये शामिल हैं:

  • STATUS: 200 (सफल तरीके से लागू किया गया) और 202 (notifications/initialized हैंडशेक).
  • SERVER_IP: बाहरी एमसीपी सर्वर का आईपी और पोर्ट (${MCP_EXT_IP}:443).
  • MCP_METHOD & TOOL: एमसीपी प्रोटोकॉल सीक्वेंस (initialize, notifications/initialized, tools/list, और tools/call के साथ get_sprocket_by_id).
  • AUTHZ: ALLOWED (आईएपी की अनुमति वाले इग्रेस की अनुमति है).
  • REGISTRY_MCP: एजेंट रजिस्ट्री के संसाधन का हल किया गया आईडी (agentregistry-...).

Cloud NAT के लॉग की पुष्टि करना

पुष्टि करें कि ${MCP_EXT_IP}:443 से कनेक्ट करते समय, Cloud NAT ने एजेंट गेटवे पीएससी नेटवर्क अटैचमेंट आईपी (10.10.10.2) से आउटबाउंड कनेक्शन को आपके रिज़र्व किए गए स्टैटिक बाहरी IPv4 पते (${NAT_EXT_IP}) में बदल दिया है:

# show cloud nat logs
gcloud logging read \
  "resource.type=nat_gateway
   AND resource.labels.gateway_name=nat-${SLUG}-${REGION}
   AND jsonPayload.connection.dest_ip=${MCP_EXT_IP}" \
  --project=${PROJ_ID} \
  --limit=8 \
  --format="table(
    timestamp.date('', tz=LOCAL):label=TIMESTAMP,
    jsonPayload.allocation_status:label=ALLOCATION_STATUS,
    jsonPayload.connection.src_ip:label=SRC_IP,
    jsonPayload.connection.nat_ip:label=NAT_IP,
    jsonPayload.connection.dest_ip:label=DEST_IP,
    jsonPayload.connection.dest_port:label=PORT
  )"

आउटपुट का उदाहरण:

TIMESTAMP                ALLOCATION_STATUS  SRC_IP      NAT_IP        DEST_IP       PORT
YYYY-MM-DDTHH:MM:SS.ZZZ  OK                 10.10.10.2  203.0.113.10  203.0.113.20  443

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

पुष्टि करें कि इंटरनल फ़ायरवॉल नीति (fw-policy-${SLUG}-internal) ने एजेंट गेटवे से इंटरनेट डेस्टिनेशन तक इग्रेस डेटा ट्रैफ़िक को अनुमति दी हो:

# show firewall policy logs (internal)
gcloud logging read \
  "logName:compute.googleapis.com%2Ffirewall
   AND jsonPayload.rule_details.reference:fw-policy-${SLUG}-internal" \
  --project=${PROJ_ID} \
  --limit=8 \
  --format="table(
    timestamp.date('', tz=LOCAL):label=TIMESTAMP,
    jsonPayload.connection.src_ip:label=SRC_IP,
    jsonPayload.connection.dest_ip:label=DEST_IP,
    jsonPayload.connection.dest_port:label=PORT,
    jsonPayload.vpc.vpc_name:label=VPC_NETWORK,
    jsonPayload.rule_details.reference.basename():label=POLICY,
    jsonPayload.rule_details.priority:label=RULE,
    jsonPayload.rule_details.direction:label=DIRECTION,
    jsonPayload.disposition:label=DISPOSITION
  )"

पुष्टि करें कि बाहरी फ़ायरवॉल नीति (fw-policy-${SLUG}-external) ने, इंटरनल नेटवर्क के सार्वजनिक NAT आईपी पते से एमसीपी सर्वर तक इंग्रेस ट्रैफ़िक को अनुमति दी हो:

# show firewall policy logs (external)
gcloud logging read \
  "logName:compute.googleapis.com%2Ffirewall
   AND jsonPayload.rule_details.reference:fw-policy-${SLUG}-external" \
  --project=${PROJ_ID} \
  --limit=8 \
  --format="table(
    timestamp.date('', tz=LOCAL):label=TIMESTAMP,
    jsonPayload.connection.src_ip:label=SRC_IP,
    jsonPayload.connection.dest_ip:label=DEST_IP,
    jsonPayload.connection.dest_port:label=PORT,
    jsonPayload.vpc.vpc_name:label=VPC_NETWORK,
    jsonPayload.rule_details.reference.basename():label=POLICY,
    jsonPayload.rule_details.priority:label=RULE,
    jsonPayload.rule_details.direction:label=DIRECTION,
    jsonPayload.disposition:label=DISPOSITION
  )"

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

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

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

Gemini Enterprise के कॉम्पोनेंट हटाना

# delete gemini enterprise engine (app)
curl -s -X DELETE "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/default_collection/engines/${GE_APP_ID}" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}"

# delete custom mcp collection, data connector, and backing data store
curl -s -X DELETE "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJ_ID}/locations/${GE_LOCATION}/collections/${GE_COLLECTION_ID}" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}"

# reset identity provider configuration
curl -s -X PATCH "https://${GE_LOCATION}-discoveryengine.googleapis.com/v1/projects/${PROJ_ID}/locations/${GE_LOCATION}/aclConfig" \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "X-Goog-User-Project: ${PROJ_ID}" \
  -H "Content-Type: application/json" \
  -d '{"idpConfig":{"idpType":"IDP_TYPE_UNSPECIFIED"}}'

OAuth 2.0 क्लाइंट क्रेडेंशियल (ge-mcp-sprockets-client) हटाने के लिए, Google Auth Platform Clients पेज खोलें. इसके बाद, ge-mcp-sprockets-client के बगल में मौजूद मिटाएं (ट्रैश कैन) आइकॉन पर क्लिक करें:

# print google auth platform clients url
echo "https://console.cloud.google.com/auth/clients?project=${PROJ_ID}"

एमसीपी सर्वर और एजेंट रजिस्ट्री कॉम्पोनेंट हटाना

# delete external mcp server vm
gcloud -q compute instances delete vm-${MCP_NAME} --zone=${ZONE}

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

# delete agent registry oauth2 endpoint
gcloud -q agent-registry services delete oauth2-googleapis --location=${REGION}

एजेंट गेटवे के कॉम्पोनेंट हटाना

# delete gateway authz policy and iap service extension
gcloud -q network-security authz-policies delete ${AGW_NAME}-authz-policy-iap \
  --location=${REGION}

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

# delete agent gateway and connectivity template
gcloud -q network-services agent-gateways delete ${AGW_NAME} \
  --location=${REGION}

gcloud -q network-services agent-connectivity-templates delete act-${AGW_NAME} \
  --location=${REGION}

# delete iam unified access policy binding and access policy
gcloud -q iam policy-bindings delete uap-bind-${SLUG} \
  --location=global \
  --project=${PROJ_ID}

gcloud -q iam access-policies delete uap-policy-${SLUG} \
  --location=global \
  --project=${PROJ_ID}

फ़ायरवॉल कॉम्पोनेंट हटाना

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

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

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

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

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

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

नेटवर्क कॉम्पोनेंट हटाना

# delete cloud nat gateway and cloud router
gcloud -q compute routers nats delete nat-${SLUG}-${REGION} \
  --router=cr-nat-${SLUG}-${REGION} \
  --region=${REGION}

gcloud -q compute routers delete cr-nat-${SLUG}-${REGION} \
  --region=${REGION}

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

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

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

# delete reserved static external ip addresses
gcloud -q compute addresses delete ip-${SLUG}-nat ip-${SLUG}-mcp \
  --region=${REGION}

# delete internal and external vpc networks
gcloud -q compute networks delete \
  vnet-${SLUG}-internal \
  vnet-${SLUG}-external

संगठन की नीति के उल्लंघन और स्थानीय फ़ाइलों को हटाना

# delete project-level organization policy overrides
for policy in \
  discoveryengine.managed.disableCustomMcpServerConnector \
  discoveryengine.managed.allowedEgressFqdns \
  discoveryengine.managed.allowedDataSources \
  iam.managed.disableAccessPolicyBinding \
  compute.vmExternalIpAccess; do
  gcloud -q org-policies delete ${policy} --project=${PROJ_ID} 2>/dev/null || true
done

# remove local project files
rm -rf cfg

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

11. नतीजा

बधाई हो! आपने एक ऐसा एंड-टू-एंड आर्किटेक्चर बनाया है जो Gemini Enterprise ऐप्लिकेशन को, बाहरी आईपी पते की अनुमति वाली सूची में शामिल और OAuth 2.0 से सुरक्षित कस्टम एमसीपी सर्वर पर टूल को सुरक्षित तरीके से ढूंढने और उन्हें चालू करने की सुविधा देता है:

  • स्टैटिक आईपी वीपीसी इग्रेस (ALL_TRAFFIC और Cloud NAT): इसमें, एजेंट गेटवे से बाहर जाने वाले सभी ट्रैफ़िक को पीएससी नेटवर्क अटैचमेंट (10.10.10.2) के ज़रिए रूट किया जाता है. साथ ही, इंटरनेट से जुड़े अनुरोधों को Cloud NAT का इस्तेमाल करके, रिज़र्व किए गए स्टैटिक बाहरी IPv4 पते (${NAT_EXT_IP}) में बदला जाता है.
  • OAuth 2.0 एमसीपी रिसॉर्स सर्वर और एजेंट रजिस्ट्री: बाहरी स्ट्रीम किए जा सकने वाले एचटीटीपी FastMCP सर्वर (mcp-sprockets) को डिप्लॉय किया गया है. इसे सोर्स आईपी फ़ायरवॉल की सख्त अनुमति वाली सूची (${NAT_EXT_IP}/32) और Google OAuth 2.0 tokeninfo की पुष्टि से सुरक्षित किया गया है. साथ ही, इसके एंडपॉइंट और टूल स्कीमा (get_sprockets और get_sprocket_by_id) को एजेंट रजिस्ट्री में रजिस्टर किया गया है.
  • Gemini Enterprise के साथ OAuth 2.0 इंटिग्रेशन और गवर्नेंस: Gemini Enterprise ऐप्लिकेशन उपलब्ध कराया गया, आउटबाउंड टूल के ट्रैफ़िक को Agent Gateway से बाइंड किया गया, रजिस्टर किए गए एमसीपी सर्वर को OAuth 2.0 REGISTRY_MCP डेटा कनेक्टर के तौर पर अटैच किया गया, और Cloud Logging टेलीमेट्री के साथ-साथ egress_source_ip और authenticated_user, दोनों की पुष्टि की गई.

cosmopup

Cosmopup को Codelabs बहुत पसंद हैं!

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

इस सुझाव/राय देने या शिकायत करने वाले फ़ॉर्म का इस्तेमाल करके, बेझिझक टिप्पणियां करें, सवाल पूछें या सुधार के बारे में बताएं.

धन्यवाद!