Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Invio di eventi con `PutEvents` Amazon EventBridge
<a name="eb-putevents"></a>

L'`PutEvents`azione invia più [eventi](eb-events.md) EventBridge in un'unica richiesta. Per ulteriori informazioni, consulta [PutEvents](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html)*Amazon EventBridge API Reference* e [put-events](https://docs.aws.amazon.com/cli/latest/reference/events/put-events.html) in *AWS CLI Command* Reference.

Ogni richiesta `PutEvents` può supportare un numero limitato di voci. Per ulteriori informazioni, consulta [EventBridge Quote Amazon](eb-quota.md). L'operazione `PutEvents` tenta di elaborare tutte le voci secondo l'ordine naturale della richiesta. Dopo la chiamata`PutEvents`, EventBridge assegna a ogni evento un ID univoco.

Il codice Java di esempio seguente invia due eventi identici a 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());
    }
}
```

------

Dopo aver eseguito questo codice, il risultato `PutEvents` include un array di voci di risposta. Ogni voce nell'array di risposte corrisponde a una voce nella matrice di richieste secondo l'ordine dall'inizio alla fine della richiesta e della risposta. La matrice di risposta `Entries` include sempre lo stesso numero di voci della matrice di richiesta.

## Gestione degli errori con `PutEvents`
<a name="eb-failure-handling"></a>

Per impostazione predefinita, se una singola immissione all'interno di una richiesta ha esito negativo, EventBridge continua a elaborare il resto delle voci della richiesta. Un array `Entries` di risposte può includere sia le voci riuscite che quelle non riuscite. È necessario rilevare le voci non riuscite e includerle in una chiamata successiva.

Le voci di risultati senza errori includono un valore `Id`, mentre le voci di risultati con errori includono i valori `ErrorCode` e `ErrorMessage`. `ErrorCode` descrive il tipo di errore. `ErrorMessage` fornisce ulteriori informazioni sull'errore. L'esempio seguente ha tre voci di risultati per una richiesta `PutEvents`. La seconda voce non ha esito positivo.

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

**Nota**  
Se si utilizza `PutEvents` per pubblicare un evento su un bus di eventi che non esiste, EventBridge event matching non troverà una regola corrispondente e eliminerà l'evento. Sebbene EventBridge invierà una `200` risposta, non fallirà la richiesta né includerà l'evento nel `FailedEntryCount` valore della risposta alla richiesta.

Le voci non riuscite possono essere incluse nelle richieste `PutEvents` successive. In primo luogo, per determinare se vi sono voci non riuscite nella richiesta, verifica il parametro `FailedRecordCount` in `PutEventsResult`. Se è diverso da zero, puoi aggiungere ogni `Entry` che ha un `ErrorCode` non nullo a una richiesta successiva. L'esempio seguente mostra un semplice gestore di errori.

```
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);
    }
```

## Invio di eventi tramite AWS CLI
<a name="eb-send-events-aws-cli"></a>

È possibile utilizzare il AWS CLI per inviare eventi personalizzati in EventBridge modo che possano essere elaborati. L'esempio seguente inserisce un evento personalizzato 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\" }"}]'
```

Puoi anche creare un file JSON contenente eventi personalizzati.

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

Quindi, per utilizzare il AWS CLI per leggere le voci di questo file e inviare eventi, al prompt dei comandi digitate:

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

## Calcolo delle dimensioni di immissione PutEvents degli eventi
<a name="eb-putevent-size"></a>

Quando invii eventi personalizzati EventBridge utilizzando l'`PutEvents`azione, puoi raggruppare fino a 10 eventi in un'unica richiesta di efficienza. La dimensione totale della richiesta, ovvero la somma di tutti gli eventi inseriti nella richiesta, deve essere inferiore a 1 MB. Questo limite si applica alla richiesta nel suo complesso, non alle singole voci. Un singolo evento può utilizzare fino a 1 MB completo se è l'unica voce nella richiesta. È possibile calcolare la dimensione delle voci prima dell'invio degli eventi.



**Nota**  
Il limite della dimensione viene imposto sulla *voce*. Anche se la voce è inferiore al limite di dimensione, l'*evento* in EventBridge è sempre maggiore della dimensione della voce a causa dei caratteri e delle chiavi necessari per la rappresentazione JSON dell'evento. Per ulteriori informazioni, consulta [Eventi in Amazon EventBridge](eb-events.md).

EventBridge calcola la `PutEventsRequestEntry` dimensione come segue:
+ Se specificato, il parametro `Time` è di 14 byte.
+ I parametri `Source` e `DetailType` sono il numero di byte per i relativi propri moduli con codifica UTF-8.
+ Se specificato, il parametro `Detail` è il numero di byte del relativo modulo con codifica UTF-8.
+ Se specificato, il parametro `Resources` è il numero di byte dei relativi moduli con codifica UTF-8.

Il seguente codice Java di esempio calcola le dimensioni di un determinato oggetto `PutEventsRequestEntry`. Per verificare che il limite di 1 MB non venga violato, è necessario eseguire il calcolo per tutti gli eventi di una richiesta.

```
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;
}
```

**Nota**  
Se la dimensione della voce è superiore a 1 MB, ti consigliamo di caricare l'evento in un bucket Amazon S3 e di `Object URL` includerlo nella voce. `PutEvents`