Enterprise Governance-Aware Agent mit MCP und Cloud Run bereitstellen

1. Einführung

Dieses Codelab ist Teil einer zweiteiligen Reihe, in der es darum geht, wie Sie einen Governance-konformen GenAI-Agent erstellen.

Im ersten Teil dieser Reihe wird beschrieben, wie Sie die Datengrundlage schaffen, indem Sie Dataplex-Aspekte auf BigQuery-Tabellen anwenden und die Regeln lokal über die Gemini CLI testen. 👉 Teil 1 lesen)

Das Testen in einer lokalen CLI ist jedoch nur der Anfang. Um diese Lösung im gesamten Unternehmen einzuführen, benötigen Sie eine zentrale Sicherheitslösung, standardisierte Verbindungen zu KI-Tools und ein geeignetes Anwendungs-Framework, um die Logik des Agenten zu orchestrieren und eine vertraute Chatoberfläche bereitzustellen.

Im zweiten Teil lösen Sie diese Herausforderungen und skalieren auf die Produktion. Sie stellen Ihre Governance-Regeln auf einem zentralen MCP-Server bereit, der in Cloud Run gehostet wird. Anschließend verwenden Sie das Agent Development Kit (ADK) von Google, um die eigentliche Agentenanwendung zu erstellen und sie mit Ihren MCP-Tools zu verbinden. Das Ganze wird durch eine professionelle Web-UI ergänzt.

be15d5f41f0d716c.png

Voraussetzungen

  • Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.
  • Grundlegendes Verständnis von Cloud Run, IAM-Dienstkonten und Python.
  • Die in Teil 1 erstellten BigQuery-Datasets und Dataplex-Aspekte. Keine Sorge, wenn Sie sie gelöscht haben. Unten finden Sie ein Script, mit dem Sie sie schnell wiederherstellen können.

Lerninhalte

  • Verwendung des Model Context Protocol (MCP) zur Standardisierung der Interaktion von KI-Agenten mit Google Cloud-Daten.
  • So stellen Sie einen sicheren MCP-Server in Cloud Run bereit.
  • Einen KI-Agenten mit dem Agent Development Kit (ADK) erstellen und mit Ihrem MCP-Backend verbinden
  • So führen Sie die integrierte Entwickler-UI des ADK aus, um mit Ihrem geregelten Agenten zu interagieren.

Voraussetzungen

  • Zugriff auf Google Cloud Shell

Wichtige Konzepte

  • Model Context Protocol (MCP): Das MCP ist wie ein „universelles USB‑C-Kabel“ für KI‑Agenten. Anstatt für jedes einzelne KI-Modell benutzerdefinierten API-Integrationscode zu schreiben, bietet MCP eine standardisierte Möglichkeit für KI, eine sichere Verbindung zu Ihren Unternehmensdatentools (z. B. Dataplex und BigQuery) herzustellen.
  • Agent Development Kit (ADK): Ein flexibles Open-Source-Framework von Google, das die End-to-End-Entwicklung von KI-Agenten vereinfacht. Es wendet Software-Engineering-Prinzipien auf die Erstellung von Agents an, sodass Sie komplexe Tools orchestrieren, den Status verwalten und ganz einfach eine integrierte Entwickler-UI für Tests und die Bereitstellung starten können.

2. Einrichtung und Anforderungen

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:

Cloud Shell aktivieren

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Anschließend sehen Sie in etwa Folgendes:

Screenshot des Google Cloud Shell-Terminals, auf dem zu sehen ist, dass die Umgebung verbunden ist

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.

Umgebung initialisieren

Öffnen Sie Cloud Shell und legen Sie Ihre Projektvariablen fest, damit alle Befehle auf die richtige Infrastruktur ausgerichtet sind.

export PROJECT_ID=$(gcloud config get-value project)
gcloud config set project $PROJECT_ID
export REGION="us-central1"

Prüfpunkt: Fortsetzen oder neu erstellen?

Da dies Teil 2 ist, benötigt Ihr Agent die verwalteten Daten aus Teil 1, um zu funktionieren. Wählen Sie Ihren Weg aus:

Pfad A: Ich habe Teil 1 gerade abgeschlossen und meine Ressourcen werden noch ausgeführt.

Sehr gut! Wechseln Sie zum Arbeitsverzeichnis.

cd ~/devrel-demos/data-analytics/governance-context

Pfad B: Ich habe Teil 1 übersprungen ODER ich habe meine Ressourcen gelöscht (bereinigt).

Kein Problem! Unten finden Sie einen „Fast-Track“-Befehlsblock. Dadurch wird der BigQuery-Data Lake automatisch neu erstellt und die Dataplex-Governance-Metadaten werden genau wie in Teil 1 angewendet.

# 1. Clone the repo and navigate to the working directory
git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git
cd devrel-demos
git sparse-checkout set data-analytics/governance-context
cd data-analytics/governance-context

# 2. Rebuild the messy data lake with Terraform
cd terraform
terraform init
terraform apply -var="project_id=${PROJECT_ID}" -var="region=${REGION}" -auto-approve

# 3. Generate and apply Dataplex Aspects (Governance rules)
cd ..
chmod +x ./generate_payloads.sh ./apply_governance.sh
./generate_payloads.sh
./apply_governance.sh

3. Mit MCP skalieren: Die Datensteuerungsebene erstellen

Bisher haben Sie Ihre Governance-Logik mit der Gemini CLI getestet. Das ist ideal für schnelles Prototyping, aber es wird lokal mit Ihren persönlichen Nutzeranmeldedaten ausgeführt.

In einer echten Unternehmensumgebung benötigen Sie eine zentrale Steuerungsebene für Daten. Dazu verwenden wir die GenAI Toolbox for Databases, ein offizielles Open-Source-Projekt von Google. Diese Toolbox enthält einen vorgefertigten MCP-Server, der speziell dafür entwickelt wurde, KI-Agents sicher mit Google Cloud-Datenbanken und Metadatendiensten wie Dataplex zu verbinden.

Durch die Bereitstellung dieser Toolbox als MCP-Server in Cloud Run erreichen wir Folgendes:

  1. Zentrale Identität:Der Agent wird als eingeschränktes Dienstkonto und nicht als Ihr persönliches Nutzerkonto ausgeführt.
  2. Standardisierung:Jeder Client (ADK, Gemini, benutzerdefinierte Apps) kann sich über das Standard-MCP-Protokoll mit diesem Server verbinden.
  3. Kontrollierter Umfang (geringste Berechtigung): Das LLM hat keinen uneingeschränkten Zugriff auf BigQuery. Wir erzwingen, dass zuerst der Dataplex-Metadatenkatalog durchsucht wird.

Tooldefinition konfigurieren (tools.yaml)

Für die GenAI Toolbox ist eine deklarative Konfigurationsdatei, tools.yaml, erforderlich. In dieser Datei werden die sources (wo die Verbindung hergestellt werden soll) und die tools (was die KI tun darf) definiert.

  1. Rufen Sie das Serververzeichnis auf und fügen Sie Ihre Projekt-ID in die Konfigurationsdatei ein:
cd ~/devrel-demos/data-analytics/governance-context/mcp_server
envsubst < tools.yaml > tools.tmp && mv tools.tmp tools.yaml
cat tools.yaml

Es sollte mit dem folgenden Snippet identisch sein. Prüfen Sie, ob das Projektfeld jetzt mit Ihrer tatsächlichen Google Cloud-Projekt-ID übereinstimmt.

sources:
  dataplex:
    kind: dataplex
    project: YOUR-PROJECT-ID

tools:
  search_entries:
    kind: dataplex-search-entries
    source: dataplex
    description: Search for entries in Dataplex Catalog.

  lookup_entry:
    kind: dataplex-lookup-entry
    source: dataplex
    description: Retrieve a specific entry from Dataplex Catalog.

  search_aspect_types:
    kind: dataplex-search-aspect-types
    source: dataplex
    description: Find aspect types relevant to a query.

toolsets:
  dataplex-toolset:
    - search_entries
    - lookup_entry
    - search_aspect_types

Durch die Definition dieser drei Tools können wir die KI dazu zwingen, „schreibgeschützt“ und „Governance-first“ zu sein.

Konfiguration sichern (Secret Manager)

In der Unternehmensarchitektur sollten Sie Konfigurationsdateien niemals direkt in Container-Images einbetten. Wir speichern tools.yaml sicher in Google Cloud Secret Manager.

gcloud services enable secretmanager.googleapis.com
gcloud secrets create dataplex-tools-config --data-file=tools.yaml

Geringste Berechtigung implementieren (IAM)

Als Nächstes erstellen wir ein dediziertes Dienstkonto für den GenAI Toolbox MCP-Server. Diese Identität hat nur die Berechtigungen, die zum Lesen des Dataplex-Katalogs und zum Zugriff auf BigQuery-Daten erforderlich sind.

export MCP_SA=mcp-sa
gcloud iam service-accounts create ${MCP_SA} \
    --display-name="Service Account for Dataplex MCP"
export MCP_SERVICE_ACCOUNT="${MCP_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

# Allow the server to read its own config from Secret Manager
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/secretmanager.secretAccessor"

# Allow the server to read Dataplex Metadata and BigQuery Data
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/dataplex.catalogViewer"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/bigquery.dataViewer"

MCP-Server in Cloud Run bereitstellen

Jetzt stellen wir die GenAI Toolbox bereit. Wir verwenden das vorgefertigte Container-Image von Google (database-toolbox/toolbox) und stellen unsere Konfiguration aus Secret Manager (--set-secrets) zur Laufzeit bereit.

export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest

gcloud run deploy governance-mcp \
    --image=$IMAGE \
    --service-account $MCP_SERVICE_ACCOUNT \
    --region=$REGION \
    --no-allow-unauthenticated \
    --set-secrets="/app/tools.yaml=dataplex-tools-config:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080"

Sie haben jetzt eine API mit Governance eingerichtet. Anstatt Ihrem GenAI-Frontend direkten Datenbankzugriff zu gewähren, wird es mit dieser Cloud Run-URL verbunden. Der KI-Agent kann nur sehen, was diese Toolbox ihm erlaubt.

4. Agent-Backend mit dem ADK erstellen

Sie haben eine sichere, verwaltete Data Control Plane (MCP) eingerichtet, die in Cloud Run ausgeführt wird. Ihr KI-Agent benötigt nun ein Framework, um seine Logik zu orchestrieren, z. B. die Verarbeitung von Nutzereingaben, die Entscheidung, wann der MCP-Server aufgerufen werden soll, und die Formatierung der Ausgabe.

Anstatt diesen ganzen Boilerplate-Code von Grund auf neu zu schreiben, verwenden wir das Agent Development Kit (ADK) von Google. Das ADK ist ein Code-First-Framework, das Ihre Agentenlogik automatisch in ein FastAPI-Backend einbindet. Außerdem ist eine integrierte Entwickler-UI enthalten, mit der Sie den Entscheidungsprozess und die Tool-Aufrufe des Agents sofort visualisieren können, ohne zuerst ein benutzerdefiniertes Frontend erstellen zu müssen.

Agent-Logik prüfen (agent.py)

Bevor wir die Infrastruktur konfigurieren, sehen wir uns den Kern dieser Anwendung an.

Wechseln Sie zum Verzeichnis und geben Sie den Inhalt von „agent.py“ aus. Diese Datei ist das „Gehirn“ Ihrer ADK-Bereitstellung.

cd ~/devrel-demos/data-analytics/governance-context/mcp_server
cat agent.py

Sehen Sie sich die Codestruktur an. Es führt drei wichtige Funktionen mit minimalem Boilerplate-Code aus:

  1. MCPToolset-Integration:Anstatt benutzerdefinierte HTTP-Clients für die Interaktion mit Ihren Dataplex-Tools zu schreiben, verwendet das ADK MCPToolset(server_url=mcp_url). Dadurch wird die tools.yaml-Definition dynamisch von Ihrem bereitgestellten MCP-Server abgerufen und in native Funktionsaufrufe für das LLM übersetzt.
  2. Systemanweisungen:Der Parameter instructions enthält die strengen Governance-Regeln (dieselbe Logik, die wir in der CLI GEMINI.md verwendet haben). Er weist das Modell explizit an, den Reasoning-Loop von Phase 1 (Metadatensuche) bis Phase 2 (Datenabfrage) auszuführen.
  3. Agent-Orchestrierung:Die Klasse Agent(...) bindet das Gemini-Modell, den System-Prompt und die MCP-Tools zusammen. Bei der Bereitstellung wandelt ADK dieses Objekt automatisch in einen skalierbaren FastAPI-Endpunkt um.

Aufgabentrennung: Frontend-Identität konfigurieren

Damit dieser Code sicher ausgeführt werden kann, müssen wir dem Agent mitteilen, wo sich Ihr MCP-Server befindet. Wir erstellen die URL dynamisch und speichern sie in einer .env-Datei, die vom ADK zur Laufzeit gelesen wird.

Wir erstellen auch eine separate Identität (dataplex-agent-sa) für diese nutzerorientierte Anwendung. Durch diese Trennung der Aufgaben hat der Frontend-Agent andere Berechtigungen als der Backend-Governance-Server.

Führen Sie die folgenden Befehle aus, um die Umgebung und Identität zu konfigurieren:

export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
export MCP_SERVER_URL=https://governance-mcp-${PROJECT_NUMBER}.${REGION}.run.app/mcp

export AGENT_SA=dataplex-agent-sa
export AGENT_SERVICE_ACCOUNT="${AGENT_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

gcloud iam service-accounts create ${AGENT_SA} \
    --display-name="Service Account for Dataplex Agent "

Laufzeitvariablen konfigurieren

Das ADK-Framework stützt sich auf Umgebungsvariablen, um den Kontext zu verstehen. Wir müssen die Projekt-ID und die Region explizit festlegen und die Vertex AI-Nutzung aktivieren. Wir hängen sie an dieselbe Datei .env an.

echo MCP_SERVER_URL=$MCP_SERVER_URL > .env
echo GOOGLE_GENAI_USE_VERTEXAI=1 >> .env
echo GOOGLE_CLOUD_PROJECT=$PROJECT_ID >> .env
echo GOOGLE_CLOUD_LOCATION=$REGION >> .env

Berechtigungen erteilen

Auch wenn der Agent Governance-Prüfungen an den MCP-Server delegiert, benötigt er grundlegende Berechtigungen, um zu funktionieren. Wir gewähren genau zwei Rollen:

  1. Vertex AI-Nutzer:Zum Aufrufen des Gemini-Modells zum Generieren von Antworten in natürlicher Sprache.
  2. Cloud Run-Invoker:Zum sicheren Aufrufen der MCP-Server-API. Er erhält keinen direkten BigQuery- oder Dataplex-Zugriff.
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/aiplatform.user"

gcloud run services add-iam-policy-binding governance-mcp \
  --region=$REGION \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/run.invoker"

In Cloud Run bereitstellen

Schließlich stellen wir den gesamten Stack in Cloud Run bereit.

Wir verwenden uvx, um das ADK-Tool auszuführen, ohne Abhängigkeiten manuell installieren zu müssen. Mit dem folgenden Befehl wird Ihre agent.py-Logik verpackt, ein Container-Image erstellt, Ihr Dienstkonto eingefügt und ein FastAPI-Server gestartet. Durch Hinzufügen des Flags --with_ui wird auch das ADK Web Playground zum Debuggen gebündelt.

Mit diesem Befehl wird der Container erstellt und bereitgestellt. Das kann 1–3 Minuten dauern.

uvx --from google-adk \
adk deploy cloud_run \
  --project=$PROJECT_ID \
  --region=$REGION \
  --service_name=dataplex-agent \
  --with_ui \
  . \
  -- \
  --service-account=$AGENT_SERVICE_ACCOUNT \
  --allow-unauthenticated

Nachdem dieser Befehl ausgeführt wurde, wird eine Service-URL (e.g., https://dataplex-agent-xyz.run.app) ausgegeben. Klicken Sie auf diesen Link, um die vollständig verwaltete Chat-Oberfläche für generative KI zu öffnen.

12a5fa4c2aaf381f.png

End-to-End-Architekturfluss

Sie haben das System jetzt fertiggestellt. Wenn ein Nutzer mit der ADK-Benutzeroberfläche interagiert, läuft Folgendes ab:

  1. Der Nutzer sendet einen Prompt im ADK-KI-Agenten (Entwicklungsoberfläche).
  2. Der ADK-Agent (agent.py) verarbeitet die Eingabe und ruft das Gemini-Modell auf.
  3. Gemini stellt fest, dass Kontext erforderlich ist, und fordert den MCP-Server auf, die Dataplex-Tools auszuführen.
  4. Der MCP-Server erzwingt Dataplex-Governance-Regeln und gibt die Metadaten zurück.
  5. Gemini fasst die vertrauenswürdige Antwort auf Grundlage der Metadaten zusammen und gibt sie an den Nutzer zurück.

5. Enterprise-Agent testen

Nachdem Ihr KI-Agent jetzt aktiv ist, sehen wir uns die zuvor mit der CLI getesteten Governance-Szenarien noch einmal an. Die Logik bleibt dieselbe, aber Sie interagieren jetzt mit dem bereitgestellten ADK Web Playground, in dem der interne Status und die Tool-Ausführungen visualisiert werden.

  1. Orchestrierung:Der ADK-KI-Agent (der in Cloud Run ausgeführt wird) empfängt Ihren Text.
  2. Tool-Routing:Gemini erkennt, dass für Ihre Frage Datenkontext erforderlich ist, und leitet die Anfrage an den MCP-Server weiter.
  3. Governance-Prüfung:Der MCP-Server (der in einer separaten Cloud Run-Instanz ausgeführt wird) fragt Dataplex nach bestimmten Aspekttypen ab.
  4. Synthese:Die relevanten Metadaten werden an Gemini zurückgegeben, um die endgültige Antwort zu generieren.

Governance-Logik prüfen

Öffnen Sie die Dienst-URL, die Sie im vorherigen Schritt generiert haben (e.g., https://dataplex-agent-xyz.run.app), in Ihrem Browser. Fügen Sie den folgenden Prompt ein:

"My dashboard needs to show what's happening right now with our ad spend. I can't wait for the overnight load. What do you recommend?"

Reasoning-Prozess des KI-Agenten in der Entwickler-UI beobachten:

  1. Absichtserkennung:Der Agent analysiert „jetzt“ und „kann nicht bis morgen warten“.
  2. Metadaten-Lookup:Das MCP-Tool search_aspect_types wird aufgerufen. Es wird nach Datenassets gesucht, bei denen das update_frequency-Attribut auf REALTIME oder STREAMING und nicht auf DAILY oder MONTHLY festgelegt ist.
  3. Auswahl:Die Tabelle mkt_realtime_campaign_performance erfüllt diese Kriterien, während fin_monthly_closing_internal (obwohl sie von hoher Qualität ist) für Ihre Anfrage zu langsam ist.
  4. Antwort:Der KI-Agent empfiehlt die Echtzeittabelle.

e0da615724199e.png

Warum das wichtig ist:

Ohne diese Governance-Metadaten würde ein LLM wahrscheinlich die Tabelle fin_monthly_closing_internal empfehlen, weil sie eine Spalte mit dem Namen „ad_spend“ enthält. Dabei würde ignoriert, dass die Daten 24 Stunden alt sind. Der Metadatenkontext hat einen geschäftlichen Fehler verhindert.

Sie können auch den Prompt „Board Meeting“ testen, um zu sehen, wie der Agent basierend auf dem Aspekt „Data Product Tier“ (Datenproduktstufe) auf verschiedene Tabellen umstellt:

"We are preparing the deck for an internal Board of Directors meeting next week. I need the numbers to be absolutely finalized, trustworthy, and kept strictly confidential. Which table is safe to use?"

6. Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in diesem Codelab verwendeten Ressourcen in Rechnung gestellt werden. Dazu müssen Sie die gesamte in Teil 1 und Teil 2 erstellte Infrastruktur entfernen.

Datalake löschen (Terraform)

Verwenden Sie Terraform, um die BigQuery-Tabellen, ‑Datasets und Dataplex-Aspektdefinitionen zu entfernen.

cd ~/devrel-demos/data-analytics/governance-context/terraform
terraform destroy -var="project_id=${PROJECT_ID}" -var="region=${REGION}" -auto-approve

Cloud Run-Dienste löschen

Entfernen Sie die Computeressourcen, um die aktive Abrechnung für die ausgeführten Container zu beenden.

gcloud run services delete governance-mcp --region=$REGION --quiet
gcloud run services delete dataplex-agent --region=$REGION --quiet

Build-Artefakte und Staging-Speicherplatz bereinigen

Als Sie den ADK-Agenten mit uvx bereitgestellt haben, hat das System automatisch ein Container-Image erstellt und Ihren Quellcode in einen temporären Cloud Storage-Bucket hochgeladen. Diese Artefakte bleiben auch nach dem Löschen des Cloud Run-Dienstes erhalten und verursachen laufende Speicherkosten.

Entfernen Sie das Artifact Registry-Repository und den Cloud Storage-Staging-Bucket:

# Delete the repository used for the agent build
gcloud artifacts repositories delete cloud-run-source-deploy \
    --location=$REGION \
    --quiet

# Delete the staging bucket created by Cloud Run source deploy
gcloud storage rm --recursive gs://run-sources-${PROJECT_ID}-${REGION}

Identität, Berechtigungen und Secrets löschen

Entfernen Sie zuerst die IAM-Richtlinienbindungen, damit keine „Tombstone“-Einträge (verwaiste Datensätze) auf der IAM-Seite Ihres Projekts verbleiben. Löschen Sie dann die Dienstkonten und Konfigurations-Secrets.

# Remove IAM roles granted to the MCP Service Account
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/secretmanager.secretAccessor" --quiet
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/dataplex.catalogViewer" --quiet
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/bigquery.dataViewer" --quiet

# Remove IAM roles granted to the Agent Service Account
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/aiplatform.user" --quiet

# Delete the Service Accounts
gcloud iam service-accounts delete $MCP_SERVICE_ACCOUNT --quiet
gcloud iam service-accounts delete $AGENT_SERVICE_ACCOUNT --quiet

# Delete the Secret Manager entry
gcloud secrets delete dataplex-tools-config --quiet

Lokale Konfiguration entfernen

Löschen Sie zum Schluss die lokalen Konfigurationsdateien und Umgebungsvariablen in Cloud Shell.

# Uninstall the Gemini CLI extension (installed in Part 1)
gemini extensions uninstall dataplex

# Remove local repository files and unset variables
cd ~
rm -rf ~/devrel-demos
unset MCP_SERVER_URL
unset MCP_SERVICE_ACCOUNT
unset AGENT_SERVICE_ACCOUNT

7. Glückwunsch!

Sie haben einen Governance-konformen GenAI-Agenten mit End-to-End-Funktionalität erfolgreich bereitgestellt.

In diesem zweiteiligen Codelab haben Sie eine robuste, produktionsreife Architektur implementiert, die über einfaches Prompt Engineering hinausgeht. Wenn Sie Data Governance als Voraussetzung für GenAI betrachten, haben Sie eine systematische Methode eingeführt, um zu verhindern, dass das Modell nicht zertifizierte oder halluzinierte Daten abruft.

Zusammenfassung

  • Deterministische KI durch Metadaten:Anstatt sich darauf zu verlassen, dass das LLM die richtige Tabelle anhand von Spaltennamen errät, haben Sie einen strengen Reasoning-Loop mit der GenAI-Toolbox für Datenbanken erzwungen. Indem Sie nur drei Dataplex-Tools (search_aspect_types, search_entries, lookup_entry) explizit zur Verfügung gestellt haben, wurde das Modell gezwungen, Datenzertifizierungen zu prüfen, bevor es Antworten synthetisiert.
  • Entkoppelte Architektur (MCP): Durch die Bereitstellung des MCP-Servers (Model Context Protocol) in Cloud Run haben Sie Ihre Regeln für die Datenverwaltung in einer zentralisierten, standardisierten API abstrahiert. Der Frontend-Agent muss keine Datenbanklogik enthalten, sondern nur über den MCP-Standard kommunizieren. Das bedeutet, dass Sie jedes zukünftige KI‑Modell oder jeden zukünftigen Client an dasselbe verwaltete Backend anschließen können.
  • Aufgabentrennung:Sie haben das Prinzip der geringsten Berechtigung angewendet, indem Sie IAM-Identitäten isoliert haben. Der ADK-Agent für Nutzer arbeitet mit Berechtigungen, die auf den Modellaufruf und das API-Routing beschränkt sind, während der Backend-MCP-Server Dataplex-Katalogabfragen und den Abruf von BigQuery-Daten sicher verarbeitet.
  • Code-First-Agent-Orchestration:Sie haben das Google Agent Development Kit (ADK) verwendet, um Ihre Python-Agent-Logik sofort in ein skalierbares FastAPI-Backend zu verpacken. Dabei haben Sie die integrierte Entwickler-UI genutzt, um die internen Tool-Ausführungen des Agents zu visualisieren und zu debuggen.

Wie geht es weiter?