Agentenbasierten KI-Agenten mit dem Agent Development Kit (ADK) und Vertex AI in GKE bereitstellen

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

Dieser Leitfaden richtet sich an ML-Entwickler, Entwickler und Cloud-Architekten, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen für die Bereitstellung von agentenbasierten 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.

Machen Sie sich vorher mit folgenden Punkten vertraut:

Hintergrund

In diesem Leitfaden werden mehrere Google-Technologien kombiniert, um eine skalierbare Plattform für agentenbasierte KI zu schaffen. 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, ist für den GKE-Cluster keine spezielle GPU-Hardware erforderlich, da die Inferenz von der verwalteten Infrastruktur von Google übernommen 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, ist aber modellunabhängig, unabhängig von der Bereitstellung 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 Containeranwendungen. GKE bietet die erforderliche Infrastruktur, einschließlich skalierbarer Ressourcen, verteiltem Computing und effizienter Netzwerke, um die Rechenanforderungen von LLMs zu bewältigen.

Weitere Informationen zu wichtigen Kubernetes-Konzepten finden Sie unter Kubernetes lernen. Weitere Informationen zu 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 GKE bietet Vertex AI wichtige Tools und Dienste, darunter Zugriff auf LLMs wie Gemini 2.0 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 auf der verwalteten Infrastruktur von Google. 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.0 Flash

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

Technische Informationen zu Gemini 2.0 Flash, z. B. Leistungsbenchmarks, Informationen zu unseren Trainingsdatensätzen, Bemühungen um Nachhaltigkeit, beabsichtigte Nutzung und Einschränkungen sowie unser Ansatz in Bezug auf Ethik und Sicherheit, finden Sie in der Modellkarte für Gemini 2.0 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 Agent.
  • Stellen Sie den Agent in einem GKE-Cluster bereit.
  • Testen Sie den bereitgestellten Agent.

Kosten

In diesem Leitfaden werden die folgenden kostenpflichtigen Komponenten von Google Cloudverwendet:

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

Hinweise

  • Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  • 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.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. 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.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

    •

  • Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin, roles/artifactregistry.admin, roles/cloudbuild.builds.editor, roles/resourcemanager.projectIamAdmin

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      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. Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
    6. Klicken Sie auf Weitere Rolle hinzufügen, wenn Sie weitere Rollen zuweisen möchten.
    7. Klicken Sie auf Speichern.

      8. 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), in der Ihr GKE-Cluster, Artifact Registry und andere regionale Ressourcen bereitgestellt werden.

      Beispielprojekt klonen

      1. Klonen Sie in Ihrem Cloud Shell-Terminal das Beispielcode-Repository des Tutorials:

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

      2. Gehen Sie zum Anleitungsverzeichnis:

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

      Google Cloud -Ressourcen erstellen und konfigurieren

      Um Ihren Agent in GKE bereitzustellen, stellen Sie die erforderlichenGoogle Cloud -Ressourcen bereit. Sie können den Agenten entweder mit der gcloud CLI für die direkte Ausführung über die Befehlszeile 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 der Identitätsföderation von Arbeitslasten für 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 agentenbasierte Anwendung in einem GKE-Cluster im Autopilot- oder Standardmodus 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 Pushen 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 in Ihre Artifact Registry zu übertragen. Achten Sie darauf, dass sich Ihr Dockerfile und Ihr 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, 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 Ihre Google Cloud-Ressourcen mit Terraform bereitstellen. Das Beispiel-Repository, das Sie geklont haben, 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 den Vorgang 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 der Identitätsföderation von Arbeitslasten für 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 dabei CLUSTER_NAME durch den Namen Ihres GKE-Cluster.

      Zugriff über die Identitätsföderation von Arbeitslasten für GKE konfigurieren

      Wenn Sie Terraform verwenden, können Sie diesen Schritt überspringen. Bei diesem Vorgang wird ein Kubernetes-Dienstkonto (Kubernetes Service Account, KSA) mit einem IAM-Dienstkonto verknüpft, um Ihrem Agenten sicheren Zugriff auf Google Cloud -Dienste zu gewähren.

      1. Dienstkonto für den Vertex AI-Zugriff erstellen:

        gcloud iam service-accounts create vertex-sa \
    --project=$PROJECT_ID

      2. Weisen Sie dem Dienstkonto die Rolle aiplatform.user zu. Dadurch kann das Dienstkonto mit Vertex AI interagieren.

        gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member "serviceAccount:vertex-sa@$PROJECT_ID.iam.gserviceaccount.com" \
    --role "roles/aiplatform.user"

      3. Erstellen Sie ein KSA in Ihrem Cluster. Folgen Sie der Anleitung unter kubectl für die Kommunikation mit Ihrem Cluster konfigurieren, bevor Sie diesen Befehl ausführen.

        kubectl create serviceaccount vertex-sa

      4. Annotieren Sie das KSA, um es mit Ihrem Dienstkonto zu verknüpfen:

        kubectl annotate serviceaccount vertex-sa \
    iam.gke.io/gcp-service-account=vertex-sa@$PROJECT_ID.iam.gserviceaccount.com

      5. Gewähren Sie Ihrem Dienstkonto Berechtigungen, damit es als Workload Identity Federation for GKE-Nutzer für das KSA fungieren kann:

        gcloud iam service-accounts add-iam-policy-binding vertex-sa@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:$PROJECT_ID.svc.id.goog[default/vertex-sa]"

      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 Agents definieren, ein Dockerfile erstellen, um ihn in einen Container zu packen, und ein Kubernetes-Manifest schreiben, um ihn in Ihrem Cluster bereitzustellen.

      1. Struktur der Agent-Anwendung: Das Verzeichnis /app enthält die wichtigsten Dateien für Ihre Agent-Anwendung:
        • main.py: Der FastAPI-Anwendungseinstiegspunkt, der für die Bereitstellung der API des Agents 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 Agent auf.
        • Dockerfile: Definiert, wie Ihre Anwendung in einem Docker-Image verpackt wird.

      2. Manifest für die Agentbereitstellung 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
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 die Bereitstellung und die zugehörigen Pods für Ihre Agent-Anwendung im GKE-Cluster erstellt.

      4. Agent freigeben: Mit diesen Methoden können Sie Ihren Agent 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.

        • Für die lokale Entwicklung und das lokale Testen können Sie mit dem Befehl kubectl port-forward direkt auf Ihren Agenten zugreifen.

        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 Ihrem 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 Agent testen

      Nachdem Ihre Agent-Anwendung bereitgestellt und verfügbar gemacht wurde, sollten Sie ihre Funktionalität testen.

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

      1. Endpunkt des Agents ermitteln: Je nachdem, wie Sie Ihren Agent im vorherigen Abschnitt verfügbar gemacht haben, müssen Sie den zugänglichen Endpunkt ermitteln:

        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 Agents ist 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 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 Kundenservicemitarbeiter 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 verfügbare Apps auflisten:

          curl -X GET AGENT_BASE_URL/list-apps

        2. Senden Sie eine Anfrage an den Agenten. Verwenden Sie dazu die Sitzungsdetails aus dem vorherigen Schritt.

          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 Agent 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 Web-UI für die Interaktion und das Debugging. Wenn Sie Ihren Agent beispielsweise über einen Load-Balancer bereitgestellt haben und dessen 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 "serviceAccount:vertex-sa@$PROJECT_ID.iam.gserviceaccount.com" \
    --role "roles/aiplatform.user"

gcloud iam service-accounts delete vertex-sa@$PROJECT_ID.iam.gserviceaccount.com

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. Öffnen Sie in Ihrem Cloud Shell-Terminal das 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