

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Amazon Bedrock AgentCore Runtime für AWS Marketplace
<a name="bedrock-agentcore-runtime"></a>

Dieses Dokument enthält Informationen für AWS Marketplace Verkäufer, die KI-Agenten oder Tools auflisten möchten, die auf Amazon Bedrock AgentCore Runtime eingesetzt werden können. Es beschreibt die technischen Anforderungen, Konfigurationsrichtlinien und Best Practices für die Vorbereitung Ihres von Bedrock AgentCore Runtime unterstützten Containers für. AWS Marketplace

**Topics**
+ [Übersicht](#agentcore-runtime-overview)
+ [Technische Anforderungen für AgentCore Bedrock-Container](#agentcore-container-requirements)
+ [Testen Sie Ihren Bedrock AgentCore Runtime-Container](#testing-agentcore-container)
+ [Bewährte Methoden für die Container-Konfiguration](#container-best-practices)
+ [Voraussetzungen für die Einreichung AWS Marketplace](#marketplace-submission-requirements)
+ [Weitere Ressourcen](#agentcore-additional-resources)
+ [Support für AgentCore Runtime on AWS Marketplace](#agentcore-support)

## Übersicht
<a name="agentcore-runtime-overview"></a>

Amazon Bedrock AgentCore Runtime bietet eine sichere, serverlose und speziell entwickelte Hosting-Umgebung für die Bereitstellung und Ausführung von KI-Agenten oder -Tools. Wenn Sie Ihren Bedrock AgentCore Runtime-Container anbieten, müssen Sie sicherstellen AWS Marketplace, dass er bestimmte Anforderungen erfüllt, damit er in der Bedrock-Umgebung ordnungsgemäß funktioniert. AgentCore 

**Anmerkung**  
Weitere Informationen finden Sie unter [Erste Schritte mit Amazon Bedrock AgentCore Runtime](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-getting-started.html).

## Technische Anforderungen für AgentCore Bedrock-Container
<a name="agentcore-container-requirements"></a>

Amazon Bedrock AgentCore Runtime hat unterschiedliche technische Anforderungen für die Auflistung von AI-Agenten, MCP-Servern und A2A-Servern.
+ **Anforderungen an Agenten**
+ **Anforderungen an den MCP-Server**
+ **A2A-Serveranforderungen**

### Anforderungen an den Agenten
<a name="agent-requirements"></a>

Ihr Agent in Containern muss die folgenden Kernanforderungen erfüllen:
+ **/ping-Endpunkt**: GET-Endpunkt für Zustandsprüfungen
+ **/invocations** Endpoint: POST-Endpunkt für Agenteninteraktionen
+ **Docker Container: containerisiertes Bereitstellungspaket** ARM64 
+ **Port: Der** Container muss den Port `8080` für die HTTP-basierte Agentenkommunikation verfügbar machen

#### `/ping`- HOLEN
<a name="ping-endpoint"></a>

Dieser Endpunkt überprüft, ob Ihr Agent betriebsbereit und bereit ist, Anfragen zu bearbeiten.

**Beispiel für eine Antwort:**

```
{
  "status": "Healthy"
}
```

#### `/invocations`- BEITRAG
<a name="invocations-endpoint"></a>

Dies ist der primäre Endpunkt der Agenteninteraktion, wenn Kunden den Agenten mit der Payload im JSON-Format anrufen, um eine InvokeAgentRuntime Aktion auszuführen. InvokeAgentRuntime unterstützt Streaming-Antworten, sodass Kunden Teilantworten erhalten können, sobald diese verfügbar sind.

**Beispiel für eine Anfrage:**

```
Content-Type: application/json
{
  "prompt": "What's the weather today?"
}
```

**Beispielantworten:**
+ JSON-Antwort (kein Streaming):

  ```
  Content-Type: application/json
  {
    "response": "Your agent's response here",
    "status": "success"
  }
  ```
+ SSE-Antwort (Streaming):

  ```
  Content-Type: text/event-stream
  data: {"event": "partial response 1"}
  data: {"event": "partial response 2"}
  data: {"event": "final response"}
  ```

### MCP-Serveranforderungen
<a name="mcp-server-requirements"></a>

Mit Amazon Bedrock AgentCore Runtime können Sie Model Context Protocol (MCP) -Server bereitstellen und ausführen. Wenn Sie Amazon Bedrock AgentCore Runtime mit dem MCP-Protokoll konfigurieren, erwartet der Service MCP-Servercontainer im Pfad. `0.0.0.0:8000/mcp` Dies ist der Standardpfad, den die meisten offiziellen MCP-Server unterstützen. SDKs 

Da Amazon Bedrock AgentCore Runtime standardmäßig Sitzungsisolierung bietet, sind statuslose Streamable-HTTP-Server erforderlich. Die Runtime fügt automatisch einen `Mcp-Session-Id` Header für jede Anfrage hinzu, die keinen enthält. Auf diese Weise können MCP-Clients die Verbindungskontinuität zu derselben Amazon Bedrock AgentCore Runtime-Sitzung aufrechterhalten.

Die `InvokeAgentRuntime` API leitet Nutzdaten direkt weiter, was die einfache Weiterleitung von RPC-Nachrichten für Protokolle wie MCP ermöglicht.

Voraussetzungen:
+ **Transport — Es darf nur stateless streamable-http** verwendet werden
+ **Sitzungsverwaltung** — Die Plattform fügt automatisch einen Header für die Sitzungsisolierung hinzu `Mcp-Session-Id`
+ **Host** — Container muss zuhören `0.0.0.0`
+ **Port — Der** Container muss den Port `8000` für die MCP-Serverkommunikation verfügbar machen
+ **Pfad** — Muss `/mcp` als POST-Endpunkt angegeben werden, um MCP-RPC-Nachrichten zu empfangen. Die `InvokeAgentRuntime` API leitet Anfragen an diesen Pfad für MCP-Server weiter.
+ **Protokoll** — Der MCP-Server muss das MCP-Protokoll unterstützen, einschließlich der folgenden Protokollnachrichten:
  + `tools/list`
  + `tools/call`(wird von gängigen Frameworks wie FastMCP unterstützt)

Weitere Informationen zu den MCP-Serveranforderungen finden Sie unter [Bereitstellen von MCP-Servern](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-mcp.html) in Runtime. AgentCore 

#### `/mcp`- BEITRAG
<a name="mcp-endpoint"></a>

Dies ist der primäre Endpunkt für Agenteninteraktionen, mit InvokeAgentRuntime dem Kunden den MCP-Server anrufen.

**Beispiel für eine Listenanfrage:**

```
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
}
```

**Beispiel für eine Listenantwort:**

JSON-Antwort (kein Streaming):

```
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "get_weather",
        "title": "Weather Information Provider",
        "description": "Get current weather information for a location",
        "inputSchema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "City name or zip code"
            }
          },
          "required": ["location"]
        }
      }
    ],
    "nextCursor": "next-page-cursor"
  }
}
```

**Beispiel für eine Anfrage zum Tool-Aufruf:**

```
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "New York"
    }
  }
}
```

**Beispiel für eine Antwort auf einen Tool-Aufruf:**

JSON-Antwort (kein Streaming):

```
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Current weather in New York:\nTemperature: 72°F\nConditions: Partly cloudy"
      }
    ],
    "isError": false
  }
}
```

### A2A-Serveranforderungen
<a name="a2a-server-requirements"></a>

Mit Amazon Bedrock AgentCore Runtime können Sie Agent-to-Agent (A2A) -Server in der AgentCore Runtime bereitstellen und ausführen. AgentCoreDie A2A-Protokollunterstützung von Amazon Bedrock ermöglicht eine nahtlose Integration mit A2A-Servern, indem sie als transparente Proxyschicht fungiert. Bei der Konfiguration für A2A AgentCore erwartet Amazon Bedrock, dass Container statuslose, streambare HTTP-Server auf dem Port `9000` im Root-Pfad (`0.0.0.0:9000/`) ausführen, was der standardmäßigen A2A-Serverkonfiguration entspricht.

Der Service bietet Sitzungsisolierung auf Unternehmensebene bei gleichzeitiger Wahrung der Protokolltransparenz — JSON-RPC-Nutzlasten von der API werden ohne Änderung direkt an den InvokeAgentRuntime A2A-Container weitergeleitet. Diese Architektur behält die standardmäßigen A2A-Protokollfunktionen wie die integrierte Agentenerkennung über Agentenkarten bei `/.well-known/agent-card.json` und die JSON-RPC-Kommunikation bei und bietet gleichzeitig Unternehmensauthentifizierung (SigV4/2.0) und Skalierbarkeit. OAuth 

Die wichtigsten Unterscheidungsmerkmale zu anderen Protokollen sind der Port (9000 gegenüber 8080 für HTTP), der Bereitstellungspfad (`/`vs`/invocations`) und der standardisierte Agentenerkennungsmechanismus, was Amazon Bedrock zu AgentCore einer idealen Bereitstellungsplattform für A2A-Agenten in Produktionsumgebungen macht.

Voraussetzungen:
+ **Port** — A2A-Server laufen auf Port 9000 (gegenüber 8080 für HTTP, 8000 für MCP)
+ **Host** — Container muss zuhören `0.0.0.0`
+ **Pfad**
  + A2A-Server werden unter `/` (im Gegensatz zu HTTP, `/invocations` `/mcp` für MCP) gemountet
  + Gesundheitschecks bei der `/ping` Verwendung von GET
+ **Agentenkarten** — A2A bietet eine integrierte Agentenerkennung über Agentenkarten unter `/.well-known/agent-card.json`
+ **Protokoll** — Verwendet JSON-RPC für die Kommunikation agent-to-agent
+ **Authentifizierung** — Unterstützt sowohl Sigv4- als auch 2.0-Authentifizierungsschemata OAuth 

Weitere Informationen zu den A2A-Serveranforderungen finden Sie unter [Bereitstellen von A2A-Servern in Runtime](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-a2a.html). AgentCore 

#### `/`- BEITRAG
<a name="a2a-endpoint"></a>

Dies ist der primäre Endpunkt für Agenteninteraktionen, mit InvokeAgentRuntime dem Kunden den A2A-Server anrufen.

**Beispiel für eine Anfrage zum Aufrufen eines Agenten:**

```
Content-Type: application/json
{  
  "jsonrpc": "2.0",  
  "id": "req-001",  
  "method": "message/send",  
  "params": {  
    "message": {  
      "role": "user",  
      "parts": [  
        {  
          "kind": "text",  
          "text": "what is 101 * 11?"  
        }  
      ],  
      "messageId": "12345678-1234-1234-1234-123456789012"  
    }  
  } 
}
```

**Beispiel für eine Antwort auf einen Agentenaufruf:**

JSON-Antwort (kein Streaming):

```
Content-Type: application/json
{
  "jsonrpc": "2.0",
  "id": "req-001",
  "result": {
    "artifacts": [
      {
        "parts": [
          {
            "kind": "text",
            "text": "101 * 11 is 1111"
          }
        ]
      }
    ]
  }
}
```

**Beispiel für den Abruf einer Agentenkarte:**

```
curl https://bedrock-agentcore.<REGION>.amazonaws.com/runtimes/{escaped_agent_arn}/invocations/.well-known/agent-card.json
```

#### `/ping`- HOLEN
<a name="a2a-endpoint-ping"></a>

Dies ist der Endpunkt für die Durchführung von Gesundheitschecks.

## Testen Sie Ihren Bedrock AgentCore Runtime-Container
<a name="testing-agentcore-container"></a>

Bevor Sie Ihren Container einreichen AWS Marketplace, testen Sie ihn gründlich:

### Testen mit lokalen Agenten
<a name="local-agent-testing"></a>

Testen Sie Ihren Agenten lokal mit Docker

```
docker run -p 8080:8080 <your-container-image>

# Test ping endpoint
curl http://localhost:8080/ping

# Test agent invocation endpoint
curl -X POST http://localhost:8080/invocations \
     -H "Content-Type: application/json" \
     -d '{"prompt": "Hello world!"}'
```

### Testen lokaler MCP-Server
<a name="local-mcp-testing"></a>

Testen Sie Ihren MCP-Server lokal mit Docker

```
docker run -p 8000:8000 <your-container-image>

# Test ping endpoint
curl http://localhost:8000/ping

# Test MCP endpoint with tools/list
curl -X POST http://localhost:8000/mcp \
     -H "Content-Type: application/json" \
     -d '{"jsonrpc": "2.0","id": 1,"method": "tools/list"}'

# Test MCP endpoint with tools/call
curl -X POST http://localhost:8000/mcp \
     -H "Content-Type: application/json" \
     -d '{ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "get_weather", "arguments": {"location": "New York"}}}'
```

### Testen lokaler A2A-Server
<a name="local-a2a-testing"></a>

Testen Sie Ihren A2A-Server lokal mit Docker

```
docker run -p 9000:9000 <your-container-image>

# Test ping endpoint
curl http://localhost:9000/ping

# Retrieve agent card
curl http://localhost:9000/.well-known/agent-card.json

# Test A2A endpoint with message/send
curl -X POST http://localhost:9000/ \
     -H "Content-Type: application/json" \
     -d '{ "jsonrpc": "2.0", "id": "req-001", "method": "message/send", "params": { "message": {  "role": "user",  "parts": [  {  "kind": "text",  "text": "what is 101 * 11?"}],"messageId": "12345678-1234-1234-1234-123456789012" }}}'
```

### Testen auf Bedrock Runtime AgentCore
<a name="testing-on-agentcore"></a>

Nachdem Sie Ihren Container lokal getestet haben, laden Sie ihn in Amazon Elastic Container Registry (Amazon ECR) hoch und stellen Sie ihn in Amazon Bedrock AgentCore Runtime bereit. Sie können die Bereitstellung entweder mit der Amazon Bedrock AgentCore Runtime-Konsole oder mit AWS Command Line Interface (AWS CLI) durchführen.

## Bewährte Methoden für die Container-Konfiguration
<a name="container-best-practices"></a>

### Sicherheitsüberlegungen
<a name="security-considerations"></a>
+ **Isolierung** — Speichern Sie keine sensiblen Daten zwischen Aufrufen
+ **Authentifizierung** — Validieren Sie alle eingehenden Anfragen
+ **Protokollierung — Protokollieren** Sie die entsprechenden Informationen, vermeiden Sie jedoch die Angabe sensibler Daten
+ **Abhängigkeiten** — Halten Sie alle Abhängigkeiten aktuell, um Sicherheitslücken zu vermeiden

### Leistungsoptimierung
<a name="performance-optimization"></a>
+ **Kaltstart** — Optimieren Sie Ihren Container für schnelle Kaltstarts
+ **Speichernutzung** — Minimiere den Speicherbedarf, um die Leistung zu verbessern
+ **Parallelität** — Gestalten Sie Ihren Agenten so, dass er gleichzeitige Anfragen effizient bearbeitet
+ **Timeouts** — Implementieren Sie die richtige Behandlung von Timeouts

### Fehlerbehandlung
<a name="error-handling"></a>
+ **Graaceful Degradation** — Implementieren Sie Ausweichmechanismen für den Fall, dass Dienste nicht verfügbar sind
+ **Strukturierte Fehler** — Geben Sie gut strukturierte Fehlerantworten mit den entsprechenden HTTP-Statuscodes zurück
+ **Wiederholungslogik** — Implementieren Sie eine geeignete Wiederholungslogik für vorübergehende Fehler

## Voraussetzungen für die Einreichung AWS Marketplace
<a name="marketplace-submission-requirements"></a>

Wenn Sie Ihren AgentCore Runtime-Container an einreichen AWS Marketplace, müssen Sie Folgendes angeben:
+ **Container-Image** — Ihr Container-Image wurde an Amazon ECR übertragen
+ **Dokumentation** — Umfassende Dokumentation zur Verwendung Ihres Agenten- oder MCP-Servers
+ **Anwendungsbeispiele** — Klare Beispiele dafür, wie Sie Ihren Agenten oder MCP-Server aufrufen
+ **Support-Informationen** — Kontaktinformationen für den Support
+ **Preisinformationen** — Klare Preisstruktur für Ihren Agenten oder MCP-Server

## Weitere Ressourcen
<a name="agentcore-additional-resources"></a>

Weitere Informationen finden Sie hier:
+ [Was ist Amazon Bedrock AgentCore?](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html)
+ [Was ist AWS Marketplace?](https://docs.aws.amazon.com/marketplace/latest/userguide/what-is-marketplace.html)
+ [Erste Schritte mit Container-Produkten](container-product-getting-started.md)

## Support für AgentCore Runtime on AWS Marketplace
<a name="agentcore-support"></a>

Fragen zur Listung Ihres AgentCore Runtime-Containers auf AWS Marketplace finden Sie unter [Support erhalten für AWS Marketplace](https://docs.aws.amazon.com/marketplace/latest/buyerguide/buyer-support.html).

Technische Fragen zu AgentCore Runtime finden Sie unter [AWS Support Kundenservice](https://console.aws.amazon.com/support/home#/case/create?issueType=technical).