Sichere agentische Unternehmensbereitstellungen in mehreren Clouds

1. Einführung

In diesem Codelab stellen Sie einen einzelnen Agenten bzw. eine Bereitstellung mit mehreren Tools sicher mit dem Agent Development Kit (ADK), der Agent Engine und Google Kubernetes Engine bereit. Sie erfahren, wie ein von einem Nutzer in Gemini Enterprise initiierter KI-Agent sicher in Google Cloud navigiert und dabei auf GKE Gateway mit Service Extensions zurückgreift, um vertrauliche Daten in MCP-Tool-Antworten zu entfernen.

Lerninhalte

Einen ADK-Hypothekenassistenten-Agenten mit OpenTelemetry-Instrumentierung in der Agent Engine bereitstellen
Backend-MCP-Server in Google Kubernetes Engine (GKE) hinter einem internen Gateway bereitstellen
Agent Engine über eine PSC-Schnittstelle und DNS-Peering mit einer Projekt-VPC verbinden
REST APIs als MCP-Tools über den Apigee MCP Discovery-Proxy bereitstellen
GKE Gateway für den kontrollierten Agent-Ausgang mit Service Extensions für DLP-Schwärzung und MCP-Autorisierung konfigurieren
KI-Schutzmaßnahmen mit Model Armor für die Überprüfung von Prompts und Antworten anwenden

Voraussetzungen

Ein Webbrowser wie Chrome
Ein Google Cloud-Projekt mit aktivierter Abrechnung
Grundkenntnisse zu Terraform, Kubernetes und Python

Dieses Codelab richtet sich an Entwickler und Sicherheitsexperten, die agentenbasierte Workflows in Unternehmensumgebungen bereitstellen und schützen möchten.

2. Hinweis

Erstellen Sie ein Google Cloud-Projekt und aktivieren Sie die erforderlichen APIs.

Wählen Sie in der Google Cloud Console auf der Seite zur Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

Erforderliche IAM-Rollen

In diesem Codelab wird davon ausgegangen, dass Sie die Rolle Projektinhaber für Ihr Google Cloud-Projekt haben.

APIs aktivieren

Klicken Sie in der Google Cloud Console auf Cloud Shell aktivieren: Wenn Sie Cloud Shell noch nie verwendet haben, wird ein Bereich angezeigt, in dem Sie auswählen können, ob Sie Cloud Shell in einer vertrauenswürdigen Umgebung mit oder ohne Boost starten möchten. Wenn Sie zur Autorisierung von Cloud Shell aufgefordert werden, klicken Sie auf Autorisieren.

Aktivieren Sie in Cloud Shell alle erforderlichen APIs:

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

Abhängigkeiten installieren

Prüfen Sie in Cloud Shell, ob die erforderlichen Tools installiert sind. Terraform, kubectl und Go sind in der Regel vorinstalliert. Sie müssen uv (den Python-Paketmanager) und Skaffold installieren:

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

Umgebungsvariablen festlegen

Legen Sie die folgenden Umgebungsvariablen fest, die in diesem Codelab verwendet werden:

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

Öffentliche DNS-Zone erstellen

Für dieses Codelab muss in Ihrem Projekt eine öffentliche DNS-Zone vorhanden sein, bevor Sie die Terraform-Konfiguration anwenden. Diese Zone ist für die Nameserver-Delegierung erforderlich, damit bei der Einrichtung die Erstellung der erforderlichen Datensätze für Certificate Manager automatisiert werden kann.

Führen Sie in Cloud Shell den folgenden Befehl aus, um die Zone zu erstellen:

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. GitHub-Repository klonen

Klonen Sie das cloud-networking-solutions-Repository in einem Terminal auf Ihrem lokalen Computer:
```
git clone https://github.com/googleCloudPlatform/cloud-networking-solutions.git
```

Wechseln Sie zum heruntergeladenen Repository-Verzeichnis:

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

4. Infrastruktur mit Terraform bereitstellen

Sie verwenden Terraform, um das grundlegende Netzwerk, den GKE-Cluster und die erforderlichen Identitätskonfigurationen bereitzustellen.

Wechseln Sie im geklonten Repository zum Verzeichnis terraform:
```
cd terraform
```
Konfigurieren Sie das Terraform-Backend. Erstellen Sie eine backend.conf-Datei für die teilweise Backend-Konfiguration. Ersetzen Sie durch einen global eindeutigen Bucket-Namen.
```
cat <<EOF > backend.conf
bucket = "<YOUR_TERRAFORM_STATE_BUCKET>"
prefix = "terraform"
EOF
```

Kopieren Sie die Beispielvariablendatei und aktualisieren Sie sie mit Ihren Projektwerten:
```
cp example.tfvars terraform.tfvars
```
Bearbeiten Sie terraform.tfvars und ersetzen Sie die Platzhalterwerte.Ersetzen Sie Folgendes:
- project_id: Ihre Google Cloud-Projekt-ID.
- organization_id: Ihre numerische GCP-Organisations-ID.
- dns_zone_domain: Eine Domain, die Sie kontrollieren (z.B. demo.example.com.). Muss mit einem Punkt enden.
Achten Sie darauf, dass die folgenden Funktions-Flags aktiviert sind. Sie sind in der Beispieldatei vorkonfiguriert:
- enable_certificate_manager = true
- enable_model_armor = true
- enable_agent_engine = true
- enable_psc_interface = true

Initialisieren und wenden Sie die Terraform-Konfiguration an:

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

5. Beispielarbeitslasten mit Skaffold bereitstellen

Als Nächstes stellen Sie die MCP-Server und externen Verarbeitungsservices in Ihrem GKE-Cluster bereit.

Stellen Sie eine Verbindung zum GKE-Cluster her, der mit Terraform erstellt wurde:

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

Kehren Sie zum Stammverzeichnis des Projekts zurück und konfigurieren Sie die Kubernetes-Manifestvorlagen. Kopieren Sie die Beispielkonfiguration und legen Sie Ihre Projekt-ID und Basisdomain fest:Legen Sie BASE_DOMAIN entsprechend Ihrer Umgebung fest. Die BASE_DOMAIN sollte mit Ihrer Terraform-Variablen dns_zone_domain übereinstimmen (ohne den nachgestellten Punkt).
```
export BASE_DOMAIN=example.com
```

Generieren Sie die Kubernetes-Manifeste und skaffold.yaml aus Vorlagen:

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

Stellen Sie alle Backend-Dienste bereit:

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

Stellen Sie die Gateway- und HTTPRoute-Konfiguration bereit:
```
kubectl apply -k k8s/gateway-internal/
```

6. KI-Sicherheitsmaßnahmen mit Model Armor anwenden

Sie können Entscheidungen zur Sicherheit von Inhalten, z. B. das Entfernen schädlicher Prompts oder das Verhindern von Datenlecks, an Model Armor delegieren.

Voraussetzungen: IAM-Rollen zuweisen

Sie müssen dem GKE Gateway-Dienstkonto die erforderlichen Rollen zuweisen. Das Dienstkonto hat das Format service-GATEWAY_PROJECT_NUMBER@gcp-sa-dep.iam.gserviceaccount.com.

Führen Sie die folgenden Befehle aus, um die erforderlichen Berechtigungen zu erteilen:

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

Model Armor-Autorisierungserweiterung erstellen

Definieren Sie eine Erweiterung, die auf den Model Armor-Dienst in Ihrer Region verweist. Speichern Sie diese Konfiguration als ma-content-authz-extension.yaml.

Exportieren Sie die von Terraform erstellte Model Armor-Vorlagen-ID.

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

Model Armor-Autorisierungsrichtlinie erstellen

Erstellen Sie eine Richtlinie, die die Model Armor-Erweiterung mit Ihrem Agent Gateway verknüpft. Speichern Sie diese Konfiguration als 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. Gemini Enterprise konfigurieren

Beobachtbarkeit aktivieren

Der Hypotheken-Agent wird mit OpenTelemetry-Instrumentierung und den folgenden Telemetrie-Umgebungsvariablen bereitgestellt, die standardmäßig aktiviert sind:

GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY=true
OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true
OTEL_TRACES_SAMPLER=parentbased_traceidratio

Weitere Informationen zum Konfigurieren von Traces und Spans in Gemini Enterprise finden Sie unter Einstellungen für die Beobachtbarkeit verwalten.

Model Armor in Gemini Enterprise aktivieren

Wenden Sie die Model Armor-Filterung auf den Gemini Enterprise-Assistenten an, um sowohl Nutzer-Prompts als auch Modellantworten zu prüfen. Für globale Gemini Enterprise-Apps ist eine Model Armor-Vorlage in der Multi-Region us erforderlich. Daher wird von Terraform eine separate Vorlage für diesen Zweck bereitgestellt.

Rufen Sie den Vorlagennamen aus der Terraform-Ausgabe ab:

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

Rufen Sie die APP‑ID Ihrer Gemini Enterprise-Instanz ab:

Rufen Sie in der Google Cloud Console die Seite „Gemini Enterprise“ auf.
Klicken Sie im Navigationsmenü auf „Apps“.
ID der Gemini Enterprise-Instanz kopieren

Exportieren Sie die ID als Umgebungsvariable.

export APP_ID=<PASTE_APP_ID>

Assistent patchen, um Model Armor zu aktivieren:

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

Legen Sie failureMode auf FAIL_OPEN fest, um Anfragen zuzulassen, wenn Model Armor nicht verfügbar ist, oder auf FAIL_CLOSED, um sie zu blockieren.

8. Agent bereitstellen und in Gemini Enterprise hinzufügen

Details zur Autorisierung abrufen

So rufen Sie die Autorisierungsdetails ab:

Rufen Sie in der Google Cloud Console auf der Seite „APIs & Dienste“ die Seite „Anmeldedaten“ auf.
Rufen Sie die Seite Anmeldedaten auf.
Klicken Sie auf „Anmeldedaten erstellen“ und wählen Sie „OAuth-Client-ID“ aus.
Wählen Sie unter „Anwendungstyp“ die Option „Webanwendung“ aus.
Fügen Sie im Abschnitt „Autorisierte Weiterleitungs-URIs“ die folgenden URIs hinzu:

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

Klicken Sie auf „Erstellen“.
Client-ID und Clientschlüssel für die Bereitstellung exportieren

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

Hypotheken-Agent bereitstellen

Mit dem src/mortgage-agent/deploy_agent.py-Skript wird der ADK-Agent in der Agent Engine bereitgestellt und optional in Gemini Enterprise registriert. Weitere Informationen zum Registrierungsvorgang für Gemini Enterprise finden Sie unter A2A-Agenten registrieren und verwalten.

Variablen aus der Terraform-Bereitstellung exportieren.

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)

Abhängigkeiten installieren und bereitstellen:

cd src/mortgage-agent
uv sync

Agent in Vertex Agent Engine bereitstellen und bei Gemini Enterprise registrieren:

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

Flag-Referenz

Flag	Standardeinstellung	Beschreibung
`--project`	`$PROJECT_ID`	GCP-Projekt-ID
`--dms-mcp-url`	(erforderlich)	DMS-MCP-Server-URL
`--income-verification-url`	(erforderlich)	Basis-URL der Income Verification API; `/mcp` wird automatisch angehängt
`--email-mcp-url`	(erforderlich)	E-Mail-URL des MCP-Servers
`--region`	`$REGION`	GCP-Region
`--staging-bucket`	`gs://PROJECT-staging`	GCS-Bucket für das Staging
`--display-name`	`Mortgage Assistant Agent`	Anzeigename für den bereitgestellten Agent
`--update`	(optional)	Vorhandenen Agenten direkt aktualisieren (vollständigen Ressourcennamen übergeben)
`--network-attachment`	(optional)	Netzwerkanhang für die PSC-Schnittstelle (vollständiger Pfad oder Name)
`--dns-peering-domain`	(optional)	DNS-Domain für PSC-I-DNS-Peering (muss mit einem Punkt enden)
`--dns-peering-target-project`	(optional)	Projekt, in dem das VPC-Zielnetzwerk für das DNS-Peering gehostet wird
`--dns-peering-target-network`	(optional)	VPC-Netzwerkname für DNS-Peering
`--enable-agent-identity`	`false`	Anmeldedaten mit geringsten Berechtigungen pro Agent aktivieren
`--ge-deploy`	`false`	Agent nach der Bereitstellung in Gemini Enterprise registrieren
`--app-id`	(optional)	Gemini Enterprise-Engine-ID (mit `--ge-deploy` erforderlich)
`--oauth-client-id`	`$OAUTH_CLIENT_ID`	OAuth2-Client-ID (erforderlich bei `--ge-deploy`)
`--oauth-client-secret`	`$OAUTH_CLIENT_SECRET`	OAuth2-Clientschlüssel (erforderlich bei `--ge-deploy`)
`--model`	`gemini-3.1-flash-lite-preview`	Gemini-Modellname für den KI-Agenten
`--agent-name`	`mortgage-agent`	Gemini Enterprise-Autorisierung und Agentname
`--ge-deploy-only`	(optional)	Vorhandene Problemlösungs-Engine in Gemini Enterprise registrieren, ohne sie neu bereitzustellen (vollständigen Ressourcennamen übergeben)

Nutzer mit Berechtigungen hinzufügen

Informationen zum Hinzufügen von Nutzern mit Berechtigungen zu einem ADK-Agenten über die Google Cloud Console finden Sie unter Nutzer und ihre Berechtigungen hinzufügen oder ändern.

9. Agent testen

Nachdem Sie den Agent, GKE Gateway und alle Back-End-Dienste bereitgestellt und konfiguriert haben, testen Sie den End-to-End-Ablauf, um zu prüfen, ob die Sicherheitsrichtlinien wie erwartet funktionieren. Sie interagieren über die Gemini Enterprise-Benutzeroberfläche mit dem „mortgage-agent“.

Auf den Agent zugreifen

Rufen Sie in der Google Cloud Console die Seite „Gemini Enterprise“ auf.
Wählen Sie die Gemini Enterprise-App aus, die Sie zuvor konfiguriert haben und in der der „mortgage-agent“ registriert ist.
Rufen Sie auf dem Tab „Übersicht“ die URL auf, die im Abschnitt „Ihre Gemini Enterprise-Webanwendung ist bereit“ angezeigt wird.
Wählen Sie im Menü auf der linken Seite den Tab „KI-Agent“ aus. Das Menü heißt KI-Agent-Galerie.
Sie sollten jetzt mit dem KI-Agenten „Mortgage Assistant Agent“ chatten können.

Testlauf 1: Der „Happy Path“ – Daten mit Entfernung personenidentifizierbarer Informationen zusammenfassen

Bei diesem Test wird geprüft, ob der Agent über das Agent Gateway auf Backend-Systeme zugreifen kann und ob Richtlinien zum Schutz vor Datenverlust (Data Loss Prevention, DLP) angewendet werden, um sensible Informationen zu entfernen.

Senden Sie den folgenden Prompt an den Mortgage Assistant-Agenten:

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?

Was passiert hinter den Kulissen?
- Der Agent in Gemini Enterprise formuliert Anfragen an die erforderlichen Tools (z.B. Dokumentenverwaltungssystem (DMS) für Steuererklärungen, Income Verification API).
- Model Armor untersucht die Nutzlasten von Anfragen und Antworten auf Bedrohungen.
- Die von Ihnen konfigurierte „Content-based Authorization Policy“ (Inhaltsbasierte Autorisierungsrichtlinie) löst die benutzerdefinierte DLP-Erweiterung (dlp-content-authz-ext) aus. Diese Erweiterung prüft die aus den Back-End-Systemen abgerufenen Daten.
- Der DLP-Dienst entfernt alle personenbezogenen Daten (Personally Identifiable Information, PII), z. B. Sozialversicherungsnummern, aus den Steuererklärungsdaten, bevor sie den Kundenservicemitarbeiter erreichen.
Erwartetes Ergebnis:Der Agent gibt eine Zusammenfassung der Steuererklärungen und einen Status der Einkommensüberprüfung zurück. Prüfen Sie die vom Agent bereitgestellte Zusammenfassung sorgfältig. Sie sollten darauf achten, dass sensible Informationen wie Steuernummern (SSNs) durch Platzhalter (z.B. [REDACTED]) ersetzt wurden. Dies bestätigt die Ausführung der DLP-Richtlinie über das Gateway.

Beobachtbarkeit und Auditing

Während dieser Tests werden von der Agent-Plattform und den zugehörigen Diensten Telemetriedaten erfasst:

Cloud Logging:Detaillierte Logs vom GKE Gateway, von GKE-Arbeitslasten und anderen Diensten bieten einen Audit-Trail von Anfragen, Richtlinienauswertungen und Ergebnissen.
Cloud Trace:Mit der im Agent und in den Backend-Diensten konfigurierten OpenTelemetry-Instrumentierung können Sie den gesamten Aufrufablauf von Gemini Enterprise über das GKE-Gateway bis hin zu den Backend-Tools visualisieren. Das ist sehr hilfreich beim Debuggen und um den Lebenszyklus von Anfragen nachzuvollziehen.

So rufen Sie Traces für Ihre Sitzungen auf:

Rufen Sie in der Google Cloud Console die Seite „Vertex AI Agent Engine“ auf.
Rufen Sie die Agent Engine auf. Agent Engine-Instanzen, die Teil des ausgewählten Projekts sind, werden in der Liste angezeigt. Mit dem Feld „Filter“ können Sie die Liste nach der von Ihnen angegebenen Spalte filtern.
Klicken Sie auf den Namen Ihrer Agent Engine-Instanz.
Klicken Sie auf den Tab „Traces“.
Sie können die Sitzungsansicht oder die Zeitspannenansicht auswählen.
Klicken Sie auf eine Sitzung oder einen Span, um die Tracedetails zu prüfen, einschließlich eines gerichteten azyklischen Graphen (DAG) der zugehörigen Spans, Ein- und Ausgaben sowie Metadatenattribute.

10. Optional: Transcodierung von REST APIs zu MCP mit Apigee

Unser Dienst zur Einkommensüberprüfung unterstützt das Model Context Protocol zwar nativ, viele ältere Unternehmenssysteme bieten jedoch nur RESTful APIs. In diesem optionalen Schritt verwenden Sie den Apigee MCP Discovery Proxy, um den REST-Endpunkt des Einkommensüberprüfungsdienstes in ein MCP-Tool zu transkodieren. So können Sie die erweiterten Richtlinien für Governance, Ratenbegrenzung und Sicherheit von Apigee auf Ihre Legacy-Tools anwenden.

Weitere Informationen finden Sie in der Übersicht über das Apigee MCP.

Vorbereitung

Bevor Sie fortfahren, müssen Sie Apigee API Hub bereitgestellt und konfiguriert haben. Folgen Sie der Anleitung in der Dokumentation zum Bereitstellen von API Hub, um den API-Hub einzurichten und Ihre Apigee-Instanz anzuhängen.

Schritt 1: Dienstanhang für Apigee erstellen

Damit Apigee auf Ihre internen Dienste zugreifen kann, die in GKE ausgeführt werden, müssen Sie eine Dienstanhänge erstellen.

Suchen Sie die interne Weiterleitungsregel für das GKE-Gateway:

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}')

Erstellen Sie den Dienstanhang:

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

Schritt 2: Apigee mit Terraform aktivieren

Aktualisieren Sie nun Ihre Infrastrukturkonfiguration, um die Apigee-Organisation und -Instanz bereitzustellen.

Rufen Sie das Verzeichnis terraform auf:
```
cd terraform
```
Bearbeiten Sie terraform.tfvars und legen Sie enable_apigee = true fest.
Übernehmen Sie die Änderung:
```
terraform apply
```

Schritt 3: OpenAPI-Spezifikation definieren

Apigee verwendet standardmäßige OpenAPI-Definitionen (OAS), um Tools zu erkennen und zu transkodieren. Erstellen Sie eine Datei mit dem Namen income-verification-oas.yaml und dem folgendem Inhalt:

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

Schritt 4: Apigee MCP Discovery-Proxy bereitstellen

Der MCP-Discovery-Proxy ist ein spezieller Apigee-Proxy, der als MCP-Server fungiert.

Rufen Sie in der Apigee-Benutzeroberfläche Entwickeln > API Proxys auf.
Klicken Sie auf Neu erstellen und wählen Sie MCP-Discovery-Proxy aus.
Geben Sie dem Proxy den Namen income-verification-discovery.
Laden Sie im Bereich OpenAPI-Spezifikation die von Ihnen erstellte income-verification-oas.yaml-Datei hoch.
Legen Sie die Umgebungsgruppe auf die Gruppe fest, in der Ihr internes Gateway zugänglich ist.
Klicken Sie auf Bereitstellen.

Optional: Sicherheitsrichtlinie hinzufügen

Bevor Sie Ihren Proxy bereitstellen oder freigeben, sollten Sie ihn schützen. Sie können Richtlinien hinzufügen, um Sicherheitsanforderungen wie OAuth-Tokens oder API-Schlüssel zu erzwingen. Eine Anleitung zum Hinzufügen einer Sicherheitsrichtlinie finden Sie in der Apigee-Dokumentation zum Sichern von APIs.

Schritt 5: Zugriff auf das transkodierte Tool überprüfen

Nach der Bereitstellung transcodiert Apigee den POST /verify-Endpunkt automatisch in ein verifyApplicant-MCP-Tool.

So listen Sie die Tools auf, die über den Apigee MCP-Endpunkt verfügbar sind:

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": {}
  }'

In der Antwort sollte das Tool verifyApplicant angezeigt werden, das aus Ihrer REST-Spezifikation transcodiert wurde. Sie können dieses Tool jetzt über Apigee aufrufen. Apigee übernimmt die Übersetzung in den zugrunde liegenden REST-Dienst und wendet alle von Ihnen konfigurierten Sicherheitsrichtlinien an.

Schritt 6: Mortgage Agent für die Verwendung von Apigee aktualisieren

Nachdem Apigee Ihre REST API erfolgreich in ein MCP-kompatibles Tool transcodiert hat, müssen Sie die Bereitstellungskonfiguration des Agents aktualisieren. Wenn Sie den Agent auf den Apigee-Endpunkt verweisen, profitieren alle Anfragen zur Einkommensüberprüfung von der unternehmensgerechten Sicherheit, Protokollierung und Traffic-Verwaltung von Apigee.

Apigee MCP-URL ermitteln: Ihr Endpunkt sollte dem Muster https://api.internal.${DNS_PEERING_DOMAIN%%.}/income-verification-discovery/mcp entsprechen.

Bereitstellungsscript noch einmal ausführen:Verwenden Sie das Flag --update zusammen mit dem neuen --income-verification-url. Dadurch wird der vorhandene Agent in der Agent Engine aktualisiert, ohne dass er vollständig gelöscht werden muss.

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}

Änderung bestätigen:Kehren Sie zur Gemini Enterprise-Benutzeroberfläche zurück und bitten Sie den Agenten, das Einkommen eines Bewerbers zu bestätigen.
```
"Can you verify the joint income for the Sterlings using the verification service?"
```
Auf dem Apigee Debug-Tab sollte jetzt die eingehende JSON-RPC-Anfrage vom GKE-Gateway in eine standardmäßige REST-POST-Anfrage an Ihren GKE-Backend-Dienst umgewandelt werden.

11. Bereinigen

Damit Ihrem Google Cloud-Konto die in diesem Codelab erstellten Ressourcen nicht in Rechnung gestellt werden, löschen Sie sie, wenn Sie fertig sind.

Löschen Sie den Dienstanhang, wenn er manuell erstellt wurde:

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

Wechseln Sie zum Verzeichnis terraform und löschen Sie alle Ressourcen:
```
cd terraform
terraform destroy
```
Optional: Löschen Sie das Google Cloud-Projekt vollständig:
```
gcloud projects delete ${PROJECT_ID}
```

12. Glückwunsch

Sie haben dieses Codelab abgeschlossen und gelernt, wie Sie agentische Unternehmensbereitstellungen in mehreren Clouds schützen.

Behandelte Themen

Sie haben einen ADK-Hypothekenassistenten-Agent in der Agent Engine mit OpenTelemetry-Instrumentierung bereitgestellt.
Backend-MCP-Server in GKE hinter einem internen Gateway bereitgestellt
Agent Engine über eine PSC-Schnittstelle und DNS-Peering mit einer Projekt-VPC verbunden
GKE Gateway für den kontrollierten Agent-Ausgang mit DLP-Schwärzung und MCP-Autorisierung konfiguriert
Angewendete KI-Schutzmaßnahmen mit Model Armor für die Überprüfung von Prompts und Antworten
Optional: Transcodierte REST APIs zu MCP mit dem Apigee MCP Discovery-Proxy