Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Enviar eventos con `PutEvents` in Amazon EventBridge
<a name="eb-putevents"></a>

La `PutEvents` acción envía varios [eventos](eb-events.md) EventBridge en una sola solicitud. Para obtener más información, consulte [PutEvents](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html)la referencia de la * EventBridge API de Amazon y la referencia* de *AWS CLI comandos* [put-events](https://docs.aws.amazon.com/cli/latest/reference/events/put-events.html).

Cada solicitud `PutEvents` puede admitir un número limitado de entradas. Para obtener más información, consulte [EventBridge Cuotas de Amazon](eb-quota.md). La operación `PutEvents` intenta procesar todas las entradas en el orden natural de la solicitud. Después de llamar`PutEvents`, EventBridge asigna a cada evento un identificador único.

En el siguiente ejemplo, el código Java envía dos eventos idénticos 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());
    }
}
```

------

Tras ejecutar este código, el resultado de `PutEvents` incluye una matriz de entradas de respuesta. Cada entrada en la matriz de respuestas se corresponde con una entrada en la matriz de solicitudes siguiendo el orden de principio a fin de la solicitud y la respuesta. La matriz de respuesta `Entries` siempre incluye el mismo número de entradas que la matriz de solicitud.

## Gestión de errores con `PutEvents`
<a name="eb-failure-handling"></a>

De forma predeterminada, si se produce un error en una entrada individual de una solicitud, EventBridge continúa procesando el resto de las entradas de la solicitud. Una matriz de `Entries` de respuestas puede incluir entradas correctas e incorrectas. Debe detectar las entradas incorrectas e incluirlas en una llamada siguiente.

Las entradas de resultados correctas incluyen un valor `Id` y las entradas de resultados incorrectas incluyen valores `ErrorCode` y `ErrorMessage`. `ErrorCode` describe el tipo de error. `ErrorMessage` proporciona más información acerca del error. El ejemplo siguiente tiene tres entradas de resultados para una solicitud `PutEvents`. La segunda entrada no es correcta.

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

**nota**  
Si publicas `PutEvents` un evento en un bus de eventos que no existe, la coincidencia de EventBridge eventos no encontrará la regla correspondiente y descartará el evento. Aunque EventBridge enviará una `200` respuesta, no rechazará la solicitud ni incluirá el evento en el `FailedEntryCount` valor de la respuesta a la solicitud.

Puede incluir las entradas incorrectas en solicitudes `PutEvents` posteriores. En primer lugar, compruebe el parámetro `FailedRecordCount` en `PutEventsResult` para confirmar si se hay entradas incorrectas. Si no es cero, puedes añadir cada `Entry` que tenga un valor `ErrorCode` que no sea nulo a una solicitud posterior. En el siguiente ejemplo se muestra un administrador de errores.

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

## Enviar eventos mediante el AWS CLI
<a name="eb-send-events-aws-cli"></a>

Puede utilizar el AWS CLI para enviar eventos personalizados a EventBridge fin de que se puedan procesar. El siguiente ejemplo coloca un evento personalizado en 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\" }"}]'
```

También puede crear un archivo JSON que contenga eventos personalizados.

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

A continuación, para usar el AWS CLI para leer las entradas de este archivo y enviar eventos, en una línea de comandos, escriba:

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

## Calcular el tamaño de la entrada del PutEvents evento
<a name="eb-putevent-size"></a>

Cuando envías eventos personalizados para EventBridge usar la `PutEvents` acción, puedes agrupar hasta 10 entradas de eventos en una sola solicitud para aumentar la eficiencia. El tamaño total de la solicitud, es decir, la suma de todas las entradas de eventos de la solicitud, debe ser inferior a 1 MB. Este límite se aplica a la solicitud en su conjunto, no a las entradas individuales. Un solo evento puede consumir hasta 1 MB completo si es la única entrada de la solicitud. Puede calcular el tamaño de entrada antes de enviar los eventos.



**nota**  
Se impone un límite de tamaño en la *entrada*. Incluso si la entrada es inferior al límite de tamaño, el tamaño del *evento* siempre EventBridge es mayor que el tamaño de la entrada debido a los caracteres y claves necesarios para la representación del evento en JSON. Para obtener más información, consulte [Eventos en Amazon EventBridge](eb-events.md).

EventBridge calcula el `PutEventsRequestEntry` tamaño de la siguiente manera:
+ Si se especifica, el parámetro `Time` es de 14 bytes.
+ Los parámetros `Source` y `DetailType` son el número de bytes para sus formatos cifrados con UTF-8.
+ Si se especifica, el parámetro `Detail` es el número de bytes para el formato cifrado con UTF-8.
+ Si se especifica, cada entrada del parámetro `Resources` es el número de bytes para sus formatos cifrados con UTF-8.

El siguiente ejemplo de código Java calcula el tamaño de un objeto `PutEventsRequestEntry` dado. Para comprobar que no se infringe el límite de 1 MB, debe realizar el cálculo de todos los eventos de una solicitud.

```
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**  
Si el tamaño de la entrada es superior a 1 MB, te recomendamos subir el evento a un bucket de Amazon S3 e incluirlo `Object URL` en la `PutEvents` entrada.