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.

# Senden von Ereignissen mit `PutEvents` in Amazon EventBridge
<a name="eb-putevents"></a>

Die `PutEvents` Aktion sendet mehrere [ Ereignisse ](eb-events.md) EventBridge in einer einzigen Anfrage an. Weitere Informationen finden Sie [ PutEvents ](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html) in der * EventBridge Amazon-API-Referenz * und unter [ put-events ](https://docs.aws.amazon.com/cli/latest/reference/events/put-events.html) in der *AWS CLI Befehlsreferenz. *

Jede `PutEvents`-Anforderung kann eine begrenzte Anzahl von Einträgen unterstützen. Weitere Informationen finden Sie unter [EventBridge Amazon-Kontingente](eb-quota.md). Die `PutEvents`-Operation versucht, alle Einträge in der natürlichen Reihenfolge der Anforderung zu verarbeiten. EventBridge Weist jedem Ereignis nach dem Aufruf `PutEvents` eine eindeutige ID zu.

Der folgende Beispiel-Java-Code sendet zwei identische Ereignisse an EventBridge.

------
#### [ AWS SDK for Java Version 2.x ]

```
EventBridgeClient eventBridgeClient =
    EventBridgeClient.builder().build();

PutEventsRequestEntry requestEntry = PutEventsRequestEntry.builder()
    .resources("resource1", "resource2")
    .source("com.mycompany.myapp")
    .detailType("myDetailType")
    .detail("{ \"key1\": \"value1\", \"key2\": \"value2\" }")
    .build();

List <
PutEventsRequestEntry > requestEntries = new ArrayList <
PutEventsRequestEntry > ();
requestEntries.add(requestEntry);

PutEventsRequest eventsRequest = PutEventsRequest.builder()
    .entries(requestEntries)
    .build();

PutEventsResponse result = eventBridgeClient.putEvents(eventsRequest);

for (PutEventsResultEntry resultEntry: result.entries()) {
    if (resultEntry.eventId() != null) {
        System.out.println("Event Id: " + resultEntry.eventId());
    } else {
        System.out.println("PutEvents failed with Error Code: " + resultEntry.errorCode());
    }
}
```

------
#### [ AWS SDK for Java Version 1.0 ]

```
EventBridgeClient eventBridgeClient =
    EventBridgeClient.builder().build();
    
PutEventsRequestEntry requestEntry = new PutEventsRequestEntry()
        .withTime(new Date())
        .withSource("com.mycompany.myapp")
        .withDetailType("myDetailType")
        .withResources("resource1", "resource2")
        .withDetail("{ \"key1\": \"value1\", \"key2\": \"value2\" }");

PutEventsRequest request = new PutEventsRequest()
        .withEntries(requestEntry, requestEntry);

PutEventsResult result = awsEventsClient.putEvents(request);

for (PutEventsResultEntry resultEntry : result.getEntries()) {
    if (resultEntry.getEventId() != null) {
        System.out.println("Event Id: " + resultEntry.getEventId());
    } else {
        System.out.println("Injection failed with Error Code: " + resultEntry.getErrorCode());
    }
}
```

------

Nachdem Sie diesen Code ausgeführt haben, enthält das `PutEvents`-Ergebnis ein Array von Antworteinträgen. Jeder Eintrag im Antwort-Array entspricht einem Eintrag im Anforderungs-Array in der Reihenfolge vom Anfang bis zum Ende der Anforderung und Antwort. Das Antwort-Array `Entries` enthält stets die gleiche Anzahl Einträge wie in der Anforderung.

## Behandlung von Fehlern bei `PutEvents`
<a name="eb-failure-handling"></a>

Wenn ein einzelner Eintrag in einer Anforderung fehlschlägt, EventBridge werden standardmäßig die restlichen Einträge in der Anforderung verarbeitet. Ein Antwort-`Entries`-Array kann sowohl erfolgreiche als auch erfolglose Einträge enthalten. Sie müssen erfolglose Einträge erkennen und sie im nachfolgenden Aufruf aufnehmen.

Erfolgreiche Ergebniseinträge enthalten einen `Id`-Wert und erfolglose Ergebniseinträge enthalten `ErrorCode`- und `ErrorMessage`-Werte. `ErrorCode` beschreibt die Art des Fehlers. `ErrorMessage` enthält weitere Informationen über den Fehler. Im folgenden Beispiel gibt es drei Ergebniseinträge für eine `PutEvents`-Anforderung. Der zweite Eintrag ist erfolglos.

```
{
    "FailedEntryCount": 1, 
    "Entries": [
        {
            "EventId": "11710aed-b79e-4468-a20b-bb3c0c3b4860"
        },
        {   "ErrorCode": "InternalFailure",
            "ErrorMessage": "Internal Service Failure"
        },
        {
            "EventId": "d804d26a-88db-4b66-9eaf-9a11c708ae82"
        }
    ]
}
```

**Anmerkung**  
Wenn Sie verwenden`PutEvents`, um ein Ereignis auf einem Event-Bus zu veröffentlichen, der nicht existiert, findet EventBridge Event Matching keine entsprechende Regel und das Ereignis wird gelöscht. Es EventBridge wird zwar eine `200` Antwort gesendet, die Anfrage wird jedoch nicht fehlschlagen oder das Ereignis nicht in den `FailedEntryCount` Wert der Anforderungsantwort aufnehmen.

Einträge, die erfolglos waren, können Sie in nachfolgenden `PutEvents`-Anforderungen aufnehmen. Wenn Sie herausfinden möchten, ob die Anforderung fehlerhafte Einträge enthält, überprüfen Sie zunächst den Parameter `FailedRecordCount` in `PutEventsResult`. Wenn er nicht Null ist, können Sie jeden `Entry`, der einen `ErrorCode` hat, der nicht Null ist, zu einer nachfolgenden Anforderung hinzufügen. Das folgende Beispiel zeigt einen einfachen Ausfall-Handler.

```
PutEventsRequestEntry requestEntry = new PutEventsRequestEntry()
        .withTime(new Date())
        .withSource("com.mycompany.myapp")
        .withDetailType("myDetailType")
        .withResources("resource1", "resource2")
        .withDetail("{ \"key1\": \"value1\", \"key2\": \"value2\" }");

List<PutEventsRequestEntry> putEventsRequestEntryList = new ArrayList<>();
for (int i = 0; i < 3; i++) {
    putEventsRequestEntryList.add(requestEntry);
}

PutEventsRequest putEventsRequest = new PutEventsRequest();
putEventsRequest.withEntries(putEventsRequestEntryList);
PutEventsResult putEventsResult = awsEventsClient.putEvents(putEventsRequest);

while (putEventsResult.getFailedEntryCount() > 0) {
    final List<PutEventsRequestEntry> failedEntriesList = new ArrayList<>();
    final List<PutEventsResultEntry> PutEventsResultEntryList = putEventsResult.getEntries();
    for (int i = 0; i < PutEventsResultEntryList.size(); i++) {
        final PutEventsRequestEntry putEventsRequestEntry = putEventsRequestEntryList.get(i);
        final PutEventsResultEntry putEventsResultEntry = PutEventsResultEntryList.get(i);
        if (putEventsResultEntry.getErrorCode() != null) {
            failedEntriesList.add(putEventsRequestEntry);
        }
    }
    putEventsRequestEntryList = failedEntriesList;
    putEventsRequest.setEntries(putEventsRequestEntryList);
    putEventsResult = awsEventsClient.putEvents(putEventsRequest);
    }
```

## Senden von Ereignissen mit dem AWS CLI
<a name="eb-send-events-aws-cli"></a>

Sie können das verwenden AWS CLI , um benutzerdefinierte Ereignisse an diese zu senden, EventBridge damit sie verarbeitet werden können. Im folgenden Beispiel wird ein benutzerdefiniertes Ereignis eingefügt in EventBridge:

```
aws events put-events \
--entries '[{"Time": "2016-01-14T01:02:03Z", "Source": "com.mycompany.myapp", "Resources": ["resource1", "resource2"], "DetailType": "myDetailType", "Detail": "{ \"key1\": \"value1\", \"key2\": \"value2\" }"}]'
```

Sie können auch eine JSON-Datei erstellen, die benutzerdefinierte Ereignisse enthält.

```
[
  {
    "Time": "2016-01-14T01:02:03Z",
    "Source": "com.mycompany.myapp",
    "Resources": [
      "resource1",
      "resource2"
    ],
    "DetailType": "myDetailType",
    "Detail": "{ \"key1\": \"value1\", \"key2\": \"value2\" }"
  }
]
```

Geben Sie dann in der Befehlszeile Folgendes ein, AWS CLI um die Einträge aus dieser Datei zu lesen und Ereignisse zu senden:

```
aws events put-events --entries file://{{entries.json}}
```

## Berechnung der Größe des PutEvents Ereigniseintrags
<a name="eb-putevent-size"></a>

Wenn Sie benutzerdefinierte Ereignisse an EventBridge die `PutEvents` Aktion senden, können Sie aus Effizienzgründen bis zu 10 Ereigniseinträge in einer einzigen Anfrage zusammenfassen. Die Gesamtgröße der Anforderung — d. h. die Summe aller Ereigniseinträge in der Anforderung — muss weniger als 1 MB (1.048.576 Byte) betragen. Dieses Limit gilt für die gesamte Anforderung, nicht für einzelne Einträge. Ein einzelnes Ereignis kann bis zu 1 MB beanspruchen, wenn es der einzige Eintrag in der Anfrage ist. Sie können die Größe des Eintrags berechnen, bevor Sie die Ereignisse senden.



**Anmerkung**  
Die Größenbeschränkung hängt vom *Eintrag* ab. Selbst wenn der Eintrag die Größenbeschränkung unterschreitet, EventBridge ist das * Ereignis * in aufgrund der erforderlichen Zeichen und Schlüssel der JSON-Darstellung des Ereignisses immer größer als die Eintragsgröße. Weitere Informationen finden Sie unter [Veranstaltungen bei Amazon EventBridge](eb-events.md).

EventBridge berechnet die `PutEventsRequestEntry` Größe wie folgt:
+ Falls angegeben, misst der Parameter `Time` 14 Bytes.
+ Die `DetailType` Parameter `Source` und geben die Anzahl der Byte für ihre UTF-8 kodierten Formen an.
+ Falls angegeben, entspricht der `Detail` Parameter der Anzahl der Byte für die UTF-8 kodierte Form.
+ Falls angegeben, entspricht jeder Eintrag des `Resources` Parameters der Anzahl der Byte für seine UTF-8 kodierten Formen.

Das folgende Java-Code-Beispiel berechnet die Größe eines bestimmten `PutEventsRequestEntry`-Objekts. Um sicherzustellen, dass das Limit von 1 MB nicht verletzt wird, müssen Sie die Berechnung für alle Ereignisse in einer Anfrage durchführen.

```
int getSize(PutEventsRequestEntry entry) {
    int size = 0;
    if (entry.getTime() != null) {
        size += 14;
    }
    size += entry.getSource().getBytes(StandardCharsets.UTF_8).length;
    size += entry.getDetailType().getBytes(StandardCharsets.UTF_8).length;
    if (entry.getDetail() != null) {
        size += entry.getDetail().getBytes(StandardCharsets.UTF_8).length;
    }
    if (entry.getResources() != null) {
        for (String resource : entry.getResources()) {
            if (resource != null) {
                size += resource.getBytes(StandardCharsets.UTF_8).length;
            }
        }
    }
    return size;
}
```

**Anmerkung**  
Wenn die Eintragsgröße größer als 1 MB (1.048.576 Byte) ist, empfehlen wir, das Ereignis in einen Amazon S3-Bucket hochzuladen und das Ereignis in den Eintrag aufzunehmen. `Object URL` `PutEvents`