

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.

# EventBridge Amazon-Schemas
<a name="eb-schema"></a>

Ein Schema definiert die Struktur der [Ereignisse](eb-events.md), an die gesendet EventBridge werden. EventBridge stellt Schemas für alle Ereignisse bereit, die von AWS Diensten generiert werden. Sie können auch [benutzerdefinierte Schemata erstellen oder hochladen](eb-schema-create.md) oder direkt aus Ereignissen in einem [Event Bus](eb-event-bus.md) [Schemata ableiten](eb-schemas-infer.md). Sobald Sie über ein Schema für ein Ereignis verfügen, können Sie Codebindungen für gängige Programmiersprachen herunterladen und die Entwicklung beschleunigen. Sie können mit Codebindungen für Schemas arbeiten und Schemas von der EventBridge Konsole aus verwalten, indem Sie die API verwenden, oder direkt in Ihrer IDE, indem Sie die Toolkits verwenden. AWS Wenn Sie Serverless-Apps erstellen möchten, die Ereignisse verwenden, verwenden Sie AWS Serverless Application Model.

**Anmerkung**  
Wenn Sie das [Eingabe-Transformator](eb-transform-target-input.md)-Feature verwenden, wird das ursprüngliche Ereignis durch die Schemaerkennung abgeleitet, nicht das transformierte Ereignis, das an das Ziel gesendet wird.

EventBridge unterstützt sowohl OpenAPI 3- als auch JSONSchema Draft4-Formate.

Für [AWS Toolkit for JetBrains](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/eventbridge-schemas.html) und [AWS Toolkit for VS Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/working-with-aws.html) können Sie Schemas durchsuchen oder nach Schemas suchen und Codebindungen für Schemas direkt in Ihrer IDE herunterladen. 

 Das folgende Video gibt einen Überblick über Schemata und Schemaregistrierungen:




## Maskieren von Eigenschaftswerten der Schemaregistrierungs-API
<a name="eb-schema-mask"></a>

Einige Eigenschaftswerte von Ereignissen, die zur Erstellung einer Schemaregistrierung verwendet werden, können vertrauliche Kundeninformationen enthalten. Zum Schutz der Kundeninformationen werden die Werte mit Sternchen (\$1) maskiert. Da wir diese Werte maskieren, EventBridge empfiehlt es sich, keine Anwendungen zu erstellen, die explizit von den folgenden Eigenschaften oder deren Werten abhängen:
+ **[CreateSchema](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#CreateSchema)**— Die `Content` Eigenschaft des Körpers `requestParameters`
+ **[GetDiscoveredSchema](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-discover.html#GetDiscoveredSchema)**— Das `Events` Eigentum des `requestParameters` Körpers und das `Content` Eigentum des `responseElements` Körpers
+ **[SearchSchemas](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-search.html#SearchSchemas)**— Das `keywords` Eigentum des `requestParameters`
+ **[UpdateSchema](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#UpdateSchema)**— Das `Content` Eigentum der `requestParameters`

# Ein AWS Serviceereignisschema in Amazon finden EventBridge
<a name="eb-find-schema"></a>

EventBridge beinhaltet [Schemas](eb-schema.md) für alle AWS Dienste, die Ereignisse generieren. Sie finden diese Schemas in der EventBridge Konsole oder mithilfe der API-Aktion. [https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-search.html](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-search.html)

**Um Schemas für AWS Dienste in der Konsole zu finden EventBridge**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich die Option **Schemas** aus.

1. Wählen Sie auf der Seite **Schemata** die Option **AWS -Ereignisschemaregistrierung** aus.

   Die erste Seite der verfügbaren Schemas wird angezeigt.

1. **Um ein Schema zu finden, geben Sie **unter AWS Suchereignisschemas** einen Suchbegriff ein.**

   Eine Suche gibt Übereinstimmungen sowohl für den Namen als auch für den Inhalt der verfügbaren Schemata zurück und zeigt dann an, welche Versionen des Schemas Übereinstimmungen enthalten.

1. Öffnen Sie ein Ereignisschema, indem Sie den Namen des Schemas auswählen.

# Schemaregister bei Amazon EventBridge
<a name="eb-schema-registry"></a>

Schemaregistrierungen sind Container für Schemata. Schemaregistrierungen sammeln und organisieren Schemata so, dass sich Ihre Schemata in logischen Gruppen befinden. Die standardmäßigen Schemaregistrierungen sind: 
+ **Alle Schemas** — Alle Schemas aus den Registern „ AWS Ereignis“, „Ermittelt“ und „Benutzerdefiniertes Schema“.
+ **AWS Registrierung des Ereignisschemas** — Die integrierten Schemas.
+ **Erkannte Schemaregistrierung** – Die Schemata, die bei der Schemaerkennung erkannt wurden

Sie können benutzerdefinierte Registrierungen erstellen, um die Schemata zu organisieren, die Sie erstellen oder hochladen.

**Anmerkung**  
Das Exportieren von benutzerdefinierten Schemas aus der EventBridge Schemaregistrierung wird nicht unterstützt.

**So erstellen Sie eine benutzerdefinierte Registrierung**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich **Schemata** und dann **Registrierung erstellen** aus.

1. Geben Sie auf der Seite **Registrierungsdetails** unter **Name** einen Namen ein.

1. (Optional) Geben Sie eine Beschreibung für die neue Registrierung ein.

1. Wählen Sie **Erstellen** aus.

Wenn Sie in der neuen Registrierung [ein benutzerdefiniertes Schema erstellen](eb-schema-create.md) möchten, wählen Sie **Benutzerdefiniertes Schema erstellen** aus. Wenn Sie der Registrierung ein Schema hinzufügen möchten, wählen Sie diese Registrierung aus, wenn Sie ein neues Schema erstellen.

Wenn Sie eine Registrierung mithilfe der API erstellen möchten, verwenden Sie [https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname.html#v1-registries-name-registryname-http-methods](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname.html#v1-registries-name-registryname-http-methods). Weitere Informationen finden Sie unter [Amazon EventBridge Schema Registry API Reference](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/index.html).

Informationen zur Verwendung der EventBridge Schemaregistrierung finden AWS CloudFormation Sie unter [EventSchemas Resource Type Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_EventSchemas.html) unter CloudFormation.

# Erstellen eines Ereignisschemas in Amazon EventBridge
<a name="eb-schema-create"></a>

Sie erstellen Schemas, indem Sie JSON-Dateien mit der [OpenAPI-Spezifikation oder der [JSONSchema Draft4-Spezifikation](https://json-schema.org/specification-links.html#draft-4)](https://swagger.io/specification/) verwenden. [Sie können Ihre eigenen Schemas erstellen oder hochladen, EventBridge indem Sie eine Vorlage verwenden oder ein Schema generieren, das auf dem JSON eines Ereignisses basiert.](eb-events.md) Sie können das Schema auch aus Ereignissen in einem [Event Bus](eb-event-bus.md) ableiten. Verwenden Sie die API-Aktion, um mithilfe der EventBridge Schema Registry API ein Schema zu erstellen. [https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#v1-registries-nam](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#v1-registries-nam)

Wenn Sie zwischen den Formaten OpenAPI 3 und JSONSchema Draft4 wählen, sollten Sie die folgenden Unterschiede berücksichtigen:
+ JSONSchema format unterstützt zusätzliche Schlüsselwörter, die in OpenAPI nicht unterstützt werden, wie `$schema, additionalItems` z.
+ Es gibt geringfügige Unterschiede in der Art und Weise, wie Schlüsselwörter behandelt werden, z. B. `type` und `format`.
+ OpenAPI unterstützt keine JSONSchema Hyperschema-Hyperlinks in JSON-Dokumenten.
+ Tools für OpenAPI konzentrieren sich in der Regel auf die Build-Time, wohingegen sich Tools für JSONSchema eher auf Laufzeitoperationen konzentrieren, wie z. B. Client-Tools für die Schemavalidierung.

Wir empfehlen, JSONSchema das Format zu verwenden, um die clientseitige Validierung zu implementieren, sodass Ereignisse, die gesendet werden, dem Schema entsprechen. EventBridge Sie können JSONSchema es verwenden, um einen Vertrag für gültige JSON-Dokumente zu definieren und dann einen [JSON-Schemavalidator](https://json-schema.org/tools) zu verwenden, bevor Sie die zugehörigen Ereignisse senden.

Nachdem Sie über ein neues Schema verfügen, können Sie [Codebindungen](eb-schema-code-bindings.md) herunterladen, um Anwendungen für Ereignisse mit diesem Schema zu erstellen.

# Erstellen eines Schemas mithilfe einer Vorlage in Amazon EventBridge
<a name="eb-schema-template"></a>

Sie können ein Schema aus einer heruntergeladenen Vorlagendatei erstellen oder indem Sie eine Vorlage direkt in der EventBridge Konsole bearbeiten. 

## Erstellen Sie ein Schema aus einer Vorlagendatei
<a name="eb-schema-template-file"></a>

Wenn Sie die Vorlage erhalten möchten, laden Sie sie von der Konsole herunter. Sie können die Vorlage so bearbeiten, dass das Schema Ihren Ereignissen entspricht. Laden Sie dann die neue Vorlage über die Konsole hoch.

**So laden Sie die Schemavorlage herunter**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich die Option **Schema registry (Schemaregistrierung)** aus.

1. Wählen Sie im Abschnitt **Getting started (Erste Schritte)** unter **Schema template (Schemavorlage)** die Option **Download (Herunterladen)** aus.

Alternativ können Sie die JSON-Vorlage aus dem folgenden Codebeispiel kopieren.

```
{
    "openapi": "3.0.0",
    "info": {
      "version": "1.0.0",
      "title": "Event"
    },
    "paths": {},
    "components": {
      "schemas": {
        "Event": {
          "type": "object",
          "properties": {
            "ordinal": {
              "type": "number",
              "format": "int64"
            },
            "name": {
              "type": "string"
            },
            "price": {
              "type": "number",
              "format": "double"
            },
            "address": {
              "type": "string"
            },
            "comments": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "created_at": {
              "type": "string",
              "format": "date-time"
            }
          }
        }
      }
    }
  }
```

**So laden Sie eine Schemavorlage hoch**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich **Schemata** und dann **Schema erstellen** aus.

1. (Optional) Wählen Sie eine Schemaregistrierung aus oder erstellen Sie sie.

1. Geben Sie unter **Schemadetails** einen Namen für das Schema ein.

1. (Optional) Geben Sie eine Beschreibung für das Schema ein.

1. Wählen Sie für **Schematyp** entweder **OpenAPI 3.0** oder **JSON Schema Draft 4** aus.

1. Ziehen Sie auf der Registerkarte **Erstellen** im Textfeld Ihre Schemadatei in das Textfeld oder fügen Sie die Schemaquelle ein.

1. Wählen Sie **Erstellen** aus.

## Bearbeiten einer Schemavorlage direkt in der Konsole
<a name="eb-schema-template-console"></a>

Sie können ein Schema direkt in der EventBridge Konsole erstellen.

**So bearbeiten Sie ein Schema in der Konsole**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich **Schemata** und dann **Schema erstellen** aus.

1. (Optional) Wählen Sie eine Schemaregistrierung aus oder erstellen Sie sie.

1. Geben Sie unter **Schemadetails** einen Namen für das Schema ein.

1. Wählen Sie für **Schematyp** entweder **OpenAPI 3.0** oder **JSON Schema Draft 4** aus.

1. (Optional) Geben Sie eine Beschreibung für das zu erstellende Schema ein.

1. Wählen Sie auf der Registerkarte **Erstellen** die Option **Vorlage laden** aus.

1. Bearbeiten Sie die Vorlage im Textfeld so, dass das Schema Ihren [Ereignissen](eb-events.md) entspricht. 

1. Wählen Sie **Erstellen** aus.

# Erstellen eines Schemas aus Event-JSON in Amazon EventBridge
<a name="eb-schemas-infer-from-json"></a>

Wenn Sie über die JSON-Datei eines Ereignisses verfügen, können Sie automatisch ein Schema für diesen Ereignistyp erstellen.

**So erstellen Sie ein Schema basierend auf dem JSON eines Ereignisses**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich **Schemata** und dann **Schema erstellen** aus.

1. (Optional) Wählen Sie eine Schemaregistrierung aus oder erstellen Sie sie.

1. Geben Sie unter **Schema details (Schemadetails)** einen Namen für Ihr Schema ein.

1. (Optional) Geben Sie eine Beschreibung für das erstellte Schema ein.

1. Wählen Sie für **Schematyp** die Option **OpenAPI 3.0** aus.

   Sie können es nicht verwenden JSONSchema , wenn Sie ein Schema aus dem JSON eines Ereignisses erstellen.

1. Wählen Sie **Discover from JSON (Aus JSON-Code erkennen)** aus.

1. Fügen Sie in das Textfeld unter **JSON**, die JSON-Quelle eines Ereignisses ein oder ziehen Sie sie dorthin.

   Sie könnten beispielsweise die Quelle aus diesem AWS Step Functions Ereignis für eine fehlgeschlagene Ausführung einfügen.

   ```
   {
       "version": "0",
       "id": "315c1398-40ff-a850-213b-158f73e60175",
       "detail-type": "Step Functions Execution Status Change",
       "source": "aws.states",
       "account": "012345678912",
       "time": "2019-02-26T19:42:21Z",
       "region": "us-east-1",
       "resources": [
         "arn:aws:states:us-east-1:012345678912:execution:state-machine-name:execution-name"
       ],
       "detail": {
           "executionArn": "arn:aws:states:us-east-1:012345678912:execution:state-machine-name:execution-name",
           "stateMachineArn": "arn:aws:states:us-east-1:012345678912:stateMachine:state-machine",
           "name": "execution-name",
           "status": "FAILED",
           "startDate": 1551225146847,
           "stopDate": 1551225151881,
           "input": "{}",
           "output": null
       }
   }
   ```

1. Klicken Sie auf **Discover schema (Schema erkennen)**.

1. EventBridge generiert ein OpenAPI-Schema für das Ereignis. Beispielsweise wird das folgende Schema für das vorhergehende Step-Functions-Ereignis generiert.

   ```
   {
     "openapi": "3.0.0",
     "info": {
       "version": "1.0.0",
       "title": "StepFunctionsExecutionStatusChange"
     },
     "paths": {},
     "components": {
       "schemas": {
         "AWSEvent": {
           "type": "object",
           "required": ["detail-type", "resources", "detail", "id", "source", "time", "region", "version", "account"],
           "x-amazon-events-detail-type": "Step Functions Execution Status Change",
           "x-amazon-events-source": "aws.states",
           "properties": {
             "detail": {
               "$ref": "#/components/schemas/StepFunctionsExecutionStatusChange"
             },
             "account": {
               "type": "string"
             },
             "detail-type": {
               "type": "string"
             },
             "id": {
               "type": "string"
             },
             "region": {
               "type": "string"
             },
             "resources": {
               "type": "array",
               "items": {
                 "type": "string"
               }
             },
             "source": {
               "type": "string"
             },
             "time": {
               "type": "string",
               "format": "date-time"
             },
             "version": {
               "type": "string"
             }
           }
         },
         "StepFunctionsExecutionStatusChange": {
           "type": "object",
           "required": ["output", "input", "executionArn", "name", "stateMachineArn", "startDate", "stopDate", "status"],
           "properties": {
             "executionArn": {
               "type": "string"
             },
             "input": {
               "type": "string"
             },
             "name": {
               "type": "string"
             },
             "output": {},
             "startDate": {
               "type": "integer",
               "format": "int64"
             },
             "stateMachineArn": {
               "type": "string"
             },
             "status": {
               "type": "string"
             },
             "stopDate": {
               "type": "integer",
               "format": "int64"
             }
           }
         }
       }
     }
   }
   ```

1. Nachdem das Schema generiert wurde, wählen Sie **Erstellen** aus.

# Ableiten von Schemas aus Event-Bus-Ereignissen in EventBridge
<a name="eb-schemas-infer"></a>

Amazon EventBridge kann Schemas ableiten, indem es Ereignisse entdeckt. Wenn Sie Schemata ableiten möchten, aktivieren Sie die Ereigniserkennung in einem Event Bus und jedes eindeutige Schema wird der Schemaregistrierung hinzugefügt, einschließlich der Schemata für kontoübergreifende Ereignisse. **Schemas, die von entdeckt wurden, EventBridge werden in der **Registrierung Entdeckte Schemas auf der Seite Schemas** angezeigt.**

Wenn sich der Inhalt von Ereignissen auf dem Event-Bus ändert, werden neue Versionen des zugehörigen Schemas EventBridge erstellt. EventBridge 

## Überlegungen beim Starten der Schemaerkennung auf einem Event-Bus
<a name="eb-schemas-infer-considerations"></a>

Bevor Sie die Schemaerkennung auf einem Eventbus aktivieren, sollten Sie die folgenden Überlegungen berücksichtigen:
+ Bei Aktivierung der Ereigniserkennung in einem Event Bus können Kosten entstehen. Die ersten fünf Millionen verarbeiteten Ereignisse in jedem Monat sind kostenlos.
+ EventBridge leitet Schemas standardmäßig aus kontenübergreifenden Ereignissen ab. Sie können dies jedoch deaktivieren, indem Sie die Eigenschaft aktualisieren. `cross-account` Weitere Informationen finden Sie unter [Discoverers](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-discoverers.html) in der API-Referenz zur EventBridge Schemaregistrierung.

**Anmerkung**  
Die Schemaerkennung wird für Event-Busse, die mit einem vom Kunden verwalteten Schlüssel verschlüsselt wurden, nicht unterstützt. Um die Schemaerkennung auf einem Event-Bus zu aktivieren, wählen Sie die Verwendung von AWS-eigener Schlüssel. Weitere Informationen finden Sie unter [KMS-Schlüsseloptionen](eb-encryption-at-rest-key-options.md).

**Um die Schemaerkennung auf einem Event-Bus (Konsole) zu starten oder zu beenden**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich die Option **Event Buses** aus.

1. Wählen Sie den Event-Bus aus, auf dem Sie die Schemaerkennung starten oder beenden möchten.

1. Führen Sie eine der folgenden Aktionen aus: 
   + Um die Schemaerkennung zu starten, wählen Sie **Erkennung starten** aus.
   + Um die Schemaerkennung zu beenden, wählen Sie **Discovery löschen**.

**Um die Schemaerkennung auf einem Event-Bus zu starten oder zu beenden (AWS CLI)**
+ Verwenden Sie [create-discoverer](https://docs.aws.amazon.com/cli/latest/reference/schemas/create-discoverer.html), um die Schemaerkennung zu starten.

  [Verwenden Sie delete-discoverer, um die Schemaerkennung zu beenden.](https://docs.aws.amazon.com/cli/latest/reference/schemas/delete-discoverer.html)

**Anmerkung**  
Die Schemaerkennung unterstützt keine Ereignisse, die größer als 1000 KiB sind. Diese Ereignisse werden nicht erkannt und es wird keine Fehlerbenachrichtigung generiert. Um Schemas für größere Ereignisse nachzuverfolgen, müssen Sie Schemas mithilfe der Schemaregistrierung manuell erstellen.

# Generieren von Codebindungen für Ereignisschemas in Amazon EventBridge
<a name="eb-schema-code-bindings"></a>

Sie können Codebindungen für [Ereignisschemas](eb-schema.md) generieren, um die Entwicklung in Golang, Java, Python und zu beschleunigen. TypeScript Codebindungen sind vefügbar für AWS -Serviceereignisse, von Ihnen [erstellte](eb-schema-create.md) Schemata und für Schemata, die Sie basierend auf [Ereignissen](eb-events.md) in einem [Event Bus](eb-event-bus.md) [generieren](eb-schemas-infer.md). Sie können Codebindungen für ein Schema mithilfe der EventBridge Konsole, der EventBridge [Schema Registry API](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/index.html) oder in Ihrer IDE mit einem Toolkit generieren. AWS 

**Um Codebindungen aus einem Schema zu generieren EventBridge**

1. Öffnen Sie die EventBridge Amazon-Konsole unter [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Wählen Sie im Navigationsbereich die Option **Schemas** aus.

1. Suchen Sie ein Schema, für das Sie Codebindungen benötigen. Durchsuchen Sie dazu entweder die Schemaregistrierungen oder suchen Sie nach einem Schema.

1. Wählen Sie den Schemanamen aus.

1. Wählen Sie auf der Seite **Schemadetails** im Abschnitt **Version** die Option **Codebindungen herunterladen** aus.

1. Wählen Sie auf der Seite **Download code bindings (Codebindungen herunterladen)** die Sprache der Codebindungen aus, die Sie herunterladen möchten.

1. Wählen Sie **Download (Herunterladen)** aus.

   Es kann einige Sekunden dauern, bis der Download beginnt. Bei der heruntergeladenen Datei handelt es sich um eine ZIP-Datei mit Codebindungen für die ausgewählte Sprache.