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-fähigen GenAI-Agenten erstellen.

Im ersten Teil dieser Reihe erfahren Sie, 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 dies für Ihr gesamtes Unternehmen einzuführen, benötigen Sie eine zentralisierte Sicherheit, standardisierte KI-Tool-Verbindungen und ein geeignetes Anwendungsframework, um die Logik des Agenten zu orchestrieren und eine vertraute Chat-Oberfläche bereitzustellen.

In diesem 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 erstellen Sie mit dem Agent Development Kit (ADK) von Google die eigentliche Agentenanwendung und verbinden sie mit Ihren MCP-Tools, einschließlich einer professionellen Web-UI.

be15d5f41f0d716c.png

Voraussetzungen

  • Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.
  • Grundlegende Kenntnisse 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. Wir stellen unten ein Schnellstartskript bereit, mit dem Sie sie neu erstellen können.

Lerninhalte

  • Verwendung des Model Context Protocol (MCP) zur Standardisierung der Interaktion von KI-Agenten mit Google Cloud-Daten.
  • Bereitstellung eines sicheren MCP-Servers in Cloud Run.
  • Erstellung eines KI-Agenten mit dem Agent Development Kit (ADK) und Verbindung mit Ihrem MCP-Backend.
  • Ausführung der integrierten Entwickler-UI des ADK zur Interaktion mit Ihrem verwalteten Agenten.

Voraussetzungen

  • Zugriff auf Google Cloud Shell

Wichtige Konzepte

  • Model Context Protocol (MCP): Stellen Sie sich MCP als ein „universelles USB-C-Kabel“ für KI-Agenten vor. Anstatt benutzerdefinierten API-Integrationscode für jedes einzelne KI-Modell zu schreiben, bietet MCP eine Standardmethode für KI, um sich sicher mit Ihren Unternehmensdaten-Tools (wie Dataplex und BigQuery) zu verbinden.
  • Agent Development Kit (ADK): Ein flexibles Open-Source-Framework von Google, das die End-to-End-Entwicklung von KI-Agenten vereinfachen soll. Es wendet Software-Engineering-Prinzipien auf die Erstellung von Agenten 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. Wenn der Vorgang abgeschlossen ist, sollte etwas Ähnliches wie hier zu sehen sein:

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"

Checkpoint: 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 einen der folgenden Pfade aus:

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

Sehr gut! Wechseln Sie zum Arbeitsverzeichnis und Sie können fortfahren.

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

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

Kein Problem! Wir haben unten einen Schnellstart-Befehlsblock bereitgestellt. 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 erfolgreich mit der Gemini CLI getestet. Das ist hervorragend für schnelles Prototyping geeignet, wird aber lokal mit Ihren persönlichen Nutzeranmeldedaten ausgeführt.

In einer echten Unternehmensumgebung benötigen Sie eine zentralisierte Datensteuerungsebene. Dazu verwenden wir die GenAI Toolbox for Databases, ein offizielles Open-Source-Projekt von Google. Diese Toolbox bietet einen vorgefertigten MCP-Server, der speziell für die sichere Verbindung von KI-Agenten mit Google Cloud-Datenbanken und Metadatendiensten wie Dataplex entwickelt wurde.

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

  1. Zentralisierte 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 standardmäßige MCP-Protokoll mit diesem Server verbinden.
  3. Kontrollierter Umfang (geringste Berechtigung): Wir gewähren dem LLM keinen uneingeschränkten Zugriff auf BigQuery. Es muss zuerst den Dataplex-Metadatenkatalog durchlaufen.

Tooldefinition konfigurieren (tools.yaml)

Für die GenAI Toolbox ist eine deklarative Konfigurationsdatei erforderlich: tools.yaml. In dieser Datei werden die sources (Verbindungsziel) und die tools (zulässige Aktionen der KI) definiert.

  1. Wechseln Sie zum Serververzeichnis 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

Sie sollte mit dem folgenden Snippet identisch sein. Prüfen Sie, ob das Feld „project“ 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 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

Prinzip der geringsten Berechtigung implementieren (IAM)

Als Nächstes erstellen wir ein dediziertes Dienstkonto für den MCP-Server der GenAI Toolbox. 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 verwaltete API eingerichtet. Anstatt Ihrem GenAI-Frontend direkten Datenbankzugriff zu gewähren, wird es eine Verbindung zu dieser Cloud Run-URL herstellen. Der Agent kann nur sehen, was diese Toolbox ihm erlaubt.

4. Agenten-Backend mit ADK erstellen

Sie haben eine sichere, verwaltete Datensteuerungsebene (MCP) eingerichtet, die in Cloud Run ausgeführt wird. Jetzt benötigt Ihr KI-Agent 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 gesamten 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 enthält es eine integrierte Entwickler-UI, mit der Sie den Reasoning-Prozess und die Toolaufrufe des Agenten sofort visualisieren können, ohne zuerst ein benutzerdefiniertes Frontend erstellen zu müssen.

Agentenlogik 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. Sie 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 Definition tools.yaml 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. Agentenorchestrierung: Die Klasse Agent(...) bindet das Gemini-Modell, den Systemprompt und die MCP-Tools zusammen. Bei der Bereitstellung konvertiert das ADK dieses Objekt automatisch in einen skalierbaren FastAPI-Endpunkt.

Aufgabentrennung: Frontend-Identität konfigurieren

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

Außerdem erstellen wir eine separate Identität (dataplex-agent-sa) für diese nutzerorientierte Anwendung. Durch diese Aufgabentrennung hat der Frontend-Agent andere Berechtigungen als der Backend-Governance-Server.

Führen Sie die folgenden Befehle aus, um die Umgebung und die 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 verwendet Umgebungsvariablen, um den Kontext zu verstehen. Wir müssen die Projekt-ID und die Region explizit festlegen und die Vertex AI-Nutzung aktivieren. Wir fügen diese der gleichen .env-Datei hinzu.

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, um Antworten in natürlicher Sprache zu generieren.
  2. Cloud Run-Invoker: Zum sicheren Aufrufen Ihrer MCP-Server-API. Er erhält keinen direkten Zugriff auf BigQuery oder Dataplex.
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 vollständigen 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 der ADK Web Playground für das Debugging 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

Nach Abschluss dieses Befehls wird eine Dienst-URL ausgegeben (e.g., https://dataplex-agent-xyz.run.app). Klicken Sie auf diesen Link, um Ihre vollständig verwaltete GenAI-Chatoberfläche zu öffnen.

12a5fa4c2aaf381f.png

End-to-End-Architekturablauf

Sie haben das System jetzt fertiggestellt. Wenn ein Nutzer mit der ADK-UI interagiert, geschieht Folgendes:

  1. Der Nutzer sendet einen Prompt im ADK-Agenten (Entwickler-UI).
  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 die Dataplex-Governance-Regeln und gibt die Metadaten zurück.
  5. Gemini synthetisiert die vertrauenswürdige Antwort auf Grundlage der Metadaten und gibt sie an den Nutzer zurück.

5. Unternehmensagent testen

Nachdem Ihr Agent jetzt aktiv ist, sehen wir uns die Governance-Szenarien noch einmal an, die wir zuvor mit der CLI getestet haben. Die Logik bleibt gleich, aber Sie interagieren jetzt mit dem bereitgestellten ADK Web Playground, der den internen Status und die Toolausführungen visualisiert.

  1. Orchestrierung: Der ADK-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?"

Beobachten Sie den Reasoning-Prozess des Agenten in der Entwickler-UI:

  1. Absichtserkennung: Der Agent analysiert „jetzt“ und „kann nicht bis morgen warten“.
  2. Metadatensuche: Er ruft das MCP-Tool search_aspect_types auf. Er sucht nach Daten-Assets, bei denen der Aspekt update_frequency auf „REALTIME“ oder „STREAMING“ und nicht auf „DAILY“ oder „MONTHLY“ festgelegt ist.
  3. Auswahl: Er stellt fest, dass die Tabelle mkt_realtime_campaign_performance diese Kriterien erfüllt, während fin_monthly_closing_internal (obwohl sie von hoher Qualität ist) für Ihre Anfrage zu langsam ist.
  4. Antwort: Der 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, einfach weil sie eine Spalte mit dem Namen „ad_spend“ hat. Dabei würde ignoriert, dass die Daten 24 Stunden alt sind. Ihr Metadatenkontext hat einen Geschäftsfehler verhindert.

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

"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. Zerstören Sie dazu die gesamte Infrastruktur, die in Teil 1 und Teil 2 erstellt wurde.

Data Lake 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 Compute-Ressourcen, 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-Speicher 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 bestehen 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

Bereinigen Sie schließlich 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 End-to-End-GenAI-Agenten mit Governance-Funktionen bereitgestellt.

In diesem zweiteiligen Codelab sind Sie über das einfache Prompt-Engineering hinausgegangen und haben eine robuste, produktionsreife Architektur implementiert. Indem Sie Data Governance als Voraussetzung für GenAI betrachtet haben, haben Sie eine systematische Methode entwickelt, 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 der Spaltennamen errät, haben Sie mit der GenAI Toolbox for Databases einen strengen Reasoning-Loop erzwungen. Indem Sie nur drei Dataplex-Tools explizit bereitgestellt haben (search_aspect_types, search_entries, lookup_entry), haben Sie das Modell gezwungen, Datenzertifizierungen zu prüfen, bevor Antworten synthetisiert werden.
  • Entkoppelte Architektur (MCP): Durch die Bereitstellung des MCP-Servers (Model Context Protocol) in Cloud Run haben Sie Ihre Data Governance-Regeln in eine zentralisierte, standardisierte API abstrahiert. Der Frontend-Agent muss keine Datenbanklogik enthalten, sondern nur über den MCP-Standard kommunizieren. So können Sie jedes zukünftige KI-Modell oder jeden zukünftigen Client in dasselbe verwaltete Backend einbinden.
  • Aufgabentrennung: Sie haben das Prinzip der geringsten Berechtigung angewendet, indem Sie IAM-Identitäten isoliert haben. Der nutzerorientierte ADK-Agent 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-Agentenorchestrierung: Sie haben das Agent Development Kit (ADK) von Google verwendet, um Ihre Python-Agentenlogik sofort in ein skalierbares FastAPI-Backend einzubinden. Dabei haben Sie die integrierte Entwickler-UI genutzt, um die internen Toolausführungen des Agenten zu visualisieren und zu debuggen.

Nächste Schritte

  • Dataplex Foundational Governance Codelab: Machen Sie sich mit den Grundlagen der Data Governance in Dataplex vertraut, bevor Sie die KI-Ebene hinzufügen.
  • Dataplex-Tools-Dokumentation: Sehen Sie sich die offizielle Dokumentation für die vorgefertigten Dataplex-Tools und ‑Erweiterungen an, die in diesem Lab verwendet werden.
  • Erste Schritte mit Gemini CLI-Erweiterungen: Erfahren Sie, wie Sie eigene benutzerdefinierte Erweiterungen erstellen, um Ihren GenAI-Agenten noch mehr Funktionen zu geben.
  • Deep Dive in MCP: Sehen Sie sich die offizielle MCP-Spezifikation an, um zu erfahren, wie Sie benutzerdefinierte Server für Ihre internen Unternehmens-APIs erstellen.