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

Ruch wychodzący z bramy agentów ze środowiska wykonawczego agentów do zewnętrznego serwera MCP

1. Wprowadzenie

W tym ćwiczeniu dowiesz się, jak zarządzać ruchem wychodzącym bramy agenta w przypadku agentów AI, którzy uzyskują dostęp do zewnętrznych serwerów Model Context Protocol (MCP) hostowanych poza Google Cloud.

Aplikacje AI, od samodzielnych chatbotów po autonomiczne systemy z przepływami pracy obejmującymi wielu agentów, mogą dynamicznie wywoływać narzędzia zewnętrzne. Zapewnienie agentom kontrolowanego dostępu do zapytań do baz danych, pobierania treści internetowych i wykonywania działań jest niezbędne do zapewnienia bezpieczeństwa i wydajności agentów. Jednak w środowiskach firmowych zabezpieczenie wykonywania narzędzi agenta jest trudne. Jeśli agent ma bezpośredni dostęp do sieci, ataki polegające na wstrzykiwaniu promptów lub halucynacje modelu mogą spowodować, że agent wykradnie dane wrażliwe lub wykona destrukcyjne polecenia.

Aby zarządzać agentami autonomicznymi na dużą skalę, Agent Gateway zapewnia scentralizowany punkt egzekwowania zasad zero zaufania, który jest bezpośrednio zintegrowany z architekturą platformy agentów. Zamiast polegać na niestandardowych implementacjach unikalnych dla każdej aplikacji lub kodu agenta, Agent Gateway zapewnia routing sieciowy, zarządzanie agentami i bezpieczeństwo środowiska wykonawczego egzekwowane na poziomie platformy.

Gdy Brama agentów działa w trybie ruchu wychodzącego (agent-to-anywhere), przekazuje wszystkie żądania wychodzące od agentów skonfigurowanych do korzystania z bramy. Każde żądanie obciążenia agenta jest uwierzytelniane za pomocą unikalnego identyfikatora agenta i autoryzowane za pomocą zasad Identity-Aware Proxy (IAP). Wywołania narzędzia MCP są dynamicznie dekodowane i sprawdzane pod kątem egzekwowania zasad. Administratorzy zabezpieczeń mogą centralnie egzekwować szczegółowe uprawnienia, aby mieć pewność, że agenci mogą wywoływać tylko zatwierdzone punkty końcowe i metody.

Co utworzysz

Brama agentów w trybie ruchu wychodzącego (od agenta do dowolnego miejsca)
Rozszerzenie autoryzacji Identity-Aware Proxy (IAP)
Agent Runtime ADK agent z tożsamością agenta
Rejestr agentów z interfejsem Google API i punktami końcowymi MCP
Łączność zewnętrznych narzędzi MCP z publicznymi zbiorami danych Data Commons
Zasady autoryzacji z kontrolą dostępu za pomocą uprawnień

Rys. 1. Architektura ćwiczeń z programowania

Czego się dowiesz

Jak wdrożyć bramę agentów w uporządkowanej sekwencji konfiguracji
Jak przejść z trybu próbnego na tryb egzekwowania zasad autoryzacji
Rejestrowanie punktów końcowych interfejsu Google API i serwerów MCP w rejestrze agentów
Jak używać warunkowych zasad autoryzacji na podstawie atrybutów protokołu MCP
Sprawdzanie dzienników Bramy agentów w celu weryfikacji zarządzania ruchem wychodzącym

Wymagania

projekt Google Cloud z włączonymi płatnościami;
Uprawnienia IAM do udostępniania usług sieciowych i zasobów Agent Platform
Powłoka zgodna z POSIX (bash lub zsh) z zainstalowanym interfejsem Google Cloud CLI (komponenty gcloud i bq).
Narzędzia wiersza poleceń: git, curl, jq (procesor JSON), Python 3 i uv (menedżer pakietów Pythona)
Bezpłatny klucz interfejsu Data Commons API umożliwiający dostęp do zbiorów danych testowych zapytań

2. Pojęcia

Sekwencja wdrażania

To ćwiczenie zawiera uporządkowaną sekwencję konfiguracji, dzięki czemu agenci mają dostęp do niezbędnych zasobów podczas inicjowania, a połączenie można potwierdzić przed zastosowaniem wymuszonych zasad dostępu.

W tym laboratorium używamy tej sekwencji wdrażania:

Rozpocznij w trybie DRY_RUN: sprawdź, czy żądania agenta docierają do bramy i przechodzą przez nią (tylko tryb audytu).
Zarejestruj wszystkie usługi: zarejestruj wszystkie komponenty agenta w rejestrze agentów i potwierdź dostęp do narzędzi agenta.
Tworzenie zasad autoryzacji: utwórz i zastosuj zasady autoryzacji, aby zezwolić na ruch wychodzący z agentów do serwerów i punktów końcowych MCP.
Przełącz na tryb ENFORCED: zaktualizuj zasadę rozszerzenia autoryzacji, aby egzekwować zasady i blokować nieautoryzowany ruch wychodzący.

Rys. 2. Sekwencja wdrażania

Topologia routingu ruchu wychodzącego

Ruch wychodzący z bramy agenta (od agenta do dowolnego miejsca) działa jako scentralizowany wychodzący serwer proxy typu „zero zaufania” dla zadań agentowych. Gdy agent wysyła żądanie do zewnętrznego narzędzia lub interfejsu API, żądanie wychodzące jest przechwytywane przez bramę agenta i oceniane pod kątem zgodności z zasadami zarządzania przed przekierowaniem do miejsca docelowego. W architekturze platformy agentów Google Cloud brama agentów zapewnia łączność platformy danych z:

Sieci prywatne (VPC): ruch wychodzący kierowany do wewnętrznych interfejsów API przedsiębiorstwa, mikrousług i baz danych hostowanych w prywatnych sieciach VPC oraz sieci lokalnych lub między chmurami, do których można dotrzeć za pomocą połączenia hybrydowego.
Sieci zewnętrzne (internet): ruch wychodzący kierowany do usług internetowych innych firm, interfejsów API SaaS lub publicznych punktów końcowych.
Usługi AI i Agent Platform: ruch wychodzący kierowany do zarządzanych interfejsów Cloud API Google, modeli podstawowych, punktów końcowych Google MCP (np. BigQuery) i usług zarządzania platformą (Agent Registry i zasady IAP).

Ilustracja 3. Topologia kierowania ruchu wychodzącego przez bramę agentów

To ćwiczenie koncentruje się na ruchu wychodzącym z agenta niestandardowego w środowisku wykonawczym agenta, który jest kierowany do zewnętrznego serwera MCP innej firmy dostępnego przez internet.

Inspekcja protokołu MCP

Wyjście z bramy agenta (agent-to-anywhere) może analizować zawartość żądań MCP i oceniać zasady dostępu na podstawie szczegółowych atrybutów protokołu. Zasady ruchu wychodzącego z serwera agenta do serwera MCP mogą zawierać warunki wyrażone w języku Common Expression Language (CEL), które są egzekwowane w czasie działania w przypadku każdego żądania.

Wywołania MCP zwykle korzystają z formatu protokołu JSON-RPC i transportu HTTP. Szczegóły wywoływanej metody MCP (np. tools/call), nazwa narzędzia docelowego i wszystkie argumenty znajdują się w ładunku JSON w treści żądania HTTP.

Atrybut iap.googleapis.com/mcp.toolName jest wyodrębniany przez Agent Gateway przez przeanalizowanie treści JSON w celu znalezienia identyfikatora narzędzia określonego w żądaniu.

Atrybuty takie jak iap.googleapis.com/mcp.tool.isReadOnly i mcp.tool.isDestructive nie są zwykle wysyłane w treści każdego żądania. Są to adnotacje (metadane) powiązane z narzędziem. Gdy brama agentów wyodrębnia toolName z treści, wyszukuje definicję narzędzia i powiązane z nią właściwości w rejestrze agentów, w którym zarejestrowano zawartość toolspec.json.

Rys. 4. Sprawdzanie MCP bramy agenta

Wyrażenia CEL używane w warunkach IAM usługi IAP mają standardowy format api.getAttribute('iap.googleapis.com/ATTRIBUTE_NAME', 'DEFAULT_VALUE')== 'DESIRED_VALUE'.

W tej tabeli opisano atrybuty zarządzania ruchem wychodzącym z bramy agentów, które można zastosować do żądań serwera MCP:

Atrybut	Metoda / lokalizacja MCP	Opis
`mcp.toolName`	`tools/call` (treść)	Identyfikator narzędzia docelowego żądany w ładunku RPC (np. `"delete_instance"`)
`mcp.tool.isReadOnly`	Rejestr agentów (`toolspec.json`)	Wskazuje, czy narzędzie jest tylko do odczytu (nie modyfikuje środowiska).
`mcp.tool.isDestructive`	Rejestr agentów (`toolspec.json`)	Wskazuje, czy wywołanie narzędzia może spowodować nieodwracalne modyfikacje lub utratę danych.
`mcp.tool.isIdempotent`	Rejestr agentów (`toolspec.json`)	Wskazuje, czy wielokrotne wykonanie narzędzia z identycznymi argumentami daje dokładnie ten sam stan.
`mcp.tool.isOpenWorld`	Rejestr agentów (`toolspec.json`)	Wskazuje, czy narzędzie wykracza poza ograniczone systemy wewnętrzne i sięga do nieograniczonego internetu publicznego.

To koniec części poświęconej pojęciom. Przejdźmy teraz do sekcji Konfiguracja.

3. Konfiguracja

Wymagane role uprawnień

Aby utworzyć zasoby w tym ćwiczeniu, musisz mieć te role:

Kategoria	Wymagana rola uprawnień (identyfikator)	Opis
Zarządzanie interfejsami API	`roles/serviceusage.serviceUsageAdmin`	Włączanie usług interfejsu Google Cloud API
Sieć i brama	`roles/networkservices.admin`	Aprowizowanie bramy agentów
Rozszerzenia usług	`roles/serviceextensions.admin`	Konfigurowanie rozszerzeń routingu
Bezpieczeństwo sieciowe	`roles/networksecurity.admin`	Wdrażanie zasad autoryzacji
Rejestr agentów	`roles/agentregistry.admin`	Dozwolone hosty katalogu
Vertex AI i agenty	`roles/aiplatform.admin`	Wdrażanie zadań Agent Runtime
Zasady ruchu wychodzącego	`roles/iap.admin`	Stosowanie zasad `roles/iap.egressor`
Cloud Storage	`roles/storage.admin`	Zarządzanie zasobnikami przejściowymi wdrożenia
Logi i audyt	`roles/logging.viewer`	Sprawdzanie śladów i dzienników kontrolnych

Możesz też użyć szerokiego poziomu podstawowego, np. roles/admin, lub starszej roli roles/owner.

Dostęp do projektu

To ćwiczenie korzysta z jednego projektu Google Cloud. Kroki konfiguracji wykorzystują interfejs wiersza poleceń gcloud i polecenia powłoki Linux.

Zacznij od uzyskania dostępu do wiersza poleceń projektu w chmurze Google Cloud:

Cloud Shell na stronie shell.cloud.google.com lub
Terminal lokalny z zainstalowanym interfejsem wiersza poleceń gcloud

Ustawianie identyfikatora projektu

gcloud config set project SET_YOUR_PROJECT_ID_HERE

Uwierzytelnianie sesji

# login to gcloud cli
gcloud auth login

# login for gcloud api
gcloud auth application-default login

Ustawianie zmiennych środowiskowych powłoki

# 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

Aktualizacja `gcloud cli` (zalecane)

Jeśli korzystasz z samodzielnie zarządzanej instalacji pakietu Google Cloud SDK (czyli poza Cloud Shell), zaktualizuj komponenty do najnowszej wersji.

# update gcloud cli
gcloud components update

Włączanie usług 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

To kończy część konfiguracji... przejdźmy teraz do sekcji Brama.

4. Brama

Przed wprowadzeniem kontroli dostępu wdróż bramę agentów i skonfiguruj jej rozszerzenie autoryzacji w DRY_RUN. Umożliwia to pomyślne wykonanie wywołań narzędzi wychodzących przy jednoczesnym rejestrowaniu wyników oceny na potrzeby kontroli.

W tym przypadku brama agentów używa regionalnego rejestru do obsługi regionalnych zasobów Agent Runtime.

Utwórz bramę

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

To kończy część dotyczącą bramy. Przejdźmy teraz do sekcji Autoryzacja.

5. Autoryzacja

Rozszerzenie autoryzacji bramy agentów dla Identity-Aware Proxy (IAP) to rodzaj Service Extension, które służy do delegowania decyzji o autoryzacji w przypadku całej komunikacji Agent Platform.

Przepływ delegowania: gdy agent próbuje wywołać zewnętrzny punkt końcowy lub serwer MCP, kieruje żądanie do bramy agenta. Zamiast oceniać dostęp lokalnie, brama używa rozszerzenia autoryzacji, aby wysłać wywołanie do usługi oceny IAP. IAP ocenia tożsamość agenta (opartą na SPIFFE) pod kątem zasad IAM dotyczących zasobu docelowego w rejestrze agentów. IAP zwraca do bramy decyzję ALLOW lub DENY, która przekazuje ruch dalej lub blokuje go za pomocą kodu stanu HTTP 403 Forbidden.
Tryby egzekwowania: w trybie DRY_RUN IAP ocenia żądania i rejestruje decyzje w Cloud Logging bez blokowania ruchu. W trybie ENFORCE każde żądanie od nieautoryzowanego agenta lub do niezarejestrowanego miejsca docelowego jest natychmiast blokowane.
Warstwa powiązań: rozszerzenie usługi jest połączone z bramą agentów za pomocą zasady autoryzacji skonfigurowanej z profilem REQUEST_AUTHZ.

Rozszerzenie autoryzacji

Tworzenie rozszerzenia autoryzacji

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

Zasady dotyczące upoważnienia

Zasady autoryzacji wiążą dostawcę zabezpieczeń (IAP) z docelowym zasobem bramy i określają profil przechwytywania (REQUEST_AUTHZ).

Tworzenie zasady autoryzacji

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

To kończy część dotyczącą autoryzacji. Przejdźmy teraz do sekcji Baza kodu.

6. Baza kodu

Kod agenta i skrypt rejestracji punktu końcowego użyte w tym ćwiczeniu są przechowywane w zdalnym repozytorium Google Cloud na GitHubie. W ramach tych czynności repozytorium zostanie sklonowane lokalnie, niezbędne pliki zostaną skopiowane do bieżącej struktury katalogów roboczych, a następnie pliki tymczasowe zostaną usunięte.

Tworzony jest zasobnik tymczasowy na dane, do którego Agent Runtime przesyła, kompiluje i wdraża spakowany kod aplikacji agenta oraz artefakty zależności.

Pobieranie artefaktów zdalnych

# 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

Tworzenie zasobnika testowego

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

To koniec części dotyczącej bazy kodu. Przejdźmy teraz do sekcji Rejestr.

7. Rejestr

Rejestr agentów to scentralizowany spis wszystkich agentów, serwerów MCP i punktów końcowych (interfejsów API) w ekosystemie AI. Jest to też katalog, w którym można wyświetlać, wyszukiwać i odkrywać inne zarejestrowane narzędzia i usługi do wykorzystania w aplikacjach AI. Tryb wychodzący bramy agentów (agent-to-anywhere) używa modelu danych rejestru jako struktury zarządzania do egzekwowania kontroli dostępu wychodzącego. Uprawnienia do roli IAM dla agentów wywołujących podmiot zabezpieczeń są sprawdzane na podstawie zasad powiązanych z zasobem rejestru.

Aby uruchomić środowisko i obsługiwać agentów korzystających z różnych interfejsów API Google i usług Google, używany jest skrypt, który szybko rejestruje wspólny zestaw punktów końcowych interfejsu API przy użyciu nazw hostów i lokalizacji z endpoints/googleapis.txt.

Rejestrowanie punktów końcowych

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

Weryfikowanie punktów końcowych

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

To wszystko, jeśli chodzi o rejestr. Przejdźmy teraz do sekcji Data Commons.

8. Data Commons

Data Commons to inicjatywa Google, której celem jest porządkowanie publicznych zbiorów danych i udostępnianie ich wszystkim użytkownikom. Jest to bezpłatna usługa, do której można uzyskać dostęp za pomocą klucza interfejsu API po utworzeniu konta.

Utwórz klucz interfejsu API

Po utworzeniu konta wykonaj te czynności, aby uzyskać klucz interfejsu API:

Zaloguj się w portalu API Data Commons.
W prawym górnym rogu kliknij przycisk „Moje aplikacje”.
W prawym górnym rogu pod swoją nazwą użytkownika kliknij przycisk „+ NOWA APLIKACJA”.
Nazwij aplikację (np. „Codelab Agent MCP”).
Kliknij przycisk „WŁĄCZ” przy interfejsie Data Commons API.api.datacommons.org
W prawym dolnym rogu kliknij przycisk „ZAPISZ”.

Spowoduje to utworzenie klucza interfejsu API i klucza tajnego. Kliknij ikonę „kopiuj” obok wartości klucza, aby skopiować klucz interfejsu API. Wklej wartość do polecenia terminala, aby ustawić zmienną środowiskową DC_API_KEY.

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

Tworzenie serwera MCP `toolspec`

Podczas ręcznego rejestrowania serwera MCP należy dołączyć plik specyfikacji narzędzia. Przesłanie pliku toolspec.json powoduje wyświetlenie listy wszystkich narzędzi udostępnianych przez punkt końcowy i umożliwia innym użytkownikom ich odkrywanie.

test_mcp.py Skrypt, który jest częścią agent-datacommons/ bazy kodu, generuje plik toolspec.json, łącząc się z docelowym serwerem MCP (przez SSE lub HTTP) i wywołując funkcję list_tools() w celu pobrania wszystkich dostępnych narzędzi udostępnianych przez serwer.

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

Wygenerowane dane wyjściowe toolspec pokazują atrybuty MCP, których brama agentów może używać do oceny i egzekwowania zasad wychodzących.

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

Rejestrowanie serwera 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}

To kończy część dotyczącą Data Commons… przejdźmy teraz do sekcji Środowisko wykonawcze.

9. Środowisko wykonawcze

agent-datacommons Agent ADK wdrożony w środowisku Agent Runtime jest skonfigurowany w skrypcie wdrożenia z tymi ustawieniami, aby zintegrować go z usługą Agent Platform:

"identity_type": types.IdentityType.AGENT_IDENTITY – udostępnia unikalną tożsamość podmiotu zabezpieczeń opartą na SPIFFE dla agenta.
"agent_gateway_config": { "agent_to_anywhere_config": {"agent_gateway": } }, aby kierować cały ruch wychodzący inicjowany przez agenta do bramy agenta w celu oceny i egzekwowania zasad.

Wdrażanie agenta

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

Pobieranie parametrów życiowych wdrożenia

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

Weryfikowanie wpisu w rejestrze

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

10. Zasady

Zasady autoryzacji zarządzania agentami zezwalają na ruch z agenta AI przez bramę agentów do miejsca docelowego (np. punktu końcowego serwera MCP innej firmy w przypadku aplikacji SaaS). Gdy ruch dotrze do miejsca docelowego, dostęp do danych jest autoryzowany przez zwykłe uprawnienia na poziomie usługi lub aplikacji.

Przyznawanie ról IAM na potrzeby ruchu wychodzącego z bramy agentów umożliwia stosowanie zasad dostępu, które pozwalają tożsamości podmiotu zabezpieczeń agenta na dostęp do zarejestrowanych zasobów docelowych za pośrednictwem bramy agentów. Zasady są egzekwowane na poziomie bramy agentów i weryfikowane przy użyciu zasad uprawnień Identity-Aware Proxy (IAP).

Przyznawanie agentowi ról uprawnień na potrzeby wychodzącego ruchu z bramy agenta

Brama agentów sprawdza przychodzące żądania, aby potwierdzić, że tożsamość agenta wywołującego ma uprawnienie iap.webServiceVersions.egressViaIAP (przyznane przez rolę roles/iap.egressor) w zasobie docelowym.

Przyznanie roles/iap.egressor tożsamości agenta lub zbiorowi podmiotów zabezpieczeń Agent Runtime w wybranym zasobie docelowym zezwala na ten ruch wychodzący. W tym ćwiczeniu rola jest przypisywana do podmiotu zabezpieczeń agent, co przyznaje uprawnienia do konkretnej tożsamości agenta środowiska wykonawczego agentów.

Zasady IAM są powiązane z zasobami docelowymi zgodnie z modelem danych rejestru agentów. Zasób iap_web/agentRegistry reprezentuje poziom „w całym rejestrze” w hierarchii IAM. gdzie agentRegistry jest elementem nadrzędnym dla poszczególnych zasobów podrzędnych agents, mcpServers i endpoints. W tym laboratorium kodowym zasady IAM są powiązane z poziomami mcpServer i endpoint, co powoduje zastosowanie uprawnień do konkretnych zasobów podrzędnych.

Informacje o filtrowaniu warunkowym w przypadku platformy MCP

Serwer MCP Data Commons ma 2 narzędzia:

search_indicators: w przypadku zapytań dotyczących odkrywania dostępnych danych, wyszukiwania zmiennych lub zrozumienia zakresu danych;
get_observations: w przypadku zapytań o pobieranie konkretnych punktów danych lub szeregów czasowych.

Podczas konfigurowania warunkowych zasad zarządzania na serwerach MCP należy pamiętać o kilku standardowych operacjach MCP. Zanim klient MCP będzie mógł wysłać tools/call dla search_indicators lub get_observations, musi najpierw wysłać żądania uzgadniania protokołu i odkrywania:

initialize
notifications/initialized
tools/list

Aby zademonstrować filtrowanie zasad warunkowych, skonfigurujemy zasadę dla tych warunków:

Tabela. Ocena zasad w przypadku żądań MCP

Żądanie / Metoda	Wartość `mcp.toolName`	Ocena CEL	Wynik
`initialize`	`""`	`"" in ['search_indicators', '']`	✅ DOZWOLONE (200)
`tools/list`	`""`	`"" in ['search_indicators', '']`	✅ DOZWOLONE (200)
`search_indicators`	`"search_indicators"`	`"search_indicators" in [...]`	✅ DOZWOLONE (200)
`get_observations`	`"get_observations"`	`"get_observations" in [...]`	❌ DENIED (403)

Aby zezwolić na uzgadnianie protokołu i wywołanie narzędzia search_indicators, warunkowa reguła zasad zawiera zezwolenie na "search_indicators" lub "" (pusty ciąg znaków).

Konfigurowanie zasad IAM serwera MCP IAP rejestru

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

UWAGA: etag: powinna zwracać domyślną wartość ACAB, ponieważ nie zdefiniowano jeszcze żadnych zasad.

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

To koniec części dotyczącej zasad. Przejdźmy teraz do sekcji Kontrola.

11. Kontrola

Rozszerzenie autoryzacji bramy agentów działa w trybie DRY_RUN. Żądania wychodzące są obserwowane i rejestrowane, ale nie blokowane.

Testowanie zapytań do agenta

Otwórz okno przeglądarki z interfejsem konsoli Google Cloud i przejdź do:

Agent Platform → Agenty → Wdrożenia → agent-datacommons
Kliknij kartę Playground (Plac zabaw).

Możesz też wpisać to polecenie w terminalu i kliknąć link, aby przejść do platformy testowej agenta:

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

Prześlij kilka zapytań testowych…

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

Sprawdź, czy zapytania zwracają prawidłowe odpowiedzi.

Analizowanie logów kontrolnych

Wyświetl logi i sprawdź oceny zasad uruchomionych próbnie.

# 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

Aktualizowanie zasad uprawnień punktów końcowych IAP rejestru

Przyznawanie agentowi uprawnień do ruchu wychodzącego w przypadku punktu końcowego telemetrii

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

Przyznawanie agentowi uprawnień do wychodzenia z punktu końcowego 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}

Przyznawanie agentowi uprawnień do wychodzącego ruchu sieciowego w przypadku punktu końcowego cloudresourcemanager

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

To koniec części dotyczącej audytu. Przejdźmy teraz do sekcji Wymuszanie.

12. Egzekwuj

Agentowi udało się wysłać żądania przez bramę w trybie DRY_RUN. Przejdź na tryb ENFORCE rozszerzenia autoryzacji IAP bramy agenta, aktualizując zasadę autoryzacji.

Aktualizowanie rozszerzenia autoryzacji

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

Aktualizowanie zasady autoryzacji

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

Weryfikacja warunkowego zezwolenia

Wróć do placu zabaw agenta w interfejsie konsoli.

Prześlij dodatkowe zapytanie testowe (spróbuj wywołać narzędzie dozwolonesearch_indicators)...

What data topics do you have for Peru?

Sprawdź, czy żądania agenta do modelu podstawowego Gemini (${REGION}-aiplatform.googleapis.com/...), interfejsu API telemetrii (telemetry.googleapis.com/...) i punktu końcowego serwera MCP Data Commons (api.datacommons.org/mcp) są przekazywane z kodami stanu 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)"

Sprawdź, czy żadne żądania nie są blokowane. W dziennikach kontrolnych bramy poszukaj odrzuconych prób wyjścia z kodami stanu 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
  )"

Weryfikowanie warunkowego odrzucenia

Prześlij dodatkowe zapytanie testowe (spróbuj wywołać narzędzie odrzuconeget_observations)...

What are the diabetes levels in Peru compared to Slovakia?

Agent najpierw sprawdzi search_indicators, a potem spróbuje użyć get_observations, ale mu się to nie uda i odpowiedź agenta będzie niekompletna.

# 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

Potwierdza to, że zasady zarządzania działają zgodnie z oczekiwaniami.

Zwróć uwagę, że drugi wiersz wskazujący pusty stan i ALLOWED to pomocnicze zdarzenie dziennika zamykania połączenia wyemitowane przez bramę agenta podczas zamykania gniazda po wysłaniu odpowiedzi 403 (ponieważ zdarzenia zamykania połączenia nie mają kodów stanu odpowiedzi, httpRequest.status jest puste).

To wszystko, jeśli chodzi o wymuszanie. Przejdźmy teraz do sekcji Czyszczenie.

13. Czyszczenie

# 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

To koniec części poświęconej czyszczeniu. Przejdźmy teraz do podsumowania.

14. Podsumowanie

Gratulacje! Udało Ci się wdrożyć i zarządzać komunikacją wychodzącą agenta, który uzyskuje dostęp do narzędzi za pomocą bramy agenta.

cosmopup

Cosmopup uważa, że Codelabs są super!

Co dalej?

Zaawansowane funkcje i samouczki znajdziesz w dokumentacji Gemini Enterprise Agent Platform.
Skonfiguruj bariery Model Armor w bramie agentów, aby zwiększyć bezpieczeństwo AI.
Poznaj zasady zarządzania semantycznego, aby egzekwować reguły biznesowe i zgodność w przypadku zapytań w języku naturalnym.

Jeśli masz jakieś uwagi, pytania lub poprawki, możesz je przesłać za pomocą tego formularza opinii.

Dziękujemy!