Eine agentische KI-Anwendung in GKE mit dem Agent Development Kit (ADK) und Vertex AI bereitstellen

In diesem Leitfaden wird beschrieben, wie Sie containerisierte agentische KI-/ML-Anwendungen mit der Google Kubernetes Engine (GKE) bereitstellen und verwalten. Durch die Kombination des Google Agent Development Kit (ADK) mit Vertex AI als Anbieter von Large Language Models (LLMs) können Sie KI-Agenten effizient und in großem Umfang operationalisieren. In diesem Leitfaden wird der End-to-End-Prozess beschrieben, mit dem Sie einen auf FastAPI basierenden Agenten, der auf Gemini 2.5 Flash basiert, von der Entwicklung bis zur Produktionsbereitstellung in GKE bringen.

Dieser Leitfaden richtet sich an Entwickler für maschinelles Lernen (ML), Entwickler und Cloud-Architekten, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen für die Bereitstellung von agentischen KI-/ML-Anwendungen zu nutzen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben in Google Cloud Inhalten finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.

Bevor Sie beginnen, sollten Sie sich mit den folgenden Punkten vertraut machen:

Hintergrund

In diesem Leitfaden werden mehrere Google-Technologien kombiniert, um eine skalierbare Plattform für agentische KI zu schaffen. Die GKE bietet die Containerorchestrierung für den Agent, der mit dem ADK erstellt wird. Wenn Sie die Vertex AI API für die LLM-Inferenz verwenden, benötigt der GKE-Cluster keine spezielle GPU-Hardware, da die Inferenz von der verwalteten Infrastruktur von Google verarbeitet wird.

Google Agent Development Kit (ADK)

Das Agent Development Kit (ADK) ist ein flexibles und modulares Framework zum Entwickeln und Bereitstellen von KI-Agenten. Das ADK ist zwar für Gemini und das Google-Ökosystem optimiert, aber modellunabhängig, unabhängig vom Bereitstellungsort und für die Kompatibilität mit anderen Frameworks konzipiert.

Weitere Informationen finden Sie in der ADK-Dokumentation.

Verwalteter Kubernetes-Dienst von GKE

GKE ist ein verwalteter Kubernetes-Dienst zum Bereitstellen, Skalieren und Verwalten von containerisierten Anwendungen. GKE bietet die erforderliche Infrastruktur, einschließlich skalierbarer Ressourcen, verteiltem Computing und effizienter Vernetzung, um die Rechenanforderungen von LLMs zu bewältigen.

Weitere Informationen zu den wichtigsten Kubernetes-Konzepten finden Sie unter Erste Schritte mit Kubernetes. Weitere Informationen zur GKE und dazu, wie Sie damit Kubernetes skalieren, automatisieren und verwalten können, finden Sie in der GKE-Übersicht.

Vertex AI

Vertex AI ist die einheitliche ML-Plattform von Google Cloud, mit der Entwickler KI/ML-Modelle erstellen, bereitstellen und skalieren können. Für agentische KI-Anwendungen in der GKE bietet Vertex AI wichtige Tools und Dienste, darunter Zugriff auf LLMs wie Gemini 2.5 Flash, verwaltete Infrastruktur für Training und Inferenz sowie MLOps-Funktionen für ein effizientes Lebenszyklusmanagement.

Wenn Sie LLMs über die Vertex AI API nutzen, erfolgt die Modellinferenz in der von Google verwalteten Infrastruktur. Dadurch ist in Ihrem GKE-Cluster kein bestimmtes GPU- oder TPU-Kontingent erforderlich.

Weitere Informationen zu Vertex AI für agentenbasierte KI-Anwendungen finden Sie in der Dokumentation zu Vertex AI.

Gemini 2.5 Flash

Gemini 2.5 Flash bietet Funktionen der nächsten Generation und verbesserte Funktionen für agentische Arbeitslasten, darunter höhere Geschwindigkeit, integrierte Tool-Nutzung, multimodale Generierung und ein Kontextfenster von 1 Million Tokens. Gemini 2.5 Flash ist eine Weiterentwicklung des vorherigen Flash-Modells und bietet eine höhere Qualität bei ähnlicher Geschwindigkeit.

Technische Informationen zu Gemini 2.5 Flash (z. B. Leistungsbenchmarks, Informationen zu unseren Trainings-Datasets, Nachhaltigkeitsbemühungen, vorgesehene Verwendung und Einschränkungen sowie unser Ansatz zu Ethik und Sicherheit) finden Sie in der Modellkarte für Gemini 2.5 Flash.

Ziele

Diese Seite enthält Anleitungen für Folgendes:

  • Richten Sie Ihre Google Cloud Umgebung ein.
  • Erstellen Sie ein Container-Image für Ihren Agenten.
  • Stellen Sie den Agent in einem GKE-Cluster bereit.
  • Bereitgestellten KI-Agenten testen

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloudverwendet:

Sehen Sie sich die Preise für die einzelnen Dienste an, um potenzielle Kosten nachzuvollziehen.

Hinweis

  • Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  • Verify that billing is enabled for your Google Cloud project.

  • Enable the required APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  • Verify that billing is enabled for your Google Cloud project.

  • Enable the required APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

    •

  • Prüfen Sie, ob Sie die folgenden Rollen für das Projekt haben: roles/container.admin, roles/iam.serviceAccountAdmin, roles/artifactregistry.admin, roles/cloudbuild.builds.editor, roles/resourcemanager.projectIamAdmin

    Rollen prüfen

    1. Rufen Sie in der Google Cloud Console die Seite IAM auf.

      IAM aufrufen
    2. Wählen Sie das Projekt aus.

    3. Suchen Sie in der Spalte Hauptkonto nach allen Zeilen, in denen Sie oder eine Gruppe, zu der Sie gehören, angegeben sind. Fragen Sie Ihren Administrator, zu welchen Gruppen Sie gehören.

    4. Prüfen Sie in allen Zeilen, in denen Sie angegeben oder enthalten sind, die Spalte Rolle, um zu sehen, ob die Liste der Rollen die erforderlichen Rollen enthält.

    Rollen zuweisen

    1. Rufen Sie in der Google Cloud Console die Seite IAM auf.

      IAM aufrufen
    2. Wählen Sie das Projekt aus.
    3. Klicken Sie auf Zugriffsrechte erteilen.

    4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Das ist in der Regel die E‑Mail-Adresse eines Google-Kontos.

    5. Klicken Sie auf Rolle auswählen und suchen Sie dann nach der Rolle.
    6. Klicken Sie auf Weitere Rolle hinzufügen, wenn Sie weitere Rollen zuweisen möchten.
    7. Klicken Sie auf Speichern.

Umgebung vorbereiten

In dieser Anleitung wird Cloud Shell verwendet, um Ressourcen zu verwalten, die auf Google Cloudgehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich kubectl, terraform und Google Cloud CLI.

So richten Sie Ihre Umgebung mit Cloud Shell ein:

  1. Starten Sie in der Google Cloud Console eine Cloud Shell-Sitzung und klicken Sie auf Cloud Shell aktivieren (Symbol für die Cloud Shell-Aktivierung). Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.

  2. Legen Sie die Standardumgebungsvariablen fest:

    gcloud config set project PROJECT_ID
export GOOGLE_CLOUD_LOCATION=REGION
export PROJECT_ID=PROJECT_ID
export GOOGLE_CLOUD_PROJECT=$PROJECT_ID
export WORKLOAD_POOL=$PROJECT_ID.svc.id.goog
export PROJECT_NUMBER=$(gcloud projects describe --format json $PROJECT_ID | jq -r ".projectNumber")

    Ersetzen Sie die folgenden Werte:

    • PROJECT_ID: Ihre Google Cloud Projekt-ID.
    • REGION: die Google Cloud -Region (z. B. us-central1) zur Bereitstellung Ihres GKE-Cluster, der Artifact Registry und anderer regionaler Ressourcen.

Beispielprojekt klonen

  1. Klonen Sie im Cloud Shell-Terminal das Repository mit dem Beispielcode für das Tutorial:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

  2. Rufen Sie das Anleitungsverzeichnis auf:

    cd kubernetes-engine-samples/ai-ml/adk-vertex

Google Cloud -Ressourcen erstellen und konfigurieren

Wenn Sie Ihren Agent in GKE bereitstellen möchten, müssen Sie die erforderlichenGoogle Cloud -Ressourcen bereitstellen. Sie können den Agenten entweder mit der gcloud CLI für die direkte Befehlszeilenausführung oder mit Terraform für Infrastructure as Code bereitstellen.

gcloud

In diesem Abschnitt finden Sie gcloud CLI-Befehle zum Einrichten Ihres GKE-Cluster, von Artifact Registry und von Workload Identity Federation for GKE für die nahtlose Integration in Vertex AI. Achten Sie darauf, dass die Umgebungsvariablen wie unter Umgebung vorbereiten beschrieben festgelegt wurden.

  1. GKE-Cluster erstellen: Sie können Ihre containerisierte agentische Anwendung in einem GKE Autopilot- oder Standard-Cluster bereitstellen. Verwenden Sie einen Autopilot-Cluster für eine vollständig verwaltete Kubernetes-Umgebung. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

    Autopilot

    Führen Sie in Cloud Shell den folgenden Befehl aus:

    gcloud container clusters create-auto CLUSTER_NAME \
        --location=$GOOGLE_CLOUD_LOCATION \
        --project=$PROJECT_ID

    Ersetzen Sie CLUSTER_NAME durch den Namen Ihres GKE Autopilot-Clusters.

    Standard

    Führen Sie in Cloud Shell den folgenden Befehl aus:

    gcloud container clusters create CLUSTER_NAME \
    --location=$GOOGLE_CLOUD_LOCATION \
    --project=$PROJECT_ID \
    --release-channel=stable \
    --num-nodes=1 \
    --machine-type=e2-medium \
    --workload-pool=$PROJECT_ID.svc.id.goog

    Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Standardclusters.

  2. Artifact Registry-Repository für Ihren Docker-Container erstellen: Erstellen Sie ein Artifact Registry-Repository, um das Docker-Container-Image Ihres Agenten sicher zu speichern und zu verwalten. Diese private Registry sorgt dafür, dass Ihre Anwendung für die Bereitstellung in GKE verfügbar ist, und lässt sich in Cloud Build einbinden.

    gcloud artifacts repositories create adk-repo \
    --repository-format=docker \
    --location=$GOOGLE_CLOUD_LOCATION \
    --project=$PROJECT_ID

  3. Repository-URL abrufen: Führen Sie diesen Befehl aus, um den vollständigen Pfad zu Ihrem Repository zu prüfen. Sie verwenden dieses Pfadformat, um Ihr Docker-Image im nächsten Schritt zu taggen.

    gcloud artifacts repositories describe adk-repo \
    --location $GOOGLE_CLOUD_LOCATION \
    --project=$PROJECT_ID

  4. Dem Compute Engine-Standarddienstkonto die erforderlichen IAM-Rollen zuweisen: Standardmäßig hat das Compute Engine-Standarddienstkonto keine Berechtigungen zum Übertragen von Images in Artifact Registry oder zum Aufrufen von Objekten in Cloud Storage oder von Logs. Weisen Sie die erforderlichen Rollen für diese Vorgänge zu.

    ROLES_TO_ASSIGN=(
    "roles/artifactregistry.writer"
    "roles/storage.objectViewer"
    "roles/logging.viewer"
)

for ROLE in "${ROLES_TO_ASSIGN[@]}"; do
    gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
        --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
        --role="${ROLE}"
done

  5. Agent-Container-Image erstellen und per Push übertragen: Führen Sie diesen Befehl aus, um Ihr Docker-Image zu erstellen und per Push an Ihre Artifact Registry zu übertragen. Achten Sie darauf, dass sich das Dockerfile und der Anwendungscode im Verzeichnis /app befinden.

    export IMAGE_URL="${GOOGLE_CLOUD_LOCATION}-docker.pkg.dev/${PROJECT_ID}/adk-repo/adk-agent:latest"

gcloud builds submit \
    --tag "$IMAGE_URL" \
    --project="$PROJECT_ID" \
    app

  6. Prüfen Sie, ob das Image übertragen wurde:

    gcloud artifacts docker images list \
    $GOOGLE_CLOUD_LOCATION-docker.pkg.dev/$PROJECT_ID/adk-repo/adk-agent \
    --project=$PROJECT_ID

Terraform

In diesem Abschnitt wird beschrieben, wie Sie mit Terraform Ihre Google Cloud-Ressourcen bereitstellen. Das geklonte Beispiel-Repository enthält die erforderlichen Terraform-Konfigurationsdateien.

  1. Terraform initialisieren: Wechseln Sie zum Verzeichnis terraform und initialisieren Sie Terraform.

    terraform init

  2. Ausführungsplan prüfen: Mit diesem Befehl werden die Infrastrukturänderungen angezeigt, die Terraform vornehmen wird.

    terraform plan -var-file=default_env.tfvars

  3. Konfiguration anwenden: Führen Sie den Terraform-Plan aus, um die Ressourcen in Ihrem Google Cloud -Projekt zu erstellen. Bestätigen Sie mit yes, wenn Sie dazu aufgefordert werden.

    terraform apply -var-file=default_env.tfvars

    Nachdem Sie diese Befehle ausgeführt haben, stellt Terraform Ihren GKE-Cluster und Ihr Artifact Registry-Repository bereit und konfiguriert die erforderlichen IAM-Rollen und Dienstkonten, einschließlich Workload Identity Federation for GKE.

Weitere Informationen zur Verwendung von Terraform finden Sie unter Terraform-Unterstützung für GKE.

kubectl für die Kommunikation mit Ihrem Cluster konfigurieren

Wenn Sie kubectl noch nicht für die Kommunikation mit Ihrem Cluster konfiguriert haben, führen Sie den folgenden Befehl aus:

gcloud container clusters get-credentials CLUSTER_NAME \
    --location=${GOOGLE_CLOUD_LOCATION}

Ersetzen Sie CLUSTER_NAME durch den Namen Ihres GKE-Cluster.

Workload Identity Federation for GKE-Zugriff konfigurieren

Wenn Sie Terraform verwenden, können Sie diesen Schritt überspringen. Dadurch erhält Ihr Kubernetes-ServiceAccount Berechtigungen für die Interaktion mit Vertex AI.

  1. Erstellen Sie ein Kubernetes-Dienstkonto in Ihrem Cluster. Achten Sie darauf, dass Sie die Anleitung unter kubectl für die Kommunikation mit Ihrem Cluster konfigurieren befolgen, bevor Sie diesen Befehl ausführen:

    kubectl create serviceaccount vertex-sa

  2. Weisen Sie dem Kubernetes-Dienstkonto die Rolle „Vertex AI-Nutzer“ (roles/aiplatform.user) für das Projekt zu:

    gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/vertex-sa" \
    --role="roles/aiplatform.user" \
    --condition=None

Agent-Anwendung bereitstellen und konfigurieren

Nachdem Sie Ihre Google Cloud Ressourcen eingerichtet haben, bereiten Sie Ihre Agent-Anwendung für die Bereitstellung vor und konfigurieren Sie die Laufzeit in GKE. Dazu müssen Sie den Code Ihres Agenten definieren, ein Dockerfile erstellen, um ihn zu containerisieren, und ein Kubernetes-Manifest schreiben, um ihn in Ihrem Cluster bereitzustellen.

  1. Struktur der Agentenanwendung verstehen: Das Verzeichnis /app enthält die wichtigsten Dateien für Ihre Agentenanwendung:
    • main.py: Der Einstiegspunkt der FastAPI-Anwendung, der für die Bereitstellung der API des Agenten verantwortlich ist.
    • agent.py: Enthält die Logik des ADK-Agents und definiert, wie er Vertex AI verwendet und Anfragen verarbeitet.
    • __init__.py: Initialisiert das Python-Paket.
    • requirements.txt: Listet alle Python-Abhängigkeiten für Ihren KI-Agenten auf.
    • Dockerfile: Definiert, wie Ihre Anwendung in ein Docker-Image gepackt wird.

  2. Manifest für die Agent-Bereitstellung erstellen: Erstellen Sie im Verzeichnis tutorials-and-examples/adk/vertex das folgende Manifest als Datei mit dem Namen agent-deployment.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: adk-agent-deployment
  labels:
    app: adk-agent
    # Identifies the workload as an AI agent and adds it to the registry
    registry.gke.io/functional-type: "AGENT"
spec:
  replicas: 1
  selector:
    matchLabels:
      app: adk-agent
  template:
    metadata:
      labels:
        app: adk-agent
    spec:
      serviceAccountName: vertex-sa
      containers:
      - name: adk-agent
        image: IMAGE_URL
        ports:
        - containerPort: 8000
        env:
        - name: GOOGLE_CLOUD_PROJECT_ID
          value: PROJECT_ID
        - name: GOOGLE_CLOUD_LOCATION
          value: REGION
        - name: GOOGLE_GENAI_USE_VERTEXAI
          value: "1"
        - name: PORT
          value: "8000"
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1"

    Ersetzen Sie die folgenden Werte:

    • IMAGE_URL: Die vollständige URL des Docker-Images, das Sie in Artifact Registry hochgeladen haben (z. B. us-central1-docker.pkg.dev/${PROJECT_ID}/adk-repo/adk-agent:latest). Sie können diesen Wert aus der Ausgabe des Befehls gcloud artifacts docker images list im vorherigen Abschnitt abrufen. Alternativ können Sie einen Befehl wie den folgenden ausführen: sed -i "s|image: IMAGE_URL|image: $IMAGE_URL|" agent-deployment.yaml.
    • PROJECT_ID: Projekt-ID in Google Cloud .
    • REGION: die Google Cloud -Region, in der Ihr GKE-Cluster bereitgestellt wird.

  3. Deployment-Manifest anwenden:

    kubectl apply -f agent-deployment.yaml

    Mit diesem Befehl werden das Deployment und die zugehörigen Pods für Ihre Agent-Anwendung im GKE-Cluster erstellt und der Agent wird in der Agent Registry registriert.

  4. KI-Agenten freigeben: Mit diesen Methoden können Sie Ihren KI-Agenten für den Zugriff freigeben.

    • Wenn Sie von außerhalb des Clusters auf Ihren Agent zugreifen möchten, erstellen Sie einen Kubernetes-Dienst. Für eine Web-API ist ein Dienst vom Typ LoadBalancer üblich.

    • Verwenden Sie für die lokale Entwicklung und Tests den Befehl kubectl port-forward, um direkt auf Ihren Agenten zuzugreifen.

    LoadBalancer

    1. Erstellen Sie das folgende Manifest als Datei mit dem Namen agent-service.yaml:

      apiVersion: v1
kind: Service
metadata:
  name: adk-agent-service
spec:
  selector:
    app: adk-agent
  type: LoadBalancer # Creates an external IP address for access
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000 # Matches the containerPort exposed in the Deployment

    2. Wenden Sie das Manifest an:

      kubectl apply -f agent-service.yaml

      Es kann einige Minuten dauern, bis die externe IP-Adresse bereitgestellt wird.

    3. Prüfen Sie, ob die IP-Adresse bereitgestellt wurde:

      kubectl get service adk-agent-service

      Suchen Sie in der Ausgabe nach dem Wert EXTERNAL-IP. Sobald der Wert verfügbar ist, können Sie diese IP-Adresse verwenden, um mit dem bereitgestellten Agenten zu interagieren.

    port-forward

    Wenn Sie hauptsächlich port-forward verwenden, sollten Sie anstelle von LoadBalancer den Diensttyp ClusterIP verwenden, da der ClusterIP-Dienst intern ist und weniger Ressourcen verbraucht.

    POD_NAME=$(kubectl get pods -l app=adk-agent -o jsonpath='{.items[0].metadata.name}')
kubectl port-forward $POD_NAME 8000:8000

    Dieser Befehl blockiert Ihr Terminal, leitet aber Traffic von localhost:8000 auf Ihrem Computer an den Agent weiter, der im GKE-Cluster ausgeführt wird.

Bereitgestellten KI-Agenten testen

Nachdem Ihre Agent-Anwendung bereitgestellt und verfügbar gemacht wurde, können Sie ihre Funktionen testen.

In diesem Abschnitt wird beschrieben, wie Sie den Endpunkt Ihres KI-Agenten ermitteln und die API des KI-Agenten testen.

  1. Endpunkt des KI-Agenten ermitteln: Je nachdem, wie Sie Ihren KI-Agenten im vorherigen Abschnitt verfügbar gemacht haben, ermitteln Sie den zugänglichen Endpunkt:

    LoadBalancer

    1. Rufen Sie die externe IP-Adresse ab:

      kubectl get service adk-agent-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}'

    2. Speichern Sie die externe IP-Adresse zur einfacheren Verwendung in einer Umgebungsvariablen:

      export AGENT_IP=$(kubectl get service adk-agent-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}')

      Die Basis-URL Ihres KI-Agenten lautet http://${AGENT_IP}.

    port-forward

    Achten Sie darauf, dass der Befehl kubectl port-forward in einem separaten Terminal ausgeführt wird. Die Basis-URL Ihres Agents ist http://localhost:8000.

  2. API des Agents testen: Testen Sie die API des Agents, indem Sie eine curl-Anfrage an den /run-Endpunkt senden. Der KI-Agent erwartet eine JSON-Nutzlast mit einem Nachrichtenfeld. Ersetzen Sie AGENT_BASE_URL durch http://${AGENT_IP} (für LoadBalancer) oder http://localhost:8000 (für Portweiterleitung).

    1. Neue Sitzung erstellen. Dadurch wird der KI-Agent auf eine neue Unterhaltung vorbereitet.

      # The user ID and session ID are arbitrary.
# The appName must match the agent's Python package directory name (in this case, "capital_agent").
curl -X POST AGENT_BASE_URL/apps/capital_agent/users/user-123/sessions/session-123

      Mit dem folgenden Befehl können Sie die verfügbaren Apps auflisten:

      curl -X GET AGENT_BASE_URL/list-apps

    2. Senden Sie eine Anfrage an den Agenten, indem Sie die Sitzungsdetails aus dem vorherigen Schritt verwenden.

      curl -X POST AGENT_BASE_URL/run \
-H "Content-Type: application/json" \
-d '{
  "appName": "capital_agent",
  "userId": "user-123",
  "sessionId": "session-123",
  "newMessage": {
    "role": "user",
    "parts": [{
      "text": "Hello, agent! What can you do for me?"
    }]
  }
}'

      Sie sollten eine JSON-Antwort von Ihrem Agenten erhalten, die angibt, dass er Anfragen erfolgreich verarbeitet und über Vertex AI mit dem Gemini-Modell interagiert. Die Antwort enthält die vom Agent generierte Antwort auf Ihre Nachricht.

  3. Auf die Web-UI des Agents zugreifen (falls zutreffend): Wenn Ihr Agent eine webbasierte Benutzeroberfläche enthält, können Sie darauf zugreifen, indem Sie in einem Webbrowser zu AGENT_BASE_URL navigieren. Das ADK enthält in der Regel eine einfache Weboberfläche für die Interaktion und das Debugging. Wenn Sie Ihren Agenten beispielsweise über einen LoadBalancer bereitgestellt haben und seine EXTERNAL-IP 34.123.45.67 ist, rufen Sie http://34.123.45.67 in Ihrem Browser auf.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Bereitgestellte Ressourcen löschen

Mit den folgenden Befehlen vermeiden Sie, dass Ihrem Google Cloud Konto die in dieser Anleitung erstellten Ressourcen in Rechnung gestellt werden:

gcloud

gcloud container clusters delete CLUSTER_NAME \
    --location=${GOOGLE_CLOUD_LOCATION} \
    --project=$PROJECT_ID

gcloud projects remove-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/vertex-sa" \
    --role="roles/aiplatform.user" \
    --condition=None

gcloud artifacts repositories delete adk-repo \
    --location=$GOOGLE_CLOUD_LOCATION \
    --project=$PROJECT_ID

Ersetzen Sie dabei CLUSTER_NAME durch den Namen Ihres GKE-Cluster.

Terraform

  1. Wechseln Sie in Ihrem Cloud Shell-Terminal zum Verzeichnis tutorials-and-examples/adk/vertex/:

    cd tutorials-and-examples/adk/vertex/

  2. Führen Sie diesen Befehl aus, um alle in Ihren Terraform-Konfigurationsdateien definierten Ressourcen zu entfernen.

    cd terraform
terraform destroy

Nächste Schritte

  • Horizontales Pod-Autoscaling (HPA) konfigurieren, um die Ressourcen Ihres Agents automatisch bei Bedarf anzupassen
  • Hier erfahren Sie, wie Sie Identity-Aware Proxy (IAP) für Ihre Webanwendungen konfigurieren, die aufGoogle Cloudausgeführt werden, um eine zentrale Autorisierung für den Zugriff auf die Benutzeroberfläche Ihres Agenten zu ermöglichen.
  • Erfahren Sie, wie Sie mit Cloud Logging und Cloud Monitoring Einblicke in die Leistung und den Zustand Ihres Agents in Ihrem GKE-Cluster erhalten.
  • In GKE AI Labs finden Sie experimentelle Beispiele, die Ihnen helfen können, GKE zur Beschleunigung Ihrer agentischen KI-Initiativen zu nutzen.