Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

יציאה מ-Agent Gateway מ-Agent Runtime ל-MCP חיצוני

1. מבוא

ב-Codelab הזה נסביר על ניהול תעבורת נתונים יוצאת (egress) בAgent Gateway לסוכני AI שגולשים לשרתים חיצוניים של Model Context Protocol‏ (MCP) שמארחים מחוץ ל-Google Cloud.

אפליקציות מבוססות-AI, מצ'אטבוטים עצמאיים ועד מערכות אוטונומיות עם תהליכי עבודה מרובי-סוכנים, יכולות להפעיל באופן דינמי כלים חיצוניים. כדי להבטיח שהסוכנים יהיו בטוחים ויעילים, חשוב לספק להם גישה מבוקרת לשאילתות במסדי נתונים, לאחזור תוכן אינטרנט ולביצוע פעולות. עם זאת, בסביבות ארגוניות, אבטחת ההרצה של כלי הסוכן היא אתגר. אם לסוכן יש גישה ישירה לרשת, מתקפות שבהן מחדירים הנחיות או הזיות של מודלים יכולות לגרום לסוכן לחלץ מידע אישי רגיש או להריץ פקודות הרסניות.

כדי לנהל סוכנים אוטונומיים בהיקפים גדולים, Agent Gateway מספק נקודת אכיפה מרכזית של אפס אמון שמשולבת ישירות בארכיטקטורה של Agent Platform. במקום להסתמך על הטמעות מותאמות אישית שייחודיות לכל אפליקציה או קוד סוכן, Agent Gateway מספק ניתוב ברשת, ניהול סוכנים ואבטחת זמן ריצה שנאכפים ברמת הפלטפורמה.

כש-Agent Gateway פועל במצב יציאה (agent-to-anywhere), הוא משמש כשרת proxy לכל הבקשות היוצאות מסוכנים שהוגדרו לשימוש בשער. כל בקשה לעומס עבודה של סוכן מאומתת באמצעות זהות הסוכן הייחודית ומקבלת הרשאה באמצעות כללי מדיניות של שרת proxy לאימות זהויות (IAP). הקריאות לכלי ה-MCP מפוענחות ונבדקות באופן דינמי לצורך אכיפת המדיניות. אדמינים של אבטחה יכולים לאכוף הרשאות ברמת פירוט גבוהה באופן מרכזי, כדי לוודא שהסוכנים יכולים להפעיל רק נקודות קצה ושיטות שאושרו.

מה תפַתחו

Agent Gateway ביציאה (מצב agent-to-anywhere)
תוסף הרשאות של שרת proxy לאימות זהויות (IAP)
סוכן ADK של Agent Runtime עם זהות סוכן
Agent Registry עם Google API ונקודות קצה של MCP
קישוריות של כלי MCP חיצוניים למערכי נתונים ציבוריים של Data Commons
כללי מדיניות של הרשאות עם בקרת גישה של IAM

איור 1. ארכיטקטורת Codelab

מה לומדים

איך פורסים את Agent Gateway ברצף מובנה של הגדרות
איך מעבירים כללי מדיניות הרשאה ממצב הרצת בדיקה למצב אכיפה
איך רושמים נקודות קצה של Google API ושרתי MCP ב-Agent Registry
איך משתמשים במדיניות הרשאות מותנית שמבוססת על מאפייני פרוטוקול MCP
איך בודקים את היומנים של Agent Gateway כדי לאמת את ניהול תעבורת נתונים יוצאת (egress)

מה צריך

פרויקט ב-Google Cloud שהחיוב בו מופעל
הרשאות IAM להקצאת משאבים של שירותי רשת ושל Agent Platform
מעטפת תואמת POSIX‏ (bash או zsh) עם Google Cloud CLI (רכיבי gcloud ו-bq) מותקן
כלי שורת פקודה: git,‏ curl,‏ jq (מעבד JSON),‏ Python 3 ו-uv (מנהל חבילות Python)
מפתח API חינמי של Data Commons לגישה למערכי נתונים של שאילתות לבדיקה

2. מושגים

רצף הפריסה

ב-Codelab הזה יש רצף מובנה של הגדרות, כדי שהסוכנים יוכלו לגשת למשאבים הנדרשים בזמן האתחול, ויהיה אפשר לאשר את הקישוריות לפני שמחילים מדיניות גישה מחייבת.

בשיעור Codelab הזה נשתמש ברצף הפריסה הבא:

התחלה במצב DRY_RUN: מוודאים שהבקשות של הסוכן מגיעות לשער ועוברות דרכו (מצב ביקורת בלבד).
רישום כל השירותים: רישום כל רכיבי הסוכן במרשם הסוכנים ואישור הגישה לכלי הסוכן.
יצירת מדיניות הרשאות: יוצרים ומחילים מדיניות הרשאות כדי לאפשר תנועת יציאה מסוכנים לשרתים ולנקודות קצה של MCP.
מעבר למצב ENFORCED: עדכון המדיניות של תוסף ההרשאה כדי לאכוף את המדיניות ולחסום תעבורת נתונים יוצאת לא מורשית.

איור 2. רצף הפריסה

טופולוגיית ניתוב של תעבורת נתונים יוצאת (egress)

יציאה (egress) מ-Agent Gateway‏ (agent-to-anywhere) פועלת כפרוקסי יוצא מרכזי עם גישת אפס אמון לעומסי עבודה של סוכנים. כשסוכן שולח בקשה לכלי חיצוני או ל-API, בקשת היציאה נחטפת על ידי Agent Gateway ונבדקת בהתאם למדיניות השליטה לפני שהיא מנותבת ליעד שלה. בארכיטקטורה של פלטפורמת סוכנים ב-Google Cloud, שער הסוכנים מספק קישוריות של מישור הנתונים אל:

רשתות פרטיות (VPC): תעבורה יוצאת שמיועדת לממשקי API פנימיים של ארגונים, למיקרו-שירותים, למסדי נתונים שמתארחים ב-VPC פרטי ולרשתות מקומיות או חוצות ענן שאפשר להגיע אליהן באמצעות קישוריות היברידית.
רשתות חיצוניות (אינטרנט): תעבורת נתונים יוצאת שמכוונת לשירותי אינטרנט של צד שלישי, לממשקי API של SaaS או לנקודות קצה ציבוריות.
שירותי AI ו-Agent Platform: תעבורה יוצאת שמכוונת לממשקי Google Cloud API מנוהלים, למודלים בסיסיים, לנקודות קצה של Google MCP (כמו BigQuery) ולשירותי ניהול פלטפורמה (מאגר סוכנים ומדיניות IAP).

איור 3. טופולוגיית ניתוב יוצאת של Agent Gateway

המיקוד של ה-Codelab הזה הוא בתעבורת נתונים יוצאת מסוכן מותאם אישית ב-Agent Runtime שמכוונת לנקודת קצה של שרת MCP חיצוני של צד שלישי שאפשר לגשת אליה דרך האינטרנט.

בדיקה של פרוטוקול ה-MCP

היציאה של Agent Gateway (agent-to-anywhere) יכולה לנתח את התוכן של בקשות MCP ולהעריך מדיניות גישה על סמך מאפייני פרוטוקול ברמת פירוט גבוהה. מדיניות יציאה (egress) משרת MCP לסוכן יכולה לכלול תנאים, שמבוטאים ב-Common Expression Language ‏(CEL), שנאכפים בזמן הריצה בכל בקשה.

בדרך כלל, קריאות MCP משתמשות בפורמט פרוטוקול JSON-RPC וב-HTTP transport. הפרטים של שיטת ה-MCP שמופעלת (לדוגמה, tools/call), שם כלי היעד וכל הארגומנטים כלולים במטען הייעודי (payload) בפורמט JSON בגוף ה-HTTP.

המאפיין iap.googleapis.com/mcp.toolName מחולץ על ידי Agent Gateway על ידי ניתוח גוף ה-JSON כדי למצוא את מזהה הכלי שצוין בבקשה.

בדרך כלל לא נשלחים מאפיינים כמו iap.googleapis.com/mcp.tool.isReadOnly ו-mcp.tool.isDestructive בגוף של כל בקשה. במקום זאת, אלה הערות (מטא-נתונים) שמשויכות לכלי. לכן, כש-Agent Gateway מחלץ את toolName מהגוף, הוא מחפש את הגדרת הכלי ואת המאפיינים המשויכים מ-Agent Registry, שבו נרשם התוכן toolspec.json.

איור 4. בדיקת MCP של Agent Gateway

ביטויי CEL שמשמשים בתנאי IAM של IAP משתמשים בפורמט הרגיל api.getAttribute('iap.googleapis.com/ATTRIBUTE_NAME', 'DEFAULT_VALUE')== 'DESIRED_VALUE'.

בטבלה הזו מפורטים מאפייני ניהול היציאה של Agent Gateway שאפשר להחיל על בקשות של שרת MCP:

מאפיין	שיטה או מיקום של MCP	תיאור
`mcp.toolName`	`tools/call` (גוף)	מזהה כלי היעד שנדרש במטען הייעודי (payload) של ה-RPC (לדוגמה, `"delete_instance"`)
`mcp.tool.isReadOnly`	Agent Registry (`toolspec.json`)	מציין אם הכלי הוא לקריאה בלבד (לא משנה את הסביבה שלו)
`mcp.tool.isDestructive`	Agent Registry (`toolspec.json`)	מציין אם הפעלת הכלי עלולה לגרום לשינויים בלתי הפיכים או לאובדן נתונים
`mcp.tool.isIdempotent`	Agent Registry (`toolspec.json`)	מציין אם הפעלה חוזרת של הכלי עם אותם ארגומנטים יוצרת את אותו מצב בדיוק
`mcp.tool.isOpenWorld`	Agent Registry (`toolspec.json`)	מציין אם הכלי מגיע מעבר למערכות פנימיות מוגבלות לאינטרנט הציבורי הלא מוגבל

סיימנו את החלק של ההסברים... עכשיו נעבור לקטע הגדרה.

3. הגדרה

התפקידים שצריך ב-IAM

כדי ליצור את המשאבים ב-Codelab הזה, צריך את התפקידים הבאים:

קטגוריה	תפקיד IAM נדרש (מזהה)	תיאור
ניהול API	`roles/serviceusage.serviceUsageAdmin`	הפעלת שירותי Google Cloud API
נטוורקינג ושער	`roles/networkservices.admin`	הקצאת Agent Gateway
תוספים לשירותים	`roles/serviceextensions.admin`	הגדרת תוספי ניתוב
אבטחת רשתות	`roles/networksecurity.admin`	פריסת מדיניות הרשאות
Agent Registry	`roles/agentregistry.admin`	מארחים מורשים בקטלוג
‫Vertex AI וסוכנים	`roles/aiplatform.admin`	פריסת עומסי עבודה של Agent Runtime
מדיניות לגבי תעבורת נתונים יוצאת (egress)	`roles/iap.admin`	החלת מדיניות `roles/iap.egressor`
Cloud Storage	`roles/storage.admin`	ניהול של קטגוריות אחסון של פריסות בשלב ההכנה
יומנים וביקורת	`roles/logging.viewer`	בדיקת עקבות ויומני ביקורת

אפשר גם להשתמש בתפקיד בסיסי רחב כמו roles/admin או בתפקיד מדור קודם כמו roles/owner.

גישה לפרויקט

בשיעור Codelab הזה משתמשים בפרויקט אחד ב-Google Cloud. בשלבי ההגדרה נעשה שימוש בפקודות של gcloud CLI ושל מעטפת Linux.

כדי להתחיל, ניגשים לשורת הפקודה של הפרויקט בענן ב-Google Cloud:

‫Cloud Shell בכתובת shell.cloud.google.com, או
מסוף מקומי עם gcloud CLI מותקן

הגדרת מזהה הפרויקט

gcloud config set project SET_YOUR_PROJECT_ID_HERE

אימות הסשן

# login to gcloud cli
gcloud auth login

# login for gcloud api
gcloud auth application-default login

הגדרת סביבת מעטפת

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

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

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

# create local dir for config files
mkdir -p cfg

עדכון `gcloud cli` (מומלץ)

אם אתם מריצים התקנה בניהול עצמי של Google Cloud SDK (כלומר, מחוץ ל-Cloud Shell), אתם צריכים לעדכן את הרכיבים לגרסה האחרונה.

# update gcloud cli
gcloud components update

הפעלת שירותי API

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

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

כאן מסתיים החלק של ההגדרה… עכשיו נעבור לקטע שער.

4. שער

לפני שמפעילים את בקרת הגישה, צריך לפרוס את Agent Gateway ולהגדיר את תוסף ההרשאה שלו במצב DRY_RUN. כך אפשר להוציא שיחות עם כלים בהצלחה, תוך רישום תוצאות ההערכה למטרות ביקורת.

במקרה הזה, Agent Gateway משתמש במאגר אזורי כדי לתמוך במשאבי Agent Runtime אזוריים.

יצירת שער

# create agent gateway config file (regional registry)
cat > cfg/${AGW_NAME}.yaml << EOF
name: ${AGW_NAME}
protocols:
  - MCP
googleManaged:
  governedAccessPath: AGENT_TO_ANYWHERE
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}

# show agent gateway details (verify deployment state)
gcloud network-services agent-gateways describe ${AGW_NAME} \
  --location=${REGION}

כאן מסתיים החלק שקשור לשער... עכשיו נעבור לקטע הרשאה.

5. אישור

תוסף ההרשאה של Agent Gateway לשרת proxy לאימות זהויות (IAP) הוא סוג של תוסף שירות שמשמש להעברת החלטות הרשאה לכל התקשורת של Agent Platform.

תהליך ההעברה: כשסוכן מנסה להפעיל נקודת קצה חיצונית או שרת MCP, הוא מנתב את הבקשה ל-Agent Gateway. במקום להעריך את הגישה באופן מקומי, שער הגישה משתמש בתוסף ההרשאות כדי לשלוח Callout לשירות ההערכה של IAP. ‫IAP מעריך את זהות הסוכן (מבוססת SPIFFE) בהשוואה למדיניות IAM של משאב היעד ב-Agent Registry. ‫IAP מחזיר החלטה ALLOW או DENY לשער, שמעביר את התנועה הלאה או חוסם אותה עם קוד סטטוס HTTP‏ 403 Forbidden.
מצבי אכיפה: במצב DRY_RUN, ‏ IAP מעריך בקשות ומתעד החלטות ב-Cloud Logging בלי לחסום תנועה. במצב ENFORCE, כל בקשה מסוכן לא מורשה או ליעד לא רשום נחסמת באופן מיידי.
שכבת הקישור: תוסף השירות מקושר ל-Agent Gateway באמצעות מדיניות הרשאות שהוגדרה עם פרופיל REQUEST_AUTHZ.

תוסף הרשאה

יצירת תוסף הרשאה

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

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

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

מדיניות הרשאה

מדיניות הרשאות מקשרת את ספק האבטחה (IAP) למשאב שער היעד ומציינת את פרופיל היירוט (REQUEST_AUTHZ).

יצירת מדיניות הרשאות

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

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

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

כאן מסתיים החלק של ההרשאה… עכשיו עוברים לקטע Codebase.

6. בסיס קוד

קוד הסוכן וסקריפט הרישום של נקודת הקצה שמשמשים בשיעור Codelab הזה מתעדכנים במאגר GitHub מרוחק של Google Cloud. בשלבים הבאים יבוצע שיבוט של המאגר באופן מקומי, העתקה של הקבצים הנדרשים למבנה של ספריית העבודה הנוכחית, ולאחר מכן ניקוי של קבצים זמניים.

נוצרת קטגוריית אחסון זמנית כדי ש-Agent Runtime יוכל להעלות, ליצור ולפרוס את קוד האפליקציה של הסוכן ואת פריטי המידע שנוצרו בתהליך פיתוח (artifacts) של יחסי התלות שלו.

אחזור פריטי מידע שנוצרים בתהליך פיתוח (Artifact) מרחוק

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

# copy agent runtime and endpoint definitions to working project dir
cp -r temp_agw_cuj_arun_egress_emcp/codelabs/agw-cuj-arun-egress-emcp/agent-datacommons ./agent-datacommons
cp -r temp_agw_cuj_arun_egress_emcp/codelabs/agw-cuj-arun-egress-emcp/endpoints ./endpoints

# remove temporary directory
rm -rf temp_agw_cuj_arun_egress_emcp

יצירת קטגוריית אחסון זמנית

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

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

כאן מסתיים החלק של בסיס הקוד... עכשיו נעבור לקטע Registry (מאגר).

7. מרשם

‫Agent Registry הוא מלאי מרכזי של כל הסוכנים, שרתי ה-MCP ונקודות הקצה (ממשקי ה-API) במערכת האקולוגית של ה-AI. הוא גם קטלוג שאפשר להשתמש בו כדי לרשום, לחפש ולגלות כלים ושירותים רשומים אחרים לשימוש באפליקציות AI. מצב יציאה של Agent Gateway (agent-to-anywhere) משתמש במודל הנתונים של המרשם כמסגרת הממשל לאכיפת בקרת גישה ליציאה. ההרשאות של תפקיד ה-IAM שניתנות לסוכני חשבונות משתמשים מתבצעות בהתאם למדיניות שקשורה למשאב של המאגר.

כדי לאתחל את הסביבה ולתמוך בסוכנים באמצעות Google APIs ושירותים שונים, נעשה שימוש בסקריפט כדי לרשום במהירות קבוצה משותפת של נקודות קצה של API באמצעות שמות מארחים ומיקומים מ-endpoints/googleapis.txt.

רישום נקודות קצה

# run python script to register google api endpoints
python3 endpoints/register_endpoints.py \
  --multi-region=${MREGION} \
  --region=${REGION} \
  --mtls-endpoints=include

אימות של נקודות קצה

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

עד כאן בנושא הרישום... עכשיו נעבור לקטע Data Commons.

8. Data Commons

‫Data Commons הוא יוזמה של Google לארגון של מערכי נתונים ציבוריים ולהנגשתם לכולם. זהו שירות חינמי שאפשר לגשת אליו באמצעות מפתח API אחרי יצירת חשבון.

יצירת מפתח API

אחרי שיוצרים חשבון, מבצעים את השלבים הבאים כדי לקבל מפתח API:

כניסה ל-API Portal של Data Commons
לוחצים על הלחצן האפליקציות שלי בפינה השמאלית העליונה.
לוחצים על הלחצן + אפליקציה חדשה בפינה השמאלית העליונה מתחת לשם המשתמש.
נותנים לאפליקציה שם (לדוגמה, Codelab Agent MCP).
לוחצים על הכפתור ENABLE (הפעלה) של Data Commons API. api.datacommons.org
לוחצים על הלחצן שמירה בפינה השמאלית התחתונה.

המערכת תיצור מפתח API וסוד. לוחצים על סמל ההעתקה לצד ערך המפתח כדי להעתיק את מפתח ה-API. מדביקים את הערך בפקודת הטרמינל כדי להגדיר את משתנה הסביבה DC_API_KEY.

# set api key env var
 export DC_API_KEY="YOUR_API_KEY_HERE"

יצירת שרת MCP `toolspec`

כשרושמים שרת MCP באופן ידני, צריך לכלול קובץ הגדרות של כלי במהלך הרישום. העלאה של קובץ toolspec.json מציגה רשימה של כל הכלים שזמינים בנקודת הקצה ומאפשרת למשתמשים אחרים לגלות אותם.

הסקריפט test_mcp.py, שכלול בבסיס הקוד agent-datacommons/, יוצר קובץ toolspec.json על ידי התחברות לשרת ה-MCP של היעד (דרך SSE או HTTP) וקורא ל-list_tools() כדי לאחזר את כל הכלים הזמינים שהשרת חושף.

# generate toolspec for registry ingestion
uv --directory agent-datacommons run python3 test_mcp.py --toolspec=include --token="${DC_API_KEY}"

בפלט toolspec שנוצר אפשר לראות את מאפייני ה-MCP ש-Agent Gateway יכול להשתמש בהם להערכה ולאכיפה של מדיניות יציאה.

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

רישום שרת MCP

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

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

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

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

כאן מסתיים החלק של Data Commons… ועכשיו נעבור לקטע Runtime.

9. זמן ריצה

סוכן agent-datacommons ADK שנפרס ב-Agent Runtime מוגדר עם ההגדרות הבאות בסקריפט הפריסה כדי להשתלב עם Agent Platform:

‫"identity_type": types.IdentityType.AGENT_IDENTITY כדי להקצות לסוכן זהות ייחודית של חשבון ראשי שמבוססת על SPIFFE
‫"agent_gateway_config": { "agent_to_anywhere_config": {"agent_gateway": } } כדי להפנות את כל התנועה היוצאת שנוצרת על ידי סוכנים אל Agent Gateway לצורך הערכה ואכיפה של מדיניות

פריסת הסוכן

# deploy agent runtime workload
uv --directory agent-datacommons run python3 deploy_agent.py \
  --project=${PROJ_ID} \
  --region=${REGION} \
  --src-dir=./agent \
  --staging-bucket=${STAGING_BUCKET} \
  --display-name="${RE_AGENT_NAME}" \
  --description="agent for data commons stats" \
  --enable-telemetry \
  --enable-agent-identity \
  --agent-gateway-egress=${AGW_URI} \
  --env-var="DC_API_KEY=${DC_API_KEY}"

אחזור נתונים בסיסיים של פריסה

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

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

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

אימות רשומת הרישום

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

10. מדיניות

מדיניות ההרשאות של ניהול הסוכנים מאפשרת תנועה מסוכן AI דרך Agent Gateway ועד ליעד (לדוגמה, נקודת קצה של שרת MCP של צד שלישי עבור אפליקציית SaaS). אחרי שהתנועה מגיעה ליעד, הרשאות רגילות ברמת השירות או ברמת האפליקציה מאשרות גישה לנתונים.

הקצאת תפקידי IAM ליציאה של Agent Gateway מאפשרת להגדיר מדיניות גישה שמאפשרת לזהות של חשבון המשתמש של הסוכן גישה למשאבי יעד רשומים דרך Agent Gateway. המדיניות נאכפת ברמת Agent Gateway ומאומתת באמצעות מדיניות IAM של שרת proxy לאימות זהויות (IAP).

הענקת תפקידי IAM לסוכנים עבור יציאה מ-Agent Gateway

הפלטפורמה Agent Gateway בודקת בקשות נכנסות כדי לוודא שלסוכן המתקשר יש את ההרשאה iap.webServiceVersions.egressViaIAP (שניתנת על ידי התפקיד roles/iap.egressor) במשאב היעד.

הענקת ההרשאה roles/iap.egressor לזהות הסוכן או לקבוצת הישויות המורשות של Agent Runtime במשאב היעד שנבחר מאפשרת את תעבורת הנתונים היוצאת הזו. בשיעור Codelab הזה, התפקיד מוקצה לחשבון המשתמש agent, שנותן הרשאה לזהות הסוכן הספציפית של Agent Runtime.

מדיניות ה-IAM קשורה למשאבי היעד כפי שמוגדר במודל הנתונים של מאגר הסוכנים. המשאב iap_web/agentRegistry מייצג רמה של מאגר כולל בהיררכיית IAM. כאשר agentRegistry משמש כנכס אב למשאבי הצאצא הנפרדים של agents,‏ mcpServers ו-endpoints. ב-codelab הזה, מדיניות IAM קשורה לרמות mcpServer ו-endpoint, וההרשאה חלה על משאבי הצאצא הספציפיים.

מידע על סינון מותנה של משפכים מרובי-ערוצים (MCP)

לשרת ה-MCP של Data Commons יש שני כלים:

‫search_indicators: לשאילתות לגבי גילוי הנתונים שזמינים, חיפוש משתנים או הבנת כיסוי הנתונים
‫get_observations: לשאילתות לאחזור נקודות נתונים ספציפיות או סדרות זמן

יש כמה פעולות סטנדרטיות של MCP שכדאי להכיר כשמגדירים מדיניות ניהול מותנה בשרתי MCP. לפני שלקוח MCP יכול לבצע tools/call עבור search_indicators או get_observations, הוא צריך קודם לשלוח בקשות לזיהוי וללחיצת יד של פרוטוקול:

initialize
notifications/initialized
tools/list

כדי להדגים סינון מדיניות מותנה, המדיניות תוגדר לתנאים הבאים:

טבלה. הערכת מדיניות לבקשות MCP

בקשה / שיטה	הערך של `mcp.toolName`	הערכה של CEL	תוצאה
`initialize`	`""`	`"" in ['search_indicators', '']`	‫✅ ALLOWED (200)
`tools/list`	`""`	`"" in ['search_indicators', '']`	‫✅ ALLOWED (200)
`search_indicators`	`"search_indicators"`	`"search_indicators" in [...]`	‫✅ ALLOWED (200)
`get_observations`	`"get_observations"`	`"get_observations" in [...]`	‫❌ DENIED (403)

כדי לאפשר את תהליך הלחיצת יד של הפרוטוקול ואת הקריאה לכלי search_indicators, כלל המדיניות המותנה כולל הרשאה ל-"search_indicators" או ל-"" (מחרוזת ריקה).

הגדרת מדיניות IAM של שרת MCP של IAP במאגר

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

הערה: הפונקציה etag: צריכה להחזיר את ברירת המחדל ACAB כי עדיין לא הוגדרו מדיניות.

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

# create policy config file
cat > cfg/iap-policy-dc-agent-to-dc-mcp-tool-1.json << EOF
{
  "bindings": [
    {
      "role": "roles/iap.egressor",
      "members": [
        "${RE_AGENT_IDENTITY}"
      ],
      "condition": {
        "title": "allow ${RE_AGENT_NAME} to use search_indicators tool for ${MCP_DISPLAY_NAME}",
        "expression": "api.getAttribute('iap.googleapis.com/mcp.toolName', '') in ['search_indicators', '']"
      }
    }
  ],
  "etag": "${IAP_ETAG}",
  "version": 3
}
EOF

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

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

כאן מסתיים החלק בנושא מדיניות… עכשיו נעבור לקטע ביקורת.

11. ביקורת

תוסף ההרשאה של Agent Gateway פועל במצב DRY_RUN. המערכת עוקבת אחרי בקשות יוצאות ומתעדת אותן, אבל לא חוסמת אותן.

בדיקת שאילתות של סוכנים

פותחים חלון דפדפן לממשק המשתמש של מסוף Google Cloud ועוברים אל:

Agent Platform → Agents → Deployments → agent-datacommons
לוחצים על הכרטיסייה סביבת משחקים.

אפשר גם להריץ את פקודת הטרמינל הזו וללחוץ על הקישור כדי לעבור אל סביבת המשחקים של הסוכן:

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

שולחים כמה שאילתות לדוגמה…

What data do you have on water quality in Zimbabwe?
Compare the life expectancy, economic inequality, and GDP growth for BRICS nations

מוודאים שהשאילתות מחזירות תשובות תקינות.

ניתוח של יומני ביקורת

צפייה ביומנים ובבדיקות של הערכות המדיניות.

# list unique urls with http status and iap authorization result
gcloud logging read \
  "resource.type=\"networkservices.googleapis.com/Gateway\" \
  AND httpRequest.requestUrl:*" \
  --project=${PROJ_ID} \
  --limit=200 \
  --format="value(httpRequest.status, jsonPayload.authzPolicyInfo.result, httpRequest.requestUrl)" | sort -u

200     ALLOWED https://api.datacommons.org/mcp
200     ALLOWED https://cloudresourcemanager.googleapis.com:443/google.cloud.resourcemanager.v3.Projects/GetProject
200     ALLOWED https://telemetry.googleapis.com/v1/traces
200     ALLOWED https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJ_ID}/locations/${REGION}/publishers/google/models/gemini-2.5-flash:generateContent
200     ALLOWED https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJ_ID}/locations/${REGION}/reasoningEngines/${RE_ENGINE_ID}/sessions/${RE_SESSION_ID}
200     ALLOWED https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJ_ID}/locations/${REGION}/reasoningEngines/${RE_ENGINE_ID}/sessions/${RE_SESSION_ID}:appendEvent
200     ALLOWED https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJ_ID}/locations/${REGION}/reasoningEngines/${RE_ENGINE_ID}/sessions/${RE_SESSION_ID}/events
202     ALLOWED https://api.datacommons.org/mcp

עדכון מדיניות ה-IAM של נקודות הקצה של IAP במאגר

מתן הרשאות יציאה לסוכן עבור נקודת קצה של טלמטריה

# set var for endpoint display name
export ENDPOINT_1_DISPLAY_NAME="telemetry.googleapis.com"
echo ${ENDPOINT_1_DISPLAY_NAME}

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

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

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

# verify iap iam policy for telemetry endpoint
gcloud beta iap web get-iam-policy \
  --region=${REGION} \
  --resource-type=agent-registry \
  --endpoint=${ENDPOINT_1_REGISTRY_ID}

מתן הרשאות יציאה לסוכן עבור נקודת הקצה של aiplatform

# set var for endpoint display name
export ENDPOINT_2_DISPLAY_NAME="${REGION}-aiplatform.googleapis.com"
echo ${ENDPOINT_2_DISPLAY_NAME}

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

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

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

# verify iap iam policy for aiplatform endpoint
gcloud beta iap web get-iam-policy \
  --region=${REGION} \
  --resource-type=agent-registry \
  --endpoint=${ENDPOINT_2_REGISTRY_ID}

מתן הרשאות יציאה לסוכן עבור נקודת הקצה של Cloud Resource Manager

# set var for endpoint display name
export ENDPOINT_3_DISPLAY_NAME="cloudresourcemanager.googleapis.com"
echo ${ENDPOINT_3_DISPLAY_NAME}

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

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

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

# verify iap iam policy for cloudresourcemanager endpoint
gcloud beta iap web get-iam-policy \
  --region=${REGION} \
  --resource-type=agent-registry \
  --endpoint=${ENDPOINT_3_REGISTRY_ID}

כאן מסתיים החלק של הביקורת... עכשיו נעבור לקטע החלה.

12. אכוף

הסוכן הצליח לשלוח בקשות דרך השער במצב DRY_RUN. מעדכנים את מדיניות ההרשאות כדי להעביר את תוסף ההרשאות של Agent Gateway IAP למצב ENFORCE.

עדכון תוסף הרשאה

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

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

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

עדכון מדיניות ההרשאות

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

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

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

אימות של הרשאה מותנית

חוזרים אל הסביבה הניסיונית של הסוכן בממשק המשתמש של המסוף.

שליחת שאילתת בדיקה נוספת (ניסיון להפעיל את הכלי המותרsearch_indicators)...

What data topics do you have for Peru?

שימו לב שהבקשות של הסוכן למודל הבסיסי של Gemini ‏ (${REGION}-aiplatform.googleapis.com/...), ל-Telemetry API ‏ (telemetry.googleapis.com/...) ולנקודת הקצה של שרת ה-MCP של Data Commons ‏ (api.datacommons.org/mcp) מועברות עם קודי סטטוס HTTP ‏200 OK.

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

בודקים שאין בקשות שנחסמות. מחפשים ביומני הביקורת של השער ניסיונות יציאה שנחסמו עם קודי סטטוס HTTP‏ 403 Forbidden.

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

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

אימות של דחייה מותנית

שליחת שאילתת בדיקה נוספת (ניסיון להפעיל את הכלי נדחתהget_observations)...

What are the diabetes levels in Peru compared to Slovakia?

הסוכן יבדוק קודם את search_indicators ואז ינסה להשתמש ב-get_observations, אבל הפעולה תיכשל והתגובה של הסוכן תהיה חסרה.

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

TIMESTAMP            STATUS  IAP_AUTHZ  MCP_METHOD                 TOOL_NAME          URL
YYYY-MM-DDTHH:MM:SS  403     DENIED     tools/call                 get_observations   https://api.datacommons.org/mcp
YYYY-MM-DDTHH:MM:SS          ALLOWED    tools/call                 get_observations   https://api.datacommons.org/mcp
YYYY-MM-DDTHH:MM:SS  403     DENIED     tools/call                 get_observations   https://api.datacommons.org/mcp
YYYY-MM-DDTHH:MM:SS  200     ALLOWED    tools/call                 search_indicators  https://api.datacommons.org/mcp
YYYY-MM-DDTHH:MM:SS  200     ALLOWED    tools/list                                    https://api.datacommons.org/mcp
YYYY-MM-DDTHH:MM:SS  202     ALLOWED    notifications/initialized                     https://api.datacommons.org/mcp

כך מוודאים שמדיניות השליטה פועלת כמו שצריך.

שימו לב שהשורה השנייה שמציינת סטטוס ריק ו-ALLOWED היא אירוע משני של ניתוק החיבור שמופק על ידי Agent Gateway כששקע נסגר אחרי שליחת התגובה 403 (כי לאירועים של סגירת חיבור אין קודי סטטוס של תגובה, ולכן httpRequest.status ריק).

בזה מסתיים החלק בנושא אכיפה… עכשיו נעבור לקטע ניקוי.

13. הסרת המשאבים

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

# next

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

# next

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

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

# next

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

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

# next

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

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

# next

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

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

# next

# remove manual registry entry
gcloud -q agent-registry services delete ${MCP_RESOURCE_NAME} --location=${REGION}

# delete gateway resources
gcloud -q beta network-security authz-policies delete ${AGW_NAME}-authz-policy-profile-iap --location=${REGION}

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

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

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

# next

# clean up local working directories and generated configs
rm -rf cfg agent-datacommons endpoints

# end

זהו סוף החלק של ניקוי הנתונים... עכשיו נעבור אל הסיכום!

14. סיכום

מעולה! הצלחתם לפרוס ולנהל תקשורת יוצאת של סוכן עם גישה לכלים באמצעות Agent Gateway.

cosmopup

Cosmopup חושב ש-Codelabs הם הכי טובים שיש!

מה השלב הבא?

במסמכי Gemini Enterprise Agent Platform אפשר למצוא מידע על תכונות מתקדמות ומדריכים
הגדרת אמצעי הגנה של Model Armor ב-Agent Gateway לשיפור הבטיחות והאבטחה של ה-AI
כדאי לעיין במדיניות בנושא ניהול סמנטי כדי לאכוף כללים עסקיים ותאימות לשאילתות בשפה טבעית

אתם מוזמנים לשלוח הערות, שאלות או תיקונים באמצעות טופס המשוב הזה.

תודה!