Protección de implementaciones empresariales con agentes en varias nubes

1. Introducción

En este codelab, implementarás de forma segura una implementación de un solo agente o varias herramientas con el Kit de desarrollo de agentes (ADK), Agent Engine y Google Kubernetes Engine. Aprenderás cómo un agente de IA iniciado por un usuario en Gemini Enterprise navega de forma segura por Google Cloud, ya que se basa en GKE Gateway con extensiones de servicio para redactar datos sensibles en tránsito desde las respuestas de la herramienta de MCP.

Qué aprenderá

Implementa un agente asistente hipotecario del ADK en Agent Engine con la instrumentación de OpenTelemetry
Implementa servidores MCP de backend en Google Kubernetes Engine (GKE) detrás de una puerta de enlace interna
Conecta Agent Engine a una VPC del proyecto con una interfaz de PSC y un intercambio de tráfico de DNS
Expón APIs de REST como herramientas de MCP con el proxy de detección de MCP de Apigee
Configura GKE Gateway para la salida de agentes controlados con Service Extensions para la redacción de DLP y la autorización de MCP
Aplica protecciones de IA con Model Armor para filtrar instrucciones y respuestas

Requisitos

Un navegador web, como Chrome
Un proyecto de Google Cloud con la facturación habilitada.
Conocimientos básicos de Terraform, Kubernetes y Python

Este codelab está dirigido a desarrolladores y profesionales de la seguridad que desean implementar y proteger flujos de trabajo basados en agentes en entornos empresariales.

2. Antes de comenzar

Crea un proyecto de Google Cloud y habilita las APIs necesarias.

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud .
Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información para verificar si la facturación está habilitada en un proyecto.

Roles de IAM obligatorios

En este codelab, se supone que tienes el rol de propietario del proyecto para tu proyecto de Google Cloud.

Habilita las APIs

En la consola de Google Cloud, haz clic en Activar Cloud Shell: Si nunca usaste Cloud Shell, aparecerá un panel en el que podrás elegir si deseas iniciar Cloud Shell en un entorno de confianza con o sin aceleración. Si se te solicita que autorices Cloud Shell, haz clic en Autorizar.

En Cloud Shell, habilita todas las APIs requeridas:

gcloud services enable \
compute.googleapis.com \
container.googleapis.com \
dns.googleapis.com \
certificatemanager.googleapis.com \
dlp.googleapis.com \
aiplatform.googleapis.com \
discoveryengine.googleapis.com \
apigee.googleapis.com

Instala dependencias

En Cloud Shell, asegúrate de tener instaladas las herramientas necesarias. Terraform, kubectl y Go suelen estar preinstalados. Debes instalar uv (el administrador de paquetes de Python) y Skaffold:

# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install Skaffold
curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 && \
sudo install skaffold /usr/local/bin/

Configura las variables de entorno

Configura las siguientes variables de entorno que se usan en este codelab:

export PROJECT_ID=$(gcloud config get project)
export REGION=us-central1
export LOCATION=${REGION}

Crea una zona DNS pública

Este codelab requiere que exista previamente una zona DNS pública en tu proyecto antes de que apliques la configuración de Terraform. Esta zona es necesaria para la delegación del servidor de nombres, de modo que la configuración pueda automatizar la creación de los registros necesarios para el Administrador de certificados.

Ejecuta el siguiente comando en Cloud Shell para crear la zona:

gcloud dns managed-zones create "inference-gateway-zone" \
    --dns-name="gateway.example.com." \
    --description="Public zone for Inference Gateway" \
    --visibility="public" \
    --project="${PROJECT_ID}"

3. Clonar un repositorio de GitHub

En una terminal de tu máquina local, clona el repositorio cloud-networking-solutions:
```
git clone https://github.com/googleCloudPlatform/cloud-networking-solutions.git
```

Navega al directorio del repositorio descargado:

cd cloud-networking-solutions/demos/service-extensions-gke-gateway

4. Implementa infraestructura con Terraform

Usarás Terraform para aprovisionar la red fundamental, el clúster de GKE y las configuraciones de identidad requeridas.

Navega al directorio terraform en el repositorio clonado:
```
cd terraform
```
Configura el backend de Terraform. Crea un archivo backend.conf para la configuración parcial del backend. Reemplaza por un nombre de bucket único a nivel global.
```
cat <<EOF > backend.conf
bucket = "<YOUR_TERRAFORM_STATE_BUCKET>"
prefix = "terraform"
EOF
```

Copia el archivo de variables de ejemplo y actualízalo con los valores de tu proyecto:
```
cp example.tfvars terraform.tfvars
```
Edita terraform.tfvars y reemplaza los valores de marcador de posición.Reemplaza lo siguiente:
- project_id: Es el ID de tu proyecto de Google Cloud.
- organization_id: Es el ID numérico de tu organización de GCP.
- dns_zone_domain: Es un dominio que controlas (p.ej., demo.example.com.). Debe terminar con un punto.
Asegúrate de que las siguientes marcas de funciones estén habilitadas (están preconfiguradas en el archivo de ejemplo):
- enable_certificate_manager = true
- enable_model_armor = true
- enable_agent_engine = true
- enable_psc_interface = true

Inicializa y aplica la configuración de Terraform:

terraform init -backend-config=backend.conf
terraform plan -out=tfplan
terraform apply "tfplan"

5. Implementa cargas de trabajo de muestra con Skaffold

A continuación, implementa los servidores de MCP y los servicios de procesamiento externos en tu clúster de GKE.

Conéctate al clúster de GKE creado por Terraform:

gcloud container clusters get-credentials gateway-cluster \
    --region=${REGION} \
    --project=${PROJECT_ID}

Regresa a la raíz del proyecto y configura las plantillas de manifiesto de Kubernetes. Copia la configuración de ejemplo y establece tu ID del proyecto y el dominio base:Establece BASE_DOMAIN para que coincida con tu entorno. El valor de BASE_DOMAIN debe coincidir con la variable dns_zone_domain de Terraform (sin el punto final).
```
export BASE_DOMAIN=example.com
```

Genera los manifiestos de Kubernetes y skaffold.yaml a partir de plantillas:

bash k8s/generate.sh
envsubst '${PROJECT_ID}' < skaffold.yaml.tmpl > skaffold.yaml

Implementa todos los servicios de backend:

skaffold run -m legacy-dms,income-verification-api,corporate-email,dlp-ext-proc

Implementa la configuración de Gateway y HTTPRoute:
```
kubectl apply -k k8s/gateway-internal/
```

6. Aplica barreras de seguridad de IA con Model Armor

Puedes delegar las decisiones de seguridad del contenido, como quitar instrucciones dañinas o evitar filtraciones de datos, a Model Armor.

Requisitos previos: Otorga roles de IAM

Debes otorgar los roles necesarios a la cuenta de servicio de GKE Gateway. La cuenta de servicio sigue el formato service-GATEWAY_PROJECT_NUMBER@gcp-sa-dep.iam.gserviceaccount.com.

Ejecuta los siguientes comandos para otorgar los permisos necesarios:

export GATEWAY_PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

# Grant roles in the Gateway project
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
 --role=roles/modelarmor.calloutUser

gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
 --role=roles/serviceusage.serviceUsageConsumer

# Grant role in the project containing Model Armor templates
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member=serviceAccount:service-${GATEWAY_PROJECT_NUMBER}@gcp-sa-dep.iam.gserviceaccount.com \
 --role=roles/modelarmor.user

Crea la extensión de autorización de Model Armor

Define una extensión que apunte al servicio de Model Armor en tu región. Guarda esta configuración como ma-content-authz-extension.yaml.

Exporta el ID de plantilla de Model Armor creado por Terraform.

export MA_TEMPLATE_ID=$(cd terraform && terraform output -raw model_armor_template_id)

cat >ma-content-authz-extension.yaml <<EOF
name: ma-ext
service: modelarmor.$LOCATION.rep.googleapis.com
metadata:
  model_armor_settings: '[
  {
  "response_template_id": "projects/${PROJECT_ID}/locations/$LOCATION/templates/${MA_TEMPLATE_ID}",
  "request_template_id": "projects/${PROJECT_ID}/locations/$LOCATION/templates/${MA_TEMPLATE_ID}"
  }
  ]'
failOpen: true
EOF

gcloud beta service-extensions authz-extensions import ma-ext \
    --source=ma-content-authz-extension.yaml \
    --location=$LOCATION

Crea la política de autorización de Model Armor

Crea una política que asocie la extensión de Model Armor con tu Agent Gateway. Guarda esta configuración como ma-content-authz-policy.yaml.

cat >ma-content-authz-policy.yaml <<EOF
name: ma-content-authz-policy
target:
  resources:
  -   "projects/$PROJECT_ID/locations/$LOCATION/gateways/mortgage-gateway"
policyProfile: CONTENT_AUTHZ
action: CUSTOM
customProvider:
  authzExtension:
    resources:
    -   "projects/$PROJECT_ID/locations/$LOCATION/authzExtensions/ma-ext"
EOF

gcloud network-security authz-policies import ma-content-authz-policy \
    --source=ma-content-authz-policy.yaml \
    --location=$LOCATION

7. Configura Gemini Enterprise

Habilita la observabilidad

El agente hipotecario se implementa con la instrumentación de OpenTelemetry y las siguientes variables de entorno de telemetría habilitadas de forma predeterminada:

GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY=true
OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true
OTEL_TRACES_SAMPLER=parentbased_traceidratio

Para obtener detalles sobre cómo configurar seguimientos y tramos en Gemini Enterprise, consulta Administra la configuración de observabilidad.

Habilita Model Armor en Gemini Enterprise

Aplica el filtrado de Model Armor al asistente de Gemini Enterprise para filtrar las instrucciones del usuario y las respuestas del modelo. Las apps globales de Gemini Enterprise requieren una plantilla de Model Armor en la región múltiple us, por lo que Terraform implementa una plantilla separada para este propósito.

Recupera el nombre de la plantilla del resultado de Terraform:

cd terraform
export GE_MA_TEMPLATE_NAME=$(terraform output -raw model_armor_gemini_enterprise_template_name)

Recupera el ID de la APP de tu instancia de Gemini Enterprise:

En la consola de Google Cloud, ve a la página de Gemini Enterprise.
En el menú de navegación, haz clic en Apps.
Copia el ID de la instancia de Gemini Enterprise

Exporta el ID como una variable de entorno.

export APP_ID=<PASTE_APP_ID>

Aplica parches al asistente para habilitar Model Armor:

curl -X PATCH \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -H "X-Goog-User-Project: ${PROJECT_ID}" \
  "https://global-discoveryengine.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/collections/default_collection/engines/${APP_ID}/assistants/default_assistant?update_mask=customerPolicy" \
  -d '{
    "customerPolicy": {
      "modelArmorConfig": {
        "userPromptTemplate": "'"$GE_MA_TEMPLATE_NAME"'",
        "responseTemplate": "'"$GE_MA_TEMPLATE_NAME"'",
        "failureMode": "FAIL_OPEN"
      }
    }
  }'

Establece failureMode en FAIL_OPEN para permitir solicitudes cuando Model Armor no esté disponible o en FAIL_CLOSED para bloquearlas.

8. Implementa y agrega agentes en Gemini Enterprise

Obtén detalles de la autorización

Sigue estos pasos para obtener los detalles de la autorización.

En la consola de Google Cloud, en la página APIs y servicios, ve a la página Credenciales.
Ir a Credenciales
Haz clic en Crear credenciales y selecciona ID de cliente de OAuth.
En Tipo de aplicación, selecciona Aplicación web.
En la sección URI de redireccionamiento autorizados, agrega los siguientes URI:

https://vertexaisearch.cloud.google.com/oauth-redirect
https://vertexaisearch.cloud.google.com/static/oauth/oauth.html

Haz clic en Crear.
Exporta el ID de cliente y el secreto del cliente para la implementación.

export OAUTH_CLIENT_ID=<Client ID>
export OAUTH_CLIENT_SECRET=<Client Secret>

Implementa el agente hipotecario

La secuencia de comandos src/mortgage-agent/deploy_agent.py implementa el agente del ADK en Agent Engine y, de manera opcional, lo registra en Gemini Enterprise. Consulta Cómo registrar y administrar un agente de A2A para obtener información general sobre el flujo de registro de Gemini Enterprise.

Exporta variables de la implementación de Terraform.

export VPC_NAME=$(cd terraform && terraform output -raw vpc_name)
export PSC_ATTACHMENT=$(cd terraform && terraform output -raw psc_interface_network_attachment_id)
export DNS_PEERING_DOMAIN=$(cd terraform && terraform output -raw psc_interface_dns_peering_domain)

Instala las dependencias y realiza la implementación:

cd src/mortgage-agent
uv sync

Implementa el agente en Vertex Agent Engine y regístralo en Gemini Enterprise:

uv run python deploy_agent.py \
    --project=${PROJECT_ID} \
    --dms-mcp-url=https://dms.${DNS_PEERING_DOMAIN%%.}/mcp \
    --income-verification-url=https://income-verification.${DNS_PEERING_DOMAIN%%.} \
    --email-mcp-url=https://email.${DNS_PEERING_DOMAIN%%.}/mcp \
    --network-attachment=projects/${PROJECT_ID}/regions/${REGION}/networkAttachments/${PSC_ATTACHMENT} \
    --dns-peering-domain=${DNS_PEERING_DOMAIN} \
    --dns-peering-target-project=${PROJECT_ID} \
    --dns-peering-target-network=${VPC_NAME} \
    --enable-agent-identity \
    --ge-deploy \
    --app-id=${APP_ID} \
    --oauth-client-id=${OAUTH_CLIENT_ID} \
    --agent-name=mortgage-agent

Referencia de la marca

Marcar	Valor predeterminado	Descripción
`--project`	`$PROJECT_ID`	ID del proyecto de Google Cloud
`--dms-mcp-url`	(obligatorio)	URL del servidor de MCP del DMS
`--income-verification-url`	(obligatorio)	URL base de la API de Income Verification; `/mcp` se agrega automáticamente
`--email-mcp-url`	(obligatorio)	URL del servidor de MCP de correo electrónico
`--region`	`$REGION`	Región de GCP
`--staging-bucket`	`gs://PROJECT-staging`	Bucket de GCS para la etapa de pruebas
`--display-name`	`Mortgage Assistant Agent`	Nombre visible del agente implementado
`--update`	(opcional)	Actualiza un agente existente en su lugar (pasa el nombre completo del recurso)
`--network-attachment`	(opcional)	Adjunto de red para la interfaz de PSC (ruta de acceso o nombre completo)
`--dns-peering-domain`	(opcional)	Dominio de DNS para el intercambio de tráfico de DNS de PSC-I (debe terminar con un punto)
`--dns-peering-target-project`	(opcional)	Proyecto que aloja la red de VPC de destino para el intercambio de tráfico de DNS
`--dns-peering-target-network`	(opcional)	Nombre de la red de VPC para el intercambio de tráfico de DNS
`--enable-agent-identity`	`false`	Habilita las credenciales de privilegio mínimo por agente
`--ge-deploy`	`false`	Registra el agente en Gemini Enterprise después de la implementación
`--app-id`	(opcional)	ID del motor de Gemini Enterprise (obligatorio con `--ge-deploy`)
`--oauth-client-id`	`$OAUTH_CLIENT_ID`	ID de cliente de OAuth2 (obligatorio con `--ge-deploy`)
`--oauth-client-secret`	`$OAUTH_CLIENT_SECRET`	Secreto del cliente de OAuth2 (obligatorio con `--ge-deploy`)
`--model`	`gemini-3.1-flash-lite-preview`	Nombre del modelo de Gemini para el agente
`--agent-name`	`mortgage-agent`	Autorización de Gemini Enterprise y nombre del agente
`--ge-deploy-only`	(opcional)	Registra un motor de inferencia existente en Gemini Enterprise sin volver a implementarlo (pasa el nombre completo del recurso)

Cómo agregar usuarios con permiso

Para agregar usuarios con permiso a un agente del ADK con la consola de Google Cloud, consulta Cómo agregar o modificar usuarios y sus permisos.

9. Prueba tu agente

Ahora que implementaste y configuraste el agente, la puerta de enlace de GKE y todos los servicios de backend, prueba el flujo de extremo a extremo para verificar que las políticas de seguridad funcionen según lo esperado. Interactuarás con el "agente de hipotecas" en la interfaz de Gemini Enterprise.

Cómo acceder al agente

Navega a la página de Gemini Enterprise en la consola de Google Cloud.
Selecciona la app de Gemini Enterprise que configuraste antes, en la que se registró "mortgage-agent".
En la pestaña Descripción general, navega a la URL que se muestra en la sección "Tu app web de Gemini Enterprise está lista".
Selecciona la pestaña Agent en el menú de la izquierda llamado Agent Gallery.
Ahora deberías poder chatear con el "Agente de asistencia sobre hipotecas".

Caso de prueba 1: La "ruta feliz": Resumen de datos con ocultamiento de PII

Esta prueba verifica que el agente pueda acceder a los sistemas de backend a través de Agent Gateway y que se apliquen las políticas de Prevención de pérdida de datos (DLP) para ocultar la información sensible.

Envía la siguiente instrucción al agente de Mortgage Assistant:

I'm reviewing the Sterling family's current application. Can you summarize their 2024 and 2025 tax returns and verify if their total household income meets our 2026 debt-to-income requirements?

Qué sucede tras bambalinas:
- El agente de Gemini Enterprise formula solicitudes a las herramientas necesarias (p.ej., el sistema de administración de documentos [DMS] para las declaraciones de impuestos y la API de Income Verification).
- Model Armor inspecciona las cargas útiles de las solicitudes y las respuestas en busca de amenazas.
- La "Política de autorización basada en contenido" que configuraste activa la extensión personalizada de DLP (dlp-content-authz-ext). Esta extensión inspecciona los datos recuperados de los sistemas de backend.
- El servicio de DLP oculta toda la información de identificación personal (PII), como los números de seguridad social (SSN), de los datos de la declaración de impuestos antes de que lleguen al agente.
Resultado esperado: El agente devolverá un resumen de las declaraciones de impuestos y un estado de verificación de ingresos. Inspecciona de forma crítica el resumen que proporciona el agente. Deberías observar que la información sensible, como los IDs de contribuyente (números de seguridad social), se reemplazó por marcadores de posición (p.ej., [REDACTED]). Esto confirma la ejecución de la política de DLP a través de la puerta de enlace.

Observabilidad y auditoría

A lo largo de estas pruebas, la Plataforma de agentes y los servicios asociados recopilan telemetría:

Cloud Logging: Los registros detallados de GKE Gateway, las cargas de trabajo de GKE y otros servicios proporcionan un registro de auditoría de las solicitudes, las evaluaciones de políticas y los resultados.
Cloud Trace: La instrumentación de OpenTelemetry configurada en los servicios de agente y de backend te permite visualizar todo el flujo de llamadas, desde Gemini Enterprise hasta las herramientas de backend a través de la puerta de enlace de GKE. Esto es invaluable para depurar y comprender el ciclo de vida de la solicitud.

Sigue estos pasos para ver los registros de seguimiento de tus sesiones:

En la consola de Google Cloud, ve a la página Vertex AI Agent Engine.
Ve a Agent Engine. Las instancias de Agent Engine que forman parte del proyecto seleccionado aparecen en la lista. Puedes usar el campo Filtro para filtrar la lista según la columna que especifiques.
Haz clic en el nombre de tu instancia de Agent Engine.
Haz clic en la pestaña Registros.
Puedes seleccionar la vista de sesión o la vista de tramo.
Haz clic en una sesión o un intervalo para inspeccionar los detalles del seguimiento, incluido un grafo acíclico dirigido (DAG) de sus intervalos, entradas y salidas, y atributos de metadatos.

10. Opcional: Transcodificación de APIs de REST a MCP con Apigee

Si bien nuestro servicio de verificación de ingresos admite de forma nativa el Protocolo de contexto del modelo, muchos sistemas heredados empresariales solo proporcionan APIs de REST. En este paso opcional, usarás el proxy de detección de MCP de Apigee para transcodificar el extremo de REST del servicio de verificación de ingresos en una herramienta de MCP. Esto te permite aplicar las políticas avanzadas de administración, limitación de frecuencia y seguridad de Apigee a tus herramientas heredadas.

Para obtener más información, consulta la Descripción general del MCP de Apigee.

Requisitos previos

Antes de continuar, asegúrate de haber aprovisionado y configurado Apigee API Hub. Sigue los pasos que se indican en la documentación de Aprovisiona el centro de APIs para configurarlo y adjuntar tu instancia de Apigee.

Paso 1: Crea un adjunto de servicio para Apigee

Para permitir que Apigee llegue a tus servicios internos que se ejecutan en GKE, debes crear una vinculación de servicio.

Busca la regla de reenvío de la puerta de enlace interna de GKE:

export RULE_URI=$(gcloud compute forwarding-rules list \
  --filter="loadBalancingScheme=INTERNAL_MANAGED AND target~targetHttpsProxies" \
  --format="value(selfLink.segment(6), region.basename(), name)" | \
  awk '{print "projects/" $1 "/regions/" $2 "/forwardingRules/" $3}')

Crea el adjunto del servicio:

gcloud compute service-attachments create internal-gke-gateway-apigee \
    --region=${REGION} \
    --target-service=$RULE_URI \
    --connection-preference=ACCEPT_AUTOMATIC \
    --nat-subnets=gateway-psc-subnet

Paso 2: Habilita Apigee con Terraform

Ahora, actualiza la configuración de tu infraestructura para aprovisionar la organización y la instancia de Apigee.

Navega al directorio terraform:
```
cd terraform
```
Edita terraform.tfvars y establece enable_apigee = true.
Aplica los cambios:
```
terraform apply
```

Paso 3: Define la especificación de OpenAPI

Apigee usa definiciones estándar de OpenAPI (OAS) para detectar y transcodificar herramientas. Crea un archivo llamado income-verification-oas.yaml con el siguiente contenido:

openapi: 3.0.0
info:
  title: Income Verification API
  description: Verify applicant income through third-party employer records.
  version: 1.0.0
servers:
  -   url: https://income-verification.internal.${DNS_PEERING_DOMAIN%%.}/api
paths:
  /income-verification/verify:
    post:
      summary: Verify applicant income
      operationId: verifyApplicant
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                first_name:
                  type: string
                last_name:
                  type: string
      responses:
        '200':
          description: Successful verification
          content:
            application/json:
              schema:
                type: object

Paso 4: Implementa el proxy de detección de MCP de Apigee

El proxy de descubrimiento de MCP es un proxy de Apigee especializado que actúa como servidor de MCP.

En la IU de Apigee, navega a Develop > API Proxies.
Haz clic en Crear nuevo y selecciona Proxy de descubrimiento de MCP.
Asigna el nombre income-verification-discovery al proxy.
En la sección OpenAPI Spec, sube el archivo income-verification-oas.yaml que creaste.
Establece el grupo de entornos en aquel en el que se pueda acceder a tu puerta de enlace interna.
Haz clic en Implementar.

(Opcional) Agrega una política de seguridad

Antes de implementar o compartir tu proxy, debes protegerlo. Puedes agregar políticas para aplicar requisitos de seguridad, como tokens de OAuth o claves de API. Para obtener instrucciones sobre cómo agregar una política de seguridad, consulta la documentación de Apigee sobre cómo proteger las APIs.

Paso 5: Verifica el acceso a la herramienta transcodificada

Una vez implementado, Apigee transcodifica automáticamente el extremo POST /verify en una herramienta de MCP verifyApplicant.

Enumera las herramientas disponibles a través del extremo de MCP de Apigee:

curl -X POST https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'

Deberías ver la herramienta verifyApplicant en la respuesta, transcodificada desde tu especificación de REST. Ahora puedes llamar a esta herramienta a través de Apigee, y Apigee controlará la traducción al servicio REST subyacente mientras aplica las políticas de seguridad que hayas configurado.

Paso 6: Actualiza el agente de hipotecas para que use Apigee

Ahora que Apigee transcodificó correctamente tu API de REST en una herramienta compatible con MCP, debes actualizar la configuración de implementación del agente. Al dirigir el agente al endpoint de Apigee, todas las solicitudes de verificación de ingresos ahora se beneficiarán de la seguridad, el registro y la administración de tráfico de nivel empresarial de Apigee.

Identifica tu URL de MCP de Apigee: Tu extremo debe seguir el patrón https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp.

Vuelve a ejecutar la secuencia de comandos de implementación: Usa la marca --update junto con el nuevo --income-verification-url. Esto actualiza el agente existente en Agent Engine sin necesidad de borrarlo por completo.

cd src/mortgage-agent

# Update the agent to route income verification through Apigee
uv run python deploy_agent.py \
    --project=${PROJECT_ID} \
    --update \
    --agent-name=mortgage-agent \
    --dms-mcp-url=https://dms.${DNS_PEERING_DOMAIN%%.}/mcp \
    --income-verification-url=https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp \
    --email-mcp-url=https://email.${DNS_PEERING_DOMAIN%%.}/mcp \
    --network-attachment=projects/${PROJECT_ID}/regions/${REGION}/networkAttachments/${PSC_ATTACHMENT} \
    --dns-peering-domain=${DNS_PEERING_DOMAIN} \
    --dns-peering-target-project=${PROJECT_ID} \
    --dns-peering-target-network=${VPC_NAME} \
    --ge-deploy \
    --app-id=${APP_ID} \
    --oauth-client-id=${OAUTH_CLIENT_ID}

Verifica el cambio: Vuelve a la interfaz de Gemini Enterprise y pídele al agente que verifique los ingresos de un solicitante.
```
"Can you verify the joint income for the Sterlings using the verification service?"
```
En la pestaña Apigee Debug, ahora deberías ver que la solicitud JSON-RPC entrante de GKE Gateway se transforma en una solicitud POST REST estándar para tu servicio de backend de GKE.

11. Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que creaste en este codelab, bórralos cuando termines.

Borra el adjunto de servicio si se creó de forma manual:

gcloud compute service-attachments delete internal-gke-gateway \
    --region=${REGION} --quiet

Navega al directorio terraform y destruye todos los recursos:
```
cd terraform
terraform destroy
```
De manera opcional, borra todo el proyecto de Google Cloud:
```
gcloud projects delete ${PROJECT_ID}
```

12. Felicitaciones

Completaste este codelab y aprendiste a proteger las implementaciones empresariales de agentes en varias nubes.

Temas que se abordaron

Se implementó un agente asistente hipotecario del ADK en Agent Engine con la instrumentación de OpenTelemetry.
Se implementaron servidores de MCP de backend en GKE detrás de una puerta de enlace interna.
Se conectó Agent Engine a una VPC del proyecto con una interfaz de PSC y un intercambio de tráfico de DNS.
Puerta de enlace de GKE configurada para la salida de agentes controlada con ocultamiento de DLP y autorización de MCP
Protecciones de IA aplicadas con Model Armor para la detección de instrucciones y respuestas
APIs de REST transcodificadas de forma opcional en MCP con el proxy de descubrimiento de MCP de Apigee

Próximos pasos

Explorar Model Armor
Obtén más información sobre Agent Engine
Explorar Gemini Enterprise