Protezione dei deployment aziendali multi-cloud con agenti

1. Introduzione

In questo codelab, eseguirai il deployment in modo sicuro di un singolo agente / più strumenti utilizzando Agent Development Kit (ADK), Agent Engine e Google Kubernetes Engine. Scoprirai in che modo un agente AI avviato da un utente in Gemini Enterprise naviga in modo sicuro in Google Cloud, basandosi su GKE Gateway con Service Extensions per oscurare i dati sensibili in transito dalle risposte dello strumento MCP.

Cosa imparerai

Esegui il deployment di un agente assistente per mutui ADK in Agent Engine con l'instrumentazione OpenTelemetry
Esegui il deployment dei server MCP di backend in Google Kubernetes Engine (GKE) dietro un gateway interno
Connetti Agent Engine a un VPC di progetto utilizzando un'interfaccia PSC e il peering DNS
Esporre API REST come strumenti MCP utilizzando il proxy di rilevamento MCP Apigee
Configura GKE Gateway per l'uscita controllata dell'agente con Service Extensions per la redazione DLP e l'autorizzazione MCP
Applica le protezioni dell'AI con Model Armor per il controllo di prompt e risposte

Cosa serve

Un browser web come Chrome
Un progetto cloud Google Cloud con la fatturazione abilitata
Conoscenza di base di Terraform, Kubernetes e Python

Questo codelab è rivolto a sviluppatori e professionisti della sicurezza che vogliono eseguire il deployment e proteggere i workflow agentici negli ambienti aziendali.

2. Prima di iniziare

Crea un progetto Google Cloud e abilita le API richieste.

Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .
Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.

Ruoli IAM richiesti

Questo codelab presuppone che tu disponga del ruolo Project Owner per il tuo progetto Google Cloud.

Abilita API

Nella console Google Cloud, fai clic su Attiva Cloud Shell: se non hai mai utilizzato Cloud Shell, viene visualizzato un riquadro che ti consente di avviare Cloud Shell in un ambiente attendibile con o senza boost. Se ti viene chiesto di autorizzare Cloud Shell, fai clic su Autorizza.

In Cloud Shell, abilita tutte le API richieste:

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

Installa le dipendenze

In Cloud Shell, assicurati di aver installato gli strumenti necessari. Terraform, kubectl e Go sono in genere preinstallati. Devi installare uv (il gestore dei pacchetti Python) e 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/

Imposta le variabili di ambiente

Imposta le seguenti variabili di ambiente utilizzate in questo codelab:

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

Crea una zona DNS pubblica

Questo codelab richiede che una zona DNS pubblico esista già nel tuo progetto prima di applicare la configurazione Terraform. Questa zona è necessaria per la delega del nameserver, in modo che la configurazione possa automatizzare la creazione dei record richiesti per Certificate Manager.

Esegui questo comando in Cloud Shell per creare 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. Clonare un repository GitHub

In un terminale sulla tua macchina locale, clona il repository cloud-networking-solutions:
```
git clone https://github.com/googleCloudPlatform/cloud-networking-solutions.git
```

Vai alla directory del repository scaricato:

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

4. Esegui il deployment dell'infrastruttura con Terraform

Utilizzerai Terraform per eseguire il provisioning della rete di base, del cluster GKE e delle configurazioni di identità richieste.

Vai alla directory terraform nel repository clonato:
```
cd terraform
```
Configura il backend Terraform. Crea un file backend.conf per la configurazione parziale del backend. Sostituisci con un nome di bucket univoco a livello globale.
```
cat <<EOF > backend.conf
bucket = "<YOUR_TERRAFORM_STATE_BUCKET>"
prefix = "terraform"
EOF
```

Copia il file di variabili di esempio e aggiornalo con i valori del tuo progetto:
```
cp example.tfvars terraform.tfvars
```
Modifica terraform.tfvars e sostituisci i valori segnaposto.Sostituisci quanto segue:
- project_id: l'ID progetto del tuo progetto Google Cloud.
- organization_id: l'ID numerico dell'organizzazione Google Cloud.
- dns_zone_domain: un dominio che controlli (ad es. demo.example.com.). Deve terminare con un punto.
Assicurati che i seguenti flag delle funzionalità siano abilitati (sono preconfigurati nel file di esempio):
- enable_certificate_manager = true
- enable_model_armor = true
- enable_agent_engine = true
- enable_psc_interface = true

Inizializza e applica la configurazione Terraform:

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

5. Esegui il deployment di carichi di lavoro di esempio con Skaffold

Successivamente, esegui il deployment dei server MCP e dei servizi di elaborazione esterni nel tuo cluster GKE.

Connettiti al cluster GKE creato da Terraform:

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

Torna alla radice del progetto e configura i modelli di manifest Kubernetes. Copia la configurazione di esempio e imposta l'ID progetto e il dominio di base:imposta BASE_DOMAIN in modo che corrisponda al tuo ambiente. BASE_DOMAIN deve corrispondere alla variabile Terraform dns_zone_domain (senza il punto finale).
```
export BASE_DOMAIN=example.com
```

Genera i manifest Kubernetes e skaffold.yaml dai modelli:

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

Esegui il deployment di tutti i servizi di backend:

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

Esegui il deployment della configurazione di Gateway e HTTPRoute:
```
kubectl apply -k k8s/gateway-internal/
```

6. Applicare misure di salvaguardia dell'AI con Model Armor

Puoi delegare le decisioni sulla sicurezza dei contenuti, come la rimozione di prompt dannosi o la prevenzione di fughe di dati, a Model Armor.

Prerequisiti: concedi ruoli IAM

Devi concedere i ruoli richiesti al service account GKE Gateway. Il service account segue il formato: service-GATEWAY_PROJECT_NUMBER@gcp-sa-dep.iam.gserviceaccount.com.

Esegui questi comandi per concedere le autorizzazioni necessarie:

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 l'estensione di autorizzazione Model Armor

Definisci un'estensione che rimandi al servizio Model Armor nella tua regione. Salva questa configurazione come ma-content-authz-extension.yaml.

Esporta l'ID modello Model Armor creato da 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 policy di autorizzazione Model Armor

Crea una policy che associ l'estensione Model Armor al tuo gateway degli agenti. Salva questa configurazione come 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

Abilita l'osservabilità

L'agente ipotecario viene implementato con l'instrumentazione OpenTelemetry e le seguenti variabili di ambiente di telemetria abilitate per impostazione predefinita:

GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY=true
OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true
OTEL_TRACES_SAMPLER=parentbased_traceidratio

Per informazioni dettagliate sulla configurazione di tracce e intervalli in Gemini Enterprise, vedi Gestire le impostazioni di osservabilità.

Abilitare Model Armor in Gemini Enterprise

Applica il filtro Model Armor all'assistente Gemini Enterprise per filtrare sia i prompt degli utenti che le risposte del modello. Le app Gemini Enterprise globali richiedono un modello Model Armor nella multiregione us, quindi Terraform implementa un modello separato a questo scopo.

Recupera il nome del modello dall'output di Terraform:

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

Recupera l'ID APP della tua istanza Gemini Enterprise:

Nella console Google Cloud, vai alla pagina Gemini Enterprise.
Nel menu di navigazione, fai clic su App.
Copia l'ID dell'istanza Gemini Enterprise

Esporta l'ID come variabile di ambiente.

export APP_ID=<PASTE_APP_ID>

Applica la patch all'assistente per abilitare 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"
      }
    }
  }'

Imposta failureMode su FAIL_OPEN per consentire le richieste quando Model Armor non è disponibile oppure su FAIL_CLOSED per bloccarle.

8. Esegui il deployment dell'agente e aggiungilo in Gemini Enterprise

Ottenere i dettagli dell'autorizzazione

Segui questi passaggi per ottenere i dettagli dell'autorizzazione.

Nella console Google Cloud, nella pagina API e servizi, vai alla pagina Credenziali.
Vai a Credenziali.
Fai clic su Crea credenziali e seleziona ID client OAuth.
In Tipo di applicazione, seleziona Applicazione web.
Nella sezione URI di reindirizzamento autorizzati, aggiungi i seguenti URI:

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

Fai clic su Crea.
Esporta l'ID client e il client secret per il deployment.

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

Esegui il deployment dell'agente per i mutui

Lo script src/mortgage-agent/deploy_agent.py esegue il deployment dell'agente ADK in Agent Engine e, facoltativamente, lo registra in Gemini Enterprise. Consulta Registrare e gestire un agente A2A per informazioni di base sul flusso di registrazione di Gemini Enterprise.

Esporta le variabili dal deployment 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)

Installa le dipendenze ed esegui il deployment:

cd src/mortgage-agent
uv sync

Esegui il deployment dell'agente in Vertex Agent Engine e registralo in 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

Riferimento flag

Flag	Predefinito	Descrizione
`--project`	`$PROJECT_ID`	ID progetto Google Cloud
`--dms-mcp-url`	(obbligatorio)	URL del server MCP DMS
`--income-verification-url`	(obbligatorio)	URL di base dell'API Income Verification; `/mcp` viene aggiunto automaticamente
`--email-mcp-url`	(obbligatorio)	URL del server MCP email
`--region`	`$REGION`	Regione Google Cloud
`--staging-bucket`	`gs://PROJECT-staging`	Bucket GCS per la gestione temporanea
`--display-name`	`Mortgage Assistant Agent`	Nome visualizzato dell'agente di cui è stato eseguito il deployment
`--update`	(facoltativo)	Aggiorna un agente esistente sul posto (passa il nome completo della risorsa)
`--network-attachment`	(facoltativo)	Collegamento di rete per l'interfaccia PSC (percorso completo o nome)
`--dns-peering-domain`	(facoltativo)	Dominio DNS per il peering DNS PSC-I (deve terminare con un punto)
`--dns-peering-target-project`	(facoltativo)	Progetto che ospita la rete VPC di destinazione per il peering DNS
`--dns-peering-target-network`	(facoltativo)	Nome della rete VPC per il peering DNS
`--enable-agent-identity`	`false`	Abilitare le credenziali con privilegi minimi per agente
`--ge-deploy`	`false`	Registra l'agente in Gemini Enterprise dopo il deployment
`--app-id`	(facoltativo)	ID motore Gemini Enterprise (obbligatorio con `--ge-deploy`)
`--oauth-client-id`	`$OAUTH_CLIENT_ID`	ID client OAuth2 (obbligatorio con `--ge-deploy`)
`--oauth-client-secret`	`$OAUTH_CLIENT_SECRET`	Client secret OAuth2 (obbligatorio con `--ge-deploy`)
`--model`	`gemini-3.1-flash-lite-preview`	Nome del modello Gemini per l'agente
`--agent-name`	`mortgage-agent`	Autorizzazione Gemini Enterprise e nome dell'agente
`--ge-deploy-only`	(facoltativo)	Registra un motore di ragionamento esistente in Gemini Enterprise senza eseguire nuovamente il deployment (passa il nome completo della risorsa)

Aggiungere utenti autorizzati

Per aggiungere utenti con autorizzazioni a un agente ADK utilizzando la console Google Cloud, consulta Aggiungere o modificare utenti e le relative autorizzazioni.

9. Testare l'agente

Ora che hai eseguito il deployment e la configurazione dell'agente, di GKE Gateway e di tutti i servizi di backend, testa il flusso end-to-end per verificare che le norme di sicurezza funzionino come previsto. Interagirai con l'agente "mortgage-agent" all'interno dell'interfaccia di Gemini Enterprise.

Accedere all'agente

Vai alla pagina Gemini Enterprise nella console Google Cloud.
Seleziona l'app Gemini Enterprise che hai configurato in precedenza, in cui è registrato "mortgage-agent".
Nella scheda Panoramica, vai all'URL mostrato nella sezione "La tua app web Gemini Enterprise è pronta".
Seleziona la scheda Agente dal menu a sinistra denominato Galleria agenti.
Ora dovresti essere in grado di chattare con l'agente "Assistente per i mutui".

Scenario di test 1: il "percorso felice" - riepilogo dei dati con oscuramento delle PII

Questo test verifica che l'agente possa accedere ai sistemi di backend tramite l'Agent Gateway e che i criteri di prevenzione della perdita di dati (DLP) vengano applicati per oscurare le informazioni sensibili.

Invia il seguente prompt all'agente assistente per i mutui:

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?

Cosa succede dietro le quinte:
- L'agente in Gemini Enterprise formula richieste agli strumenti necessari (ad es. il sistema di gestione dei documenti (DMS) per le dichiarazioni dei redditi, l'API per la verifica del reddito).
- Model Armor ispeziona i payload di richiesta e risposta alla ricerca di minacce.
- La "Policy di autorizzazione basata sui contenuti" che hai configurato attiva l'estensione DLP personalizzata (dlp-content-authz-ext). Questa estensione esamina i dati recuperati dai sistemi di backend.
- Il servizio DLP oscura qualsiasi informazione che consente l'identificazione personale (PII), ad esempio i numeri di previdenza sociale (SSN), dai dati della dichiarazione dei redditi prima che raggiungano l'agente.
Risultato previsto: l'agente restituirà un riepilogo delle dichiarazioni dei redditi e uno stato di verifica del reddito. Esamina attentamente il riepilogo fornito dall'agente. Dovresti notare che le informazioni sensibili, come gli ID contribuente (SSN), sono state sostituite con segnaposto (ad es. [REDACTED]). Ciò conferma l'esecuzione del criterio DLP tramite il gateway.

Osservabilità e controllo

Durante questi test, la piattaforma dell'agente e i servizi associati raccolgono dati di telemetria:

Cloud Logging:i log dettagliati del gateway GKE, dei workload GKE e di altri servizi forniscono una traccia di controllo di richieste, valutazioni delle policy e risultati.
Cloud Trace:la strumentazione OpenTelemetry configurata nei servizi di backend e dell'agente ti consente di visualizzare l'intero flusso di chiamate, da Gemini Enterprise tramite il gateway GKE agli strumenti di backend. È un aspetto di valore inestimabile per il debug e la comprensione del ciclo di vita della richiesta.

Visualizzare le tracce per le sessioni:

Nella console Google Cloud, vai alla pagina Vertex AI Agent Engine.
Vai a Agent Engine. Nell'elenco vengono visualizzate le istanze di Agent Engine che fanno parte del progetto selezionato. Puoi utilizzare il campo Filtro per filtrare l'elenco in base alla colonna specificata.
Fai clic sul nome dell'istanza Agent Engine.
Fai clic sulla scheda Tracce.
Puoi selezionare la visualizzazione Sessione o Intervallo.
Fai clic su una sessione o un intervallo per ispezionare i dettagli della traccia, inclusi un grafo diretto aciclico (DAG) dei relativi intervalli, input e output e attributi dei metadati.

10. (Facoltativo) Transcodifica delle API REST in MCP con Apigee

Sebbene il nostro servizio di verifica del reddito supporti in modo nativo il Model Context Protocol, molti sistemi legacy aziendali forniscono solo API RESTful. In questo passaggio facoltativo, utilizzerai il proxy di rilevamento MCP di Apigee per transcodificare l'endpoint REST del servizio di verifica del reddito in uno strumento MCP. In questo modo puoi applicare le norme avanzate di governance, limitazione di frequenza e sicurezza di Apigee ai tuoi strumenti legacy.

Per saperne di più, consulta la panoramica di Apigee MCP.

Prerequisiti

Prima di procedere, assicurati di aver eseguito il provisioning e la configurazione dell'hub delle API Apigee. Segui i passaggi descritti nella documentazione Provision API Hub per configurarlo e collegare l'istanza Apigee.

Passaggio 1: crea un collegamento al servizio per Apigee

Per consentire ad Apigee di raggiungere i tuoi servizi interni in esecuzione su GKE, devi creare un collegamento del servizio.

Cerca la regola di forwarding del gateway GKE interno:

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 il collegamento al servizio:

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

Passaggio 2: attiva Apigee con Terraform

Ora aggiorna la configurazione dell'infrastruttura per eseguire il provisioning dell'organizzazione e dell'istanza Apigee.

Vai alla directory terraform:
```
cd terraform
```
Modifica terraform.tfvars e imposta enable_apigee = true.
Applica le modifiche:
```
terraform apply
```

Passaggio 3: definisci la specifica OpenAPI

Apigee utilizza definizioni OpenAPI (OAS) standard per rilevare e transcodificare gli strumenti. Crea un file denominato income-verification-oas.yaml con i seguenti contenuti:

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

Passaggio 4: esegui il deployment del proxy di rilevamento MCP di Apigee

Il proxy di rilevamento MCP è un proxy Apigee specializzato che funge da server MCP.

Nell'interfaccia utente Apigee, vai a Sviluppo > Proxy API.
Fai clic su Crea nuovo e seleziona Proxy di rilevamento MCP.
Assegna un nome al proxy income-verification-discovery.
Nella sezione Specifica OpenAPI, carica il file income-verification-oas.yaml che hai creato.
Imposta il Gruppo di ambienti su quello in cui è accessibile il gateway interno.
Fai clic su Esegui il deployment.

(Facoltativo) Aggiungere una policy di sicurezza

Prima di eseguire il deployment o condividere il proxy, devi proteggerlo. Puoi aggiungere criteri per applicare requisiti di sicurezza, come token OAuth o chiavi API. Per istruzioni su come aggiungere una policy di sicurezza, consulta la documentazione di Apigee sulla protezione delle API.

Passaggio 5: verifica l'accesso allo strumento di transcodifica

Una volta eseguito il deployment, Apigee transcodifica automaticamente l'endpoint POST /verify in uno strumento MCP verifyApplicant.

Elenca gli strumenti disponibili tramite l'endpoint MCP di 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": {}
  }'

Dovresti vedere lo strumento verifyApplicant nella risposta, transcodificato dalla specifica REST. Ora puoi chiamare questo strumento tramite Apigee e Apigee gestirà la traduzione al servizio REST sottostante applicando le policy di sicurezza che hai configurato.

Passaggio 6: aggiorna l'agente ipotecario per utilizzare Apigee

Ora che Apigee ha eseguito correttamente la transcodifica della tua API REST in uno strumento conforme a MCP, devi aggiornare la configurazione di deployment dell'agente. Se indirizzi l'agente all'endpoint Apigee, tutte le richieste di verifica delle entrate ora usufruiranno della sicurezza, della registrazione e della gestione del traffico di livello aziendale di Apigee.

Identifica l'URL MCP di Apigee: l'endpoint deve seguire il pattern https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp.

Esegui di nuovo lo script di deployment: utilizza il flag --update insieme al nuovo --income-verification-url. In questo modo, l'agente esistente in Agent Engine viene aggiornato senza richiedere l'eliminazione completa.

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 la modifica:torna all'interfaccia di Gemini Enterprise e chiedi all'agente di verificare il reddito di un candidato.
```
"Can you verify the joint income for the Sterlings using the verification service?"
```
Nella scheda Apigee Debug, ora dovresti vedere la richiesta JSON-RPC in entrata dal gateway GKE trasformata in una richiesta REST POST standard al servizio GKE di backend.

11. Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse create in questo codelab, eliminale al termine.

Elimina l'allegato di servizio se è stato creato manualmente:

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

Vai alla directory terraform ed elimina tutte le risorse:
```
cd terraform
terraform destroy
```
(Facoltativo) Elimina completamente il progetto Google Cloud:
```
gcloud projects delete ${PROJECT_ID}
```

12. Complimenti

Hai completato questo codelab e hai imparato a proteggere i deployment aziendali agentici cross-cloud.

Argomenti trattati

È stato eseguito il deployment di un agente assistente per i mutui ADK in Agent Engine con l'instrumentazione OpenTelemetry
Server MCP di backend di cui è stato eseguito il deployment in GKE dietro un gateway interno
Connesso Agent Engine a un VPC di progetto utilizzando un'interfaccia PSC e il peering DNS
Configurato GKE Gateway per l'uscita controllata dell'agente con oscuramento DLP e autorizzazione MCP
Protezioni dell'AI applicate con Model Armor per lo screening di prompt e risposte
(Facoltativo) API REST transcodificate in MCP utilizzando il proxy di rilevamento MCP Apigee

Passaggi successivi

Esplora Model Armor
Scopri di più su Agent Engine
Scopri Gemini Enterprise