Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Einen Google-ADK-Agenten importieren

Diese Schritt-für-Schritt-Anleitung importiert die Agent Config einer Anwendung, die auf dem Agent Development Kit (ADK) von Google aufbaut — ein Agent, der Fragen von Kunden zu ihren Bestellungen beantwortet —, und baut die Anwendung für Docker Compose. Der Import entwirft jede Datei, die der Build liest: den Agenten und sein Gemini-Modell, den Schlüssel, den der Agent dem Modell als Variablenreferenz vorlegt, und die Realisierungen von beiden. Er fragt einmal nach dem einen Wert, den keine Konfiguration enthält: dem Image, in dem die Anwendung läuft. Jede Datei und jeder Ausgabeblock unten stammt aus einem echten Lauf; die Konfiguration und jede Stufe der Anleitung liegen im Beispiel import-google-adk, in dem ein Prüfskript den Import erneut ausführt, das, was er schreibt, was er ausgibt, und die Blöcke, die diese Seite zitiert, mit den dort abgelegten Dateien vergleicht und das validiert und baut, was der Import geschrieben hat.

Das Beispiel generieren

Sie können diesen Import mit den Befehlen auf dieser Seite ausführen oder ihn von Ihrem KI-Assistenten ausführen lassen.

Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:

Terminal window
aggrega scaffold --example import-google-adk

Danach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner; der folgende, unten, wechselt in den Ordner source des neuen Ordners, der enthält, was diese Seite importiert, und in dem der Import läuft:

Terminal window
cd import-google-adk

Der Ordner source des erzeugten Beispiels, in Visual Studio Code geöffnet, mit der Konfiguration des Agenten: support_agent auf gemini-2.5-flash mit dem Tool google_search.

Das Projekt

ADK kann die Agenten einer Anwendung in Agent-Config-Dateien statt im Code deklarieren: adk create --type=config schreibt root_agent.yaml, die Konfiguration des Root-Agenten, und daneben eine Umgebungsdatei. Diese hier, für diese Anleitung geschrieben, deklariert einen Agenten auf gemini-2.5-flash von Gemini, mit dem Google-Search-Tool, das ADK mitliefert:

# yaml-language-server: $schema=https://raw.githubusercontent.com/google/adk-python/refs/heads/main/src/google/adk/agents/config_schemas/AgentConfig.json
name: support_agent
model: gemini-2.5-flash
description: Answers a customer's question about their order.
instruction: |
You answer customers' questions about their orders. When a customer asks
where a parcel is, search the web for the tracking page of the company
shipping it.
tools:
- name: google_search

Der Import liest die Umgebungsdatei nie, die üblicherweise den Schlüssel enthält, den die Anwendung an Gemini sendet; daher enthält das Beispiel keine. Im Stammverzeichnis des Projekts macht eine .aggrega-config.yaml den Ordner zu einem Arbeitsbereich:

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside support_agent/.
workspace: {}
# The registry the importer is fetched from the first time an import needs it.
default_registry: hub.aggrega.ai

Der Import verweist auf die Components des Katalogs für den ADK-Agenten und das Gemini-Modell, und --target entwirft ein Manifest aus dessen Recipes. Der Arbeitsbereich nennt keinen Katalogordner, daher liest der Import den Katalog der Standardbibliothek aus der Registry, aus der er seinen Importer holt: einen signierten Snapshot des veröffentlichten Katalogs, den der erste Import holt, verifiziert und im Inhalts-Cache des Arbeitsbereichs ablegt und den die Aufzeichnung, die der Import neben seine Entwürfe schreibt, über seinen Digest benennt. Ein Arbeitsbereich, der eigene Katalogordner nennt — in AGGREGA_CATALOG_DIRS oder unter workspace.catalog_dirs —, importiert stattdessen gegen diese.

Wonach der Import fragt

Eine Agent Config benennt das Modell des Agenten, nie das Image, in dem die Anwendung läuft: Dieses Image bauen Sie aus Ihrem Projekt. Der Katalog enthält kein Standard-Image für eine auf ADK aufgebaute Anwendung, daher fragt der Import danach. An einem Terminal fragt er und schreibt die Antwort in die Entwürfe und in die Antwortdatei import-answers.yaml im importierten Verzeichnis support_agent/, sodass der nächste Import sie von dort liest und nichts fragt. Ohne Terminal — in der Continuous Integration oder über eine Pipe — fragt er nichts: Er schreibt die Datei mit leerem Schlüssel und hält an, wobei er die Datei nennt. Das Beispiel enthält die Datei bereits, mit beantwortetem Image, ghcr.io/example/support-agent:1.0.0, das für das Image steht, das Sie bauen:

# Values the import could not draft from the source, keyed by the drafted file and the key path inside
# it. Write each one beside its key; an import of the same source, and a sync, read them from here and
# ask nothing. A secret is never written here: its key asks where the secret comes from — a variable
# name, ${NAME}, or the name of a Kubernetes Secret.
release.yaml:
# Container image running the application built on ADK, serving its API on infra.port on every
# interface.
spec.components.support-agent.infra.image: "ghcr.io/example/support-agent:1.0.0"
# The origin of the secret value, written by the operator in the Release. Read exactly as
# values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes
# from, never the value.
spec.components.support-agent.uses.model.gemini-2-5-flash.features.credential.infra.origin: "google-api-key"

Die zweite Antwort gilt für einen Build für Kubernetes mit --target helm: Dort liest der Agent den Gemini-API-Schlüssel aus einem Kubernetes-Secret, und die Antwort ist der Name des Secrets, google-api-key, nie der Schlüssel. Ein Build für Docker Compose liest den Schlüssel stattdessen aus Ihrer Shell, daher verwendet dieser Import diese Antwort nicht. Die Antwortdatei des Imports beschreibt die Datei, die Fragen und die Regeln für die Antwort zu einem Secret.

aggrega import listet jedes Flag auf, das der Befehl annimmt, darunter --answers, das eine anderswo abgelegte Antwortdatei nennt.

Wechseln Sie in source:

Terminal window
cd source

Den Import ausführen

Geben Sie das Verzeichnis des Agenten an. Der Import liest dessen root_agent.yaml:

Terminal window
aggrega import support_agent --target compose

Auf der Standardausgabe listet er auf, was er geschrieben hat:

wrote aggregate.yaml
wrote release.yaml
wrote manifest.yaml
wrote .aggrega-import.json

Auf der Standardfehlerausgabe, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:

[… omitted: a warning that the importer runs unverified, printed where its module is read from beside its Plugin entity in a catalog folder rather than fetched]
read as the google-adk format, with drafted paths relative to <workspace>
info: the answers file <workspace>/support_agent/import-answers.yaml also answers spec.components.support-agent.uses.model.gemini-2-5-flash.features.credential.infra.origin in release.yaml, which these drafts do not leave empty; those answers are kept there and not applied
mapped support_agent (agent) to core/ai-agent/google-adk as a reference, NONE
mapped gemini-2.5-flash (model) to core/ai-model/gemini as a reference, NONE
made no choice for google_search (tool)
Pull complete: <workspace>/release.lock (entities=8, source_artifacts=0, external_inputs=0)

Der Import, aus dem Editor ausgeführt: Das entworfene Aggregate, Release und Manifest erscheinen neben der Konfiguration des Agenten, die Aggrega-Ausgabe listet auf, wie der Agent und sein Modell zugeordnet und welche Dateien geschrieben wurden, und eine Benachrichtigung meldet, dass der Import 3 Dateien entworfen hat, erkannt als google-adk.

  • Die info-Zeile nennt die Antwort, die die Docker-Compose-Entwürfe nicht verwenden und die in der Antwortdatei für einen Build für Kubernetes aufbewahrt wird.
  • Die Zeilen mapped besagen, dass der Agent eine Instanz des ADK-Agenten der Standardbibliothek ist, core/ai-agent/google-adk, und dass das Modell, das er nennt, eine Instanz von core/ai-model/gemini ist. Ihre Stufe lautet NONE: Der ADK-Import verweist auf diese Components anhand dessen, was die Konfiguration nennt, statt jede mit dem Katalog abzugleichen.
  • Die Zeile made no choice besagt, dass für das Google-Search-Tool nichts entworfen wird: Es ist ein Tool, das ADK mitliefert, und es läuft innerhalb der Anwendung.
  • Die Zeile Pull complete zeigt, dass der Import das, wovon das entworfene Release abhängt, wie aggrega pull in release.lock abruft, sodass die Entwürfe sofort validiert und gebaut werden können. Mit --offline ruft der Import nichts ab und nennt den auszuführenden Befehl aggrega pull.

Was er schreibt

Das Aggregate, das Release und das Manifest heißen imported/support-agent, nach dem name des Root-Agenten, support_agent, reduziert auf support-agent, unter dem Namespace, den die Einstellung target_namespace des Importers festlegt, imported, sofern Sie keinen anderen festlegen (Einstellungen).

aggregate.yaml — der Agent, mit dem Modell verbunden, wobei der Schlüssel, den er vorlegt, an der Verbindung deklariert ist, und das Modell, eingeleitet von Kommentaren, die sagen, was gelesen wurde und was nicht:

# Google ADK agent configurations read:
# - root_agent.yaml
# Not read: the application's code, which defines the tools, callbacks and agents a configuration names by their code, nor the environment file ADK's scaffold writes beside root_agent.yaml; the application runs in the image the Release names for each instance, and loads its configurations itself.
# ADK states that its Agent Config is experimental. An agent's model is a Gemini model by default; ADK serves some other providers' models by name through classes of its own, such as claude-sonnet-4-5 and gpt-4o, and others through a LiteLLM model string.
apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/support-agent
version: 0.1.0
description: Draft Aggregate imported from a source in the google-adk format.
spec:
components:
# The agent tree of root_agent.yaml, served from its root agent support_agent.
# Tools ADK ships, which run inside the application, drafted as no Component: google_search.
support-agent:
type: core/ai-agent/google-adk
values:
description: "Answers a customer's question about their order."
uses:
model:
gemini-2-5-flash:
target: gemini-2-5-flash
# For the compose target, the lines below declare credential on gemini-2-5-flash: a secret the Release alone attaches arrives under the key value, so each is declared with a key of its own and no two arrive under one; the Release attaches its origin, naming this type or none.
features:
credential:
type: core/secret-value
values:
key: GOOGLE_API_KEY
# The model gemini-2.5-flash.
gemini-2-5-flash:
type: core/ai-model/gemini
values:
model: "gemini-2.5-flash"

ADK stellt eine Anwendung von ihrem Root-Agenten aus bereit, daher enthält der Entwurf eine Instanz pro Agentenbaum, benannt nach dessen Root-Agenten. Die instruction des Agenten wird nicht übernommen: Die Anwendung liest sie aus ihrer eigenen Konfiguration, die das Image enthält.

ADK stellt gemini-2.5-flash über seine Gemini-Klasse bereit, die ihre Anfragen an die Gemini-API sendet, daher verbindet der Entwurf das Modell mit dem model-Socket des Agenten, der allein die Gemini-API zulässt. Gemini ist ein gehosteter Dienst, daher lehnt die Component des Agenten eine Verbindung dorthin ab, die keine Zugangsdaten trägt; die Verbindung deklariert welche unter dem Schlüssel GOOGLE_API_KEY. Ein Modell, das ADK auf andere Weise bereitstellt — ein Name wie gpt-4o, den ADK über eine eigene Klasse bereitstellt, oder ein LiteLLM-Modellstring wie openai/gpt-4o —, wird mit nichts verbunden: Ein Kommentar über der Instanz nennt es, und die Verbindung bleibt Ihnen überlassen, wie Was aus einem Agentenbaum wird beschreibt.

release.yaml — die Umgebung, das Image, der veröffentlichte Port und woher der Schlüssel stammt:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/support-agent
# environment is a drafted default, since no source names the environment this Release deploys to; change it to name the one it deploys to.
environment: development
version: 0.1.0
description: Draft Release imported from a source in the google-adk format.
spec:
aggregate: imported/support-agent
manifest: imported/support-agent
components:
support-agent:
infra:
# Left for the Release, since the source cannot supply it: infra.image, the container image running the application built on ADK, holding its configurations
image: "ghcr.io/example/support-agent:1.0.0"
# Published on this machine's loopback address, 127.0.0.1: reachable from this machine only, by any process running on it. Delete this line to keep the service internal.
published_port: 8000
uses:
model:
gemini-2-5-flash:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential support-agent presents to gemini-2-5-flash on its model connection (the source names no variable for it, so it is read from the one Google's Gemini API's client libraries read the API key from), read from the variable GOOGLE_API_KEY, which a target substituting variable references, as Docker Compose does when the stack starts, reads from the environment, so no file carries the value.
origin: "${GOOGLE_API_KEY}"
gemini-2-5-flash: {}

Die Umgebung, development, ist ein Standardwert, den der Import schreibt, weil keine Konfiguration eine nennt; ändern Sie ihn dort, wo das Release anderswohin bereitgestellt wird. Das Image ist die Antwort, die der Import aus support_agent/import-answers.yaml gelesen hat. published_port ist 8000, der Port, auf dem die Anwendung lauscht, sodass sie auf Ihrem Rechner unter http://127.0.0.1:8000 antwortet; wie der Kommentar der Zeile sagt, kann jeder Prozess auf diesem Rechner sie dort erreichen und nichts anderes, und wenn Sie die Zeile löschen, bleibt die Anwendung allein im Netzwerk des Stacks. Die Konfiguration nennt keine Variable für den Schlüssel, daher liest die Verbindung ihn aus ${GOOGLE_API_KEY}, der Variablen, die die Client-Bibliotheken der Gemini-API lesen, als Variablenreferenz und niemals als Wert.

manifest.yaml — das Compose-Recipe jedes Typs und die Realisierung, die die Variablenreferenz des Schlüssels unverändert in die Compose-Datei schreibt:

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/support-agent
version: 0.1.0
spec:
mappings:
components:
type:
core/ai-agent/google-adk: compose/google-adk
core/ai-model/gemini: compose/gemini
features:
type:
core/secret-value: compose/dotenv-secret

release.lock hält per Digest die Katalog-Entitäten fest, zu denen das Release aufgelöst wurde, und .aggrega-import.json ist die Aufzeichnung dessen, was der Import geschrieben hat, und wird von einem späteren aggrega import --sync gelesen.

Validieren und bauen

Terminal window
aggrega validate --release release.yaml
aggrega build --release release.yaml

Das entworfene Release, nach der Validierung im Editor geöffnet; die Aggrega-Ausgabe und eine Benachrichtigung melden beide, dass keine Probleme gefunden wurden.

Der Build des entworfenen Release: Im Explorer erscheint ein dist-Ordner, die Aggrega-Ausgabe listet die geschriebene Docker-Compose-Datei auf, und eine Benachrichtigung meldet, dass 1 Datei geschrieben wurde.

Die Validierung gibt aus:

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
release dependency validation passed: release.yaml (schema-pillar + dependency pillars)

und der Build, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
[… omitted: a total build time, which differs per run]
Build completed: 1 file written to <workspace>/dist

Die notice-Zeile ist ein Hinweis: Das Secret-Feature akzeptiert sein origin aus den values des Aggregate oder aus der infra des Release, und der Hinweis meldet, dass ein Blatt in beiden deklariert ist. Er ändert kein Urteil.

Der Dienst des Agenten in dist/compose/docker-compose.yaml:

services:
support-agent:
image: ghcr.io/example/support-agent:1.0.0
environment:
PORT: "8000"
GOOGLE_API_KEY: ${GOOGLE_API_KEY}
ports:
- 127.0.0.1:8000:8000
[… omitted: the labels the build writes on every service, naming the Aggregate, the component, the environment and the compiler's version]
networks:
- compose

Die Anwendung erhält den Port, auf dem ihr Server lauscht, als PORT und den Schlüssel als GOOGLE_API_KEY, den der Gemini-Client von ADK an die Gemini API sendet. Das Modell erhält keinen eigenen Dienst: Der Client sendet seine Anfragen an die eigene Adresse der Gemini API und liest keine andere aus seiner Umgebung. Der Schlüssel ist eine Variablenreferenz, die beim Start des Stacks aus Ihrer Shell befüllt wird. Das Compose-Recipe des ADK-Agenten veröffentlicht nur dann einen Port auf Ihrem Rechner, wenn das Release published_port in der infra des Agenten setzt, und dann ausschließlich auf der Loopback-Adresse 127.0.0.1; ohne diese Einstellung ist der Dienst nur im Netzwerk des Stacks erreichbar.

Mit einem KI-Assistenten

Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie diesen Prompt dort ein.

Verwenden Sie ausschließlich die Aggrega-Tools und legen Sie selbst keinen Ordner an. Wenn der Workspace-Ordner noch keinen Ordner `import-google-adk` enthält, rufen Sie das Tool `scaffold` einmal mit `example` auf `import-google-adk` gesetzt und ohne `dir` auf: Es schreibt das Beispiel in einen neuen Ordner `import-google-adk`, dessen Ordner `source` enthält, was diese Seite importiert. Rufen Sie dann das Tool `import` mit `workspace_root` auf `import-google-adk/source`, `source` auf `support_agent` und `target` auf `compose` gesetzt auf: Es liest die benötigten Antworten aus `import-answers.yaml` im Ordner `support_agent`, schreibt seine Entwürfe nach `import-google-adk/source` und pullt, was sie benötigen. Rufen Sie dann das Tool `validate` mit `workspace_root` auf `import-google-adk/source` und `release` auf `release.yaml` gesetzt auf, sowie das Tool `build` mit `workspace_root` auf `import-google-adk/source`, `release` auf `release.yaml` und `write` auf true gesetzt. Nennen Sie mir die Dateien, die der Build geschrieben hat; sie liegen unter `import-google-adk/source/dist/`.

In VS Code öffnen

Wenn die Aggrega-Erweiterung für Visual Studio Code installiert ist, öffnen Sie in VS Code den Ordner import-google-adk/source, in den der Import seine Entwürfe geschrieben hat. Der Ordner enthält ein einziges Release, die entworfene release.yaml, daher wählt der Editor es für Sie aus und prüft die Entwürfe während der Bearbeitung gegen dieses Release; was er findet, markiert er in der Datei und im Bereich Probleme. Aggrega: Show topology graph in der Befehlspalette zeichnet die Komponenten des Release und die Verbindungen zwischen ihnen. Aggrega: Build, Aggrega: Preview build und Aggrega: Pull wirken auf dasselbe Release, und jeder davon ist auch eine Schaltfläche im Bereich Commands der Ansicht Aggrega in der Aktivitätsleiste; Build schreibt seine Dateien in dist/ innerhalb des Ordners. Aggrega in Visual Studio Code verwenden behandelt den Rest.

Ausführen

Docker Compose führt Ihr Image als den oben gerenderten Service aus, einschließlich PORT. Das Image muss auf allen Schnittstellen an diesem Port lauschen, nicht auf 127.0.0.1, der Standardadresse des API-Servers von ADK. Der eigene API-Server von ADK, adk api_server, stellt das Konfigurationsverzeichnis unverändert bereit, sodass das Image keinen Code von Ihnen benötigt. Ein Dockerfile im Stammverzeichnis des Projekts, neben support_agent/:

FROM python:3.12-slim
RUN pip install --no-cache-dir google-adk==2.13.0
COPY support_agent/ /app/agents/support_agent/
CMD ["sh", "-c", "exec adk api_server --host 0.0.0.0 --port \"$PORT\" --auto_create_session /app/agents"]

adk api_server stellt die Agent-Verzeichnisse in dem angegebenen Ordner bereit, und der Befehl übergibt ihm PORT. --auto_create_session öffnet eine Sitzung, wenn eine Anfrage an /run sie zum ersten Mal nennt, sodass eine einzige Anfrage den Agenten erreicht. Erstellen Sie das Image, schreiben Sie seinen Namen anstelle von ghcr.io/example/support-agent:1.0.0 in support_agent/import-answers.yaml und importieren Sie erneut mit --sync, das die neue Antwort in die Entwürfe schreibt und erneut pullt; führen Sie dann den Build aus:

Terminal window
docker build -t support-agent:local .
aggrega import support_agent --sync
aggrega build --release release.yaml

Setzen Sie dann den Schlüssel in Ihrer Shell und starten Sie den Stack:

Terminal window
export GOOGLE_API_KEY='your Gemini API key'
docker compose -p support-agent -f dist/compose/docker-compose.yaml up -d --wait

-p benennt das Projekt, wie der Ausführungsschritt in Wie ein Import abläuft erklärt. --wait kehrt zurück, sobald der Container läuft, da der Build dem Service keinen Healthcheck gibt, und der Server antwortet einen Moment später; wiederholen Sie daher eine Anfrage, die er ablehnt.

Testen

Senden Sie dem Agenten eine Nachricht an http://127.0.0.1:8000, die Adresse, die published_port veröffentlicht. Die Anfrage nennt einen Benutzer und eine Sitzung, und /run öffnet die Sitzung bei ihrer ersten Nachricht:

Terminal window
curl -sS -X POST http://127.0.0.1:8000/run -H 'Content-Type: application/json' \
-d '{"app_name": "support_agent", "user_id": "u1", "session_id": "s1", "new_message": {"role": "user", "parts": [{"text": "Where is my order 1234? Answer in one short sentence."}]}}'

Die Antwort, die von Gemini, kommt als Liste der Ereignisse zurück, die die Gesprächsrunde der Sitzung hinzugefügt hat. Der Lauf verwendete einen Platzhalter für den Schlüssel, daher lehnte Gemini ihn ab: Die Anfrage antwortete mit HTTP 500, Internal Server Error, und das Log des Service, docker compose -p support-agent -f dist/compose/docker-compose.yaml logs support-agent, nennt den Grund:

google.genai.errors.ClientError: 400 INVALID_ARGUMENT. {'error': {'code': 400, 'message': 'API key not valid. Please pass a valid API key.', 'status': 'INVALID_ARGUMENT', [… omitted: the error's details]}}

curl -sS http://127.0.0.1:8000/list-apps antwortet ["support_agent"], die Agenten, die der Server enthält.

Beenden Sie den Stack mit:

Terminal window
docker compose -p support-agent -f dist/compose/docker-compose.yaml down

Auf Kubernetes

Derselbe Agent wird für Kubernetes mit --target helm importiert. Ein Cluster bezieht seine Images aus einer Registry, pushen Sie also das von Ihnen gebaute Image in eine, die Ihr Cluster liest, und schreiben Sie seinen Namen anstelle des als Antwort angegebenen Images in support_agent/import-answers.yaml; der Lauf hat es in eine Registry auf dem eigenen Rechner des Clusters gepusht, als localhost:5000/support-agent:1.0.0. Die zweite Antwort dort nennt das Secret, aus dem der Agent den Gemini-API-Schlüssel liest, google-api-key. Die Entwürfe für Docker Compose liegen bereits in source, entwerfen Sie diese also in einen eigenen Ordner und bauen Sie von dort aus:

Terminal window
aggrega import support_agent --target helm --output-dir helm
cd helm
aggrega build --release release.yaml

Der Build schreibt einfache Kubernetes-Manifeste unter dist/helm/ im Stammverzeichnis des Workspace, source, das von helm aus ../dist/helm/ ist. Erstellen Sie das Secret google-api-key in dem Namespace, auf den Sie anwenden, mit dem Schlüssel unter dem Datenschlüssel value, und wenden Sie den Ordner an, wie es der Ausführungsschritt von Wie ein Import abläuft erklärt. Der Service des Agenten ist support-agent-default: Leiten Sie einen lokalen Port an ihn weiter und lassen Sie den Befehl laufen:

Terminal window
kubectl port-forward -n <namespace> svc/support-agent-default 8000:8000

Von einem anderen Terminal aus erreicht die obige Nachricht den Agenten unter derselben Adresse, unverändert. Der Lauf erhielt denselben Internal Server Error, und kubectl logs -n <namespace> deploy/support-agent nennt dieselbe Ablehnung des Platzhalterschlüssels.