Enterprise MCP auf Bedrock AgentCore mit Okta SSO und Trino

Lambda OAuth-Modul, PKCE-Relais, AgentCore-Gateway und Laufzeitumgebung sowie Benutzerindividuelle Trino-Verbindungen ohne Leckage gemeinsamer Token.

Verlag: REACTAPP.TOPAuf dieser Website hinzugefügt 26. Sept. 202613 Min. Lesezeit2982 Wörter

Quellen: Building Enterprise MCP on AWS Bedrock AgentCore: Okta SSO + Trino

Dieser Leitfaden zeigt Schritt für Schritt den Weg von Rohstoffen bis zu einem funktionsfähigen System auf: Aufbau eines Enterprise MCPs mit AWS Bedrock AgentCore – Okta SSO + Trino. Der Schwerpunkt liegt auf ausführbaren Schritten, klaren Überprüfungen sowie Code, den man ohne Rätseln über die Absicht direkt in ein Repository einfügen kann. Zur Übersicht sollten vor der Codeänderung Eingabedaten, Verantwortliche für die Schritte sowie Abbruchkriterien definiert werden. Die Betreiber sollten in der Lage sein, die Schritte von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Neben den funktionalen Ergebnissen sollten Zeiten sowie Kosten für Token oder Abfragen aufgezeichnet werden. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsam genutzte Umgebungen übergeht.

Kurzfassung

Zusammenfassend: Definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Bewahren Sie Konfigurationen außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Operator überprüfen können, ohne den gesamten Ablauf durchzulesen. Stellen Sie Tools mit eng definierten Schemata sowie expliziten Labels für Nebeneffekte bereit. Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

MCP Client → Lambda OAuth Proxy → Bedrock AgentCore Gateway → AgentCore Runtime → Trino

Warum das Übergeben eines rohen Tokens an ein Tool die Unternehmensprüfungen scheitern lässt

Für die Erklärung, warum das Übergeben eines rohen Tokens an ein Tool die Unternehmensprüfungen scheitern lässt, sollten vor der Codeänderung Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Stellen Sie Tools mit eng gefassten Schemata sowie expliziten Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Architektur im Überblick

Für eine Übersicht der Architektur sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Man sollte kleine, testbare Einheiten vor umfangreichen Skripten bevorzugen. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufverfahren. Stellen Sie Tools mit eng definierten Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen. Für eine Übersicht der Architektur sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Tokens oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo in gemeinsame Umgebungen wechselt.

1. Der MCP-Client

Für den MCP-Client sollten die Eingaben, der Eigentümer des Schritts sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablaufverlauf durchlesen zu müssen. Die Authentifizierung sollte am Gateway erfolgen und die Neuberechtigung im Datenbereich. Ein alleinigesBearer-Token stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

2. Der Lambda MCP-Proxy (das OAuth-Zentrum)

Zum Zweiten: Für den Lambda MCP-Proxy (den OAuth-Kern) sollten vor der Codeänderung die Eingaben, der Eigentümer des Schritts sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleinigesBearer-Token stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

3. Der AWS Bedrock AgentCore Gateway

Für Punkt 3: Das AWS Bedrock AgentCore Gateway – definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Operator:innen sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen verschiedenen Nutzern dar. Für Punkt 3: Das AWS Bedrock AgentCore Gateway – definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Operator:innen sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Informationen zu Laufzeiten sowie Kosten für Token oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von Demonstrationsumgebungen in gemeinsam genutzte Umgebungen wechselt.

4. Der AWS Bedrock AgentCore Runtime

Für den AWS Bedrock AgentCore Runtime sollten Eingaben, der Verantwortliche für einen Schritt sowie die Beendigungskriterien vor dem Ändern des Codes definiert werden. Operator:innen sollten in der Lage sein, einen Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den Operator:innen überprüfen können, ohne den gesamten Ablauf durchlesen zu müssen. Für jeden Aufruf sollten Name des Tools, Hash der Argumente, Latenzzeit sowie das Ergebnis protokolliert werden. Ohne diese Aufzeichnungen verschwendet man Stunden beim Debuggen von Agentenschleifen.

Der End-to-End-Authentifizierungsfluss

Für den End-to-End-Authentifizierungsfluss sollten Sie die Eingabedaten, den Verantwortlichen für jeden Schritt sowie die Abbruchkriterien vor dem Codeändern definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch die Notfallbehandlung gemeinsam. Wiederholversuche, menschliche Überprüfungen sowie die Handhabung fehlerhafter Nachrichten gehören zum Produkt selbst und nicht zu späteren Optimierungen. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenzzeit sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Debugging-Agenten Stunden damit, im Kreis zu laufen.

┌─────────────────────┐
│    MCP Client       │
│ Claude / Claude Code│
└──────────┬──────────┘
           │
           │ OAuth 2.1 + PKCE
           ▼
┌─────────────────────┐
│   Lambda MCP Proxy  │◄──────────────► Okta
│ OAuth / Identity    │   Login + JWT
└──────────┬──────────┘
           │
           │ Bearer JWT
           ▼
┌─────────────────────────────┐
│ Bedrock AgentCore Gateway   │
│ CUSTOM_JWT validation       │
└────────────┬────────────────┘
             │ SigV4
             ▼
┌─────────────────────────────┐
│ Bedrock AgentCore Runtime   │
│ FastMCP Server              │
│                             │
│ list_catalogs               │
│ describe_table              │
│ execute_query               │
└────────────┬────────────────┘
             │
             │ User JWT
             ▼
┌─────────────────────────────┐
│ Enterprise Query Engine     │
│ Per-user authorization      │
└─────────────────────────────┘

Einsatzbeispiel 1: Anleitung für den Lambda-Proxy zur Kommunikation nach OAuth 2.1

Für Deep Dive 1: Das Lambda-Proxy dazu bringen, OAuth 2.1 zu verwenden – definieren Sie vor dem Codeändern die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenz sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Sie Stunden beim Debuggen von Schleifen. Für Deep Dive 1: Das Lambda-Proxy dazu bringen, OAuth 2.1 zu verwenden – definieren Sie vor dem Codeändern die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Führen Sie neben den funktionalen Ergebnissen auch die Laufzeiten sowie die Kosten für Tokens oder Abfragen auf. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf fehlschlägt.

wechselt von Demoumgebungen zu gemeinsam genutzten Umgebungen.

# GET /.well-known/protected-resource
{
  "resource": f"{BASE_URL}/mcp",
  "authorization_servers": [BASE_URL],
}

# GET /.well-known/oauth-authorization-server
{
  "issuer": BASE_URL,
  "authorization_endpoint": f"{BASE_URL}/authorize",
  "token_endpoint":         f"{BASE_URL}/token",
  "registration_endpoint":  f"{BASE_URL}/register",
  "response_types_supported": ["code"],
  "grant_types_supported": ["authorization_code", "refresh_token"],
  "code_challenge_methods_supported": ["S256"],
  "token_endpoint_auth_methods_supported": ["none"],
}

PKCE-Relaying ohne Störungen

Zum PKCE-Relaying ohne Störungen sollten die Eingabedaten, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode liegen. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablauf durchzulesen. Bieten Sie Tools mit eng definierten Schemata sowie expliziten Labels für Nebeneffekte an. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

relay_payload = json.dumps({"u": original_redirect, "s": original_state}).encode()
relay_state   = base64.urlsafe_b64encode(relay_payload).decode().rstrip("=")

params = {
    "client_id":             OKTA_CLIENT_ID,
    "response_type":         "code",
    "redirect_uri":          f"{BASE_URL}/callback",   # <- proxy's callback
    "state":                 relay_state,               # <- client's state, wrapped
    "code_challenge":        qs["code_challenge"],      # <- untouched
    "code_challenge_method": "S256",
}

Dynamische Client-Anmeldung

Für eine dynamische Client-Anmeldung sollten die Eingabedaten, der Verantwortliche für den jeweiligen Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch die Notfallbehandlung gemeinsam. Wiederholungsversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Stellen Sie Tools mit eng definierten Schemata sowie klaren Angaben zu Nebeneffekten bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

def handle_register(event):
    req = json.loads(event.get("body") or "{}")
    return _json_resp(201, {
        "client_id": OKTA_CLIENT_ID,
        "redirect_uris": req.get("redirect_uris", []),
        "grant_types":   req.get("grant_types", ["authorization_code"]),
        "response_types": req.get("response_types", ["code"]),
        "token_endpoint_auth_method": "none",
    })

Einsatz im Detail 2: Beobachtete Störungen, wenn FastMCP hinter AgentCore stand

Für Deep Dive 2: Es wurden Ausfälle beobachtet, als FastMCP hinter AgentCore stand; definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Stellen Sie Tools mit engen Schemata sowie expliziten Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen. Für Deep Dive 2: Es wurden Ausfälle beobachtet, als FastMCP hinter AgentCore stand; definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Informationen zu Laufzeiten sowie Kosten für Tokens oder Abfragen. Frühzeitige Sichtbarkeit der Kosten verhindert Probleme im Voraus.

Unerwartete Gebühren, wenn der Pfad von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt.

Scharfer Punkt Nr. 1: Keine benutzerdefinierten HTTP-Header erreichen den Container

Zu Scharfem Punkt Nr. 1: Keine benutzerdefinierten HTTP-Header erreichen den Container – definieren Sie die Eingaben, den Eigentümer des Schritts sowie die Abbruchkriterien, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den die Operator überprüfen können, ohne den gesamten Ablaufverlauf durchlesen zu müssen. Authentifizieren Sie am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleinigesBearer-Token stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

meta = payload.setdefault("params", {}).setdefault("_meta", {})
meta["okta_token"]   = token         # the validated user identity
meta["trino_target"] = routing_hint  # optional routing metadata

class CredentialExtractMiddleware:
    async def __call__(self, scope, receive, send):
        # buffer the whole body
        body = await _read_full_body(receive)

        # pull identity out of params._meta
        meta = json.loads(body).get("params", {}).get("_meta", {})
        token = meta.get("okta_token")        # AgentCore also injects the validated caller token as a header —
        # prefer that when present, fall back to _meta / Authorization otherwise
        token = token or _caller_token_from_headers(scope)        _req_okta_token.set(token)        # replay the buffered body so the MCP app can read it too
        await self.app(scope, _replay(body, receive), send)

Scharfer Punkt Nr. 2: AgentCore entfernt den `Accept`-Header

Für den scharfen Rand #2: AgentCore entfernt den Accept-Header, definiert die Eingaben, den Eigentümer des Schritts sowie die Abbruchkriterien, bevor der Code geändert wird. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie den erfolgreichen Ablauf sowie den Notfallweg gemeinsam. Wiederholte Versuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Authentifizieren Sie am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

class InjectAcceptMiddleware:
    async def __call__(self, scope, receive, send):
        if scope["type"] == "http":
            headers = [(k, v) for k, v in scope["headers"] if k != b"accept"]
            headers.append((b"accept", b"application/json, text/event-stream"))
            scope = {**scope, "headers": headers}
        await self.app(scope, receive, send)

Einsatz im Detail 3: Zuordnung von Okta-Zugriffstoken zu isolierten Trino-Sitzungen

Für Deep Dive 3: Das Zuordnen von Okta-Zugriffstoken zu isolierten Trino-Sitzungen – definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Authentifizieren Sie am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniger Token stellt keine Trennlinie zwischen verschiedenen Nutzern dar. Für Deep Dive 3: Das Zuordnen von Okta-Zugriffstoken zu isolierten Trino-Sitzungen – definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Angaben zu Laufzeiten sowie Kosten für Token oder Abfragen. Frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen.

Sobald sich der Pfad von „Demo“ auf gemeinsame Umgebungen verschiebt.

def get_connection():
    token = _req_okta_token.get()
    user  = _jwt_email(token)          # e.g. "alice@company.com"

    return backend.connect(
        host=BACKEND_HOST,
        user=user,                      # identity for attribution/authorization
        auth=JWTAuthentication(token),  # the backend re-validates this itself
        http_scheme="https",
    )

Autorisierung sowie die Durchsetzung des Leserechts gehören letztendlich in die Datenschicht.

Für Autorisierung sowie die Durchsetzung des Leserechts gehören letztendlich in die Datenschicht: Definieren Sie vor dem Ändern des Codes die Eingaben, den Eigentümer der Schritt sowie die Abbruchkriterien. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Halten Sie die Konfiguration außerhalb des Anwendungscode – Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort gesammelt sein, den Operator ohne das Durchlesen des gesamten Graphen überprüfen können. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenz sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Debugging-Agenten Stunden mit endlosen Schleifen.

forbidden = ("INSERT", "UPDATE", "DELETE", "DROP", "CREATE",
             "ALTER", "TRUNCATE", "MERGE", "REPLACE", "GRANT", "REVOKE")
if any(query.strip().upper().startswith(kw) for kw in forbidden):
    raise ValueError("Write operations are not allowed.")

Zwei Möglichkeiten, den Client anzuschließen

Zur Verbindung des Clients auf zwei Arten sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenzzeit sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Debugging-Agenten Stunden mit sinnlosem Herumprobieren.

{ "mcpServers": { "data": { "type": "http", "url": "https://<lambda-url>/mcp" } } }

{ "mcpServers": { "data": { "type": "http", "url": "http://localhost:8766/mcp" } } }

Was wir gelernt haben

Nach dem, was wir gelernt haben, sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Man sollte kleine, testbare Einheiten vor umfangreichen Skripten bevorzugen. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufverfahren. Für jeden Aufruf sollten Name der Protokollierungstool, Hash der Argumente, Latenzzeit sowie das Ergebnis aufgezeichnet werden. Ohne diese Aufzeichnungen verschwenden Debugging-Agenten Stunden damit, im Kreis zu laufen. Nach dem, was wir gelernt haben, sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Neben den funktionalen Ergebnissen sollten auch Zeiten sowie Kosten für Tokens oder Abfragen erfasst werden. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt.

Zusammenfassung

Zum Abschluss sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablauf durchzulesen. Bieten Sie Tools mit eng definierten Schemata sowie expliziten Kennzeichnungen für Nebeneffekte an. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Operative Checkliste

Zur operativen Checkliste sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.

Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

Führen Sie Kontrollpunkte nach aufwändigen Schritten durch. Die Wiederaufnahme des Vorgangs sollte keine erneute Abrechnung für denselben LLM-Aufruf veranlassen, wenn ein Operator einen späteren Knoten erneut versucht.

Übertragen Sie die Identität vom Client zum nachgelagerten Speicher, ohne alle Nutzer in ein Servicekonto zusammenzufassen.

Fügen Sie so oft wie möglich, solange das Budget es zulässt, einen Smoke-Test hinzu, der den kritischen Pfad in CI mit Fixtures und nicht mit live genutzten, bezahlten APIs testet.

Vor der Einführung des Stacks sollten Versionen eingefroren werden, ein „goldener“ Transkript für den kritischen Pfad erstellt und die Rollback-Schritte überprüft werden. Gemeinsam genutzte Umgebungen benötigen Rate Limits, Überprüfungen der Tenant-Isolation sowie einen klaren Verantwortlichen für die Rotation von Geheimnissen. Man sollte langweilige Zuverlässigkeit vor cleveren, einmaligen Demonstrationen bevorzugen.

Deployment-Hinweis 1: Fixieren Sie Bilder, legen Sie Anfragenbudgets fest und überprüfen Sie die Tenant-Isolation auf einer Canary-Umgebung vor einer breiteren Einführung.

Deployment-Hinweis 2: Fixieren Sie Bilder, legen Sie Anfragenbudgets fest und überprüfen Sie die Tenant-Isolation auf einer Canary-Umgebung vor einer breiteren Einführung.

Deployment-Hinweis 3: Fixieren Sie Bilder, legen Sie Anfragenbudgets fest und überprüfen Sie die Tenant-Isolation auf einer Canary-Umgebung vor einer breiteren Einführung.

Deployment-Hinweis 4: Fixieren Sie Bilder, legen Sie Anfragenbudgets fest und überprüfen Sie die Tenant-Isolation auf einer Canary-Umgebung vor einer breiteren Einführung.

Deployment-Hinweis 5: Fixieren Sie Bilder, legen Sie Anfragenbudgets fest und überprüfen Sie die Tenant-Isolation auf einer Canary-Umgebung vor einer breiteren Einführung.

Implementierungshinweis 6: Fixieren Sie Bilder, legen Sie Anfragenbudgets fest und überprüfen Sie die Isolierung der Nutzer auf einer Canary-Version vor einer breiteren Einführung.

← Alle Artikel Brief senden