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.
# Creación de patrones de EventBridge eventos de Amazon
Lo más probable es que no desee procesar todos los eventos que se envían a un bus de eventos o una canalización determinados. Más bien, es probable que desee seleccionar un subconjunto de todos los eventos entregados, en función del origen del evento, el tipo de evento y and/or los atributos de esos eventos.
Para especificar qué eventos enviar a un destino, debe crear un *patrón de eventos*. Un patrón de eventos define los datos que se EventBridge utilizan para determinar si se debe enviar el evento al destino. Si el patrón de eventos coincide con el evento, EventBridge envía el evento al destino. Los patrones de eventos tienen la misma estructura que los eventos con los que coinciden. Un patrón de eventos coincide con un evento o no lo hace.
**sugerencia**
Puede usar el EventBridge entorno aislado para probar los patrones de eventos comparándolos con eventos de muestra antes de crear o actualizar las reglas. Para obtener más información, consulte [Probar patrones de eventos con EventBridge Sandbox](eb-event-pattern-sandbox.md).
Por ejemplo, consideremos el siguiente evento de Amazon EC2:
```
{
"version": "0",
"id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718",
"detail-type": "EC2 Instance State-change Notification",
"source": "aws.ec2",
"account": "111122223333",
"time": "2017-12-22T18:43:48Z",
"region": "us-west-1",
"resources": [
"arn:aws:ec2:us-west-1:123456789012:instance/i-1234567890abcdef0"
],
"detail": {
"instance-id": "i-1234567890abcdef0",
"state": "terminated"
}
}
```
El siguiente patrón de eventos selecciona todos los EC2 `instance-termination` eventos de Amazon. Para ello, el patrón de eventos especifica tres requisitos para que coincidan con un evento:
1. La fuente del evento debe ser Amazon EC2.
1. El evento debe ser una notificación de EC2 cambio de estado de Amazon.
1. El estado de la EC2 instancia de Amazon debe ser`terminated`.
```
{
"source": ["aws.ec2"],
"detail-type": ["EC2 Instance State-change Notification"],
"detail": {
"state": ["terminated"]
}
}
```
Tenga en cuenta que en este ejemplo, el patrón del evento incluye campos *sobre* el evento (`source` y `detail-type`), así como un campo del cuerpo de evento (`state`).
**importante**
En EventBridge, es posible crear reglas que pueden provocar higher-than-expected cargos y restricciones. Por ejemplo, puede crear inadvertidamente una regla que conduzca a un bucle infinito, en el que una regla se active de forma recursiva sin fin. Supongamos que ACLs ha creado una regla para detectar los cambios en un bucket de Amazon S3 y activar el software para cambiarlos al estado deseado. Si la regla no está redactada con cuidado, el cambio posterior a la misma ACLs vuelve a activar la regla y se crea un bucle infinito.
Para obtener orientación sobre cómo escribir reglas y patrones de eventos precisos para minimizar estos resultados inesperados, consulte [Prácticas recomendadas para las reglas](eb-rules-best-practices.md) y [Prácticas recomendadas](eb-patterns-best-practices.md).
## Patrones de eventos para los buses de eventos
Para los buses de eventos, puede especificar un patrón de eventos para cada regla que cree para el bus. De esta forma, puede seleccionar qué eventos enviar a destinos específicos. Los patrones de eventos de los buses de eventos pueden coincidir con la fuente del evento, los metadatos del evento y los valores de detalle del and/or evento.
![\[Un evento se compara con el patrón de eventos de cada regla del bus y se envía al destino si coincide.\]](http://docs.aws.amazon.com/es_es/eventbridge/latest/userguide/images/event-pattern-bus_eventbridge_architecture.svg)
En el siguiente vídeo se analizan los aspectos básicos de los patrones de eventos de los buses de eventos:
## Patrones de eventos para EventBridge Pipes
En el caso de EventBridge las tuberías, puede especificar patrones de eventos para filtrar los eventos de la fuente de la tubería que desea que se envíen al destino de la tubería. Como cada canalización tiene una única fuente de eventos, los patrones de eventos de las canalizaciones pueden coincidir con los valores de and/or detalle de los metadatos de los eventos.
![\[Un evento se compara con el patrón de eventos de la canalización y se envía al destino si coincide.\]](http://docs.aws.amazon.com/es_es/eventbridge/latest/userguide/images/event-pattern-pipes_eventbridge_architecture.svg)
No todos los campos de eventos se pueden utilizar para crear patrones de eventos de canalizaciones. Para obtener más información, consulte [Filtrado](eb-pipes-event-filtering.md).
# Sintaxis del patrón de eventos
Para crear un patrón de eventos, especifique los campos con los que desea que coincida el patrón del evento. Especifique únicamente los campos que utilice para la coincidencia.
Por ejemplo, el siguiente ejemplo de patrón de eventos solo proporciona valores para tres campos: los campos de nivel superior `"source"` y`"detail-type"`, y el `"state"` campo dentro del campo `"detail"` objeto. EventBridgeomite todos los demás campos del evento al aplicar la regla.
```
{
"source": ["aws.ec2"],
"detail-type": ["EC2 Instance State-change Notification"],
"detail": {
"state": ["terminated"]
}
}
```
Para que un patrón de eventos coincida con un evento, el evento debe contener todos los nombres de campos enumerados en el patrón. Los nombres de los campos también deben aparecer en el evento con la misma estructura de anidación.
Al escribir patrones de evento para buscar eventos, puede utilizar la API de `TestEventPattern` o el comando de la CLI `test-event-pattern` para probar si el patrón coincide con los eventos correctos. Para obtener más información, consulte [TestEventPattern](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_TestEventPattern.html).
## Coincidencias de valores de eventos
En un patrón de eventos, el valor que debe coincidir está en una matriz JSON, entre corchetes ("[", "]") para que pueda proporcionar varios valores. Por ejemplo, para hacer coincidir los eventos de Amazon EC2 o AWS Fargate, puedes usar el siguiente patrón, que coincide con los eventos en los que el valor del `"source"` campo es `"aws.ec2"` o`"aws.fargate"`.
```
{
"source": ["aws.ec2", "aws.fargate"]
}
```
Para obtener más información, consulte [Hacer coincidir con varios valores de campo](eb-event-patterns-arrays.md).
## Uso de operadores de comparación en los patrones de EventBridge eventos de Amazon
Amazon EventBridge admite el filtrado declarativo de contenido mediante patrones de eventos. Mediante el filtrado de contenido, puede crear patrones de eventos complejos que solo coinciden con eventos bajo condiciones muy específicas. Por ejemplo, puede crear un patrón de eventos que coincida con un evento cuando:
+ Un campo del evento está dentro de un intervalo numérico específico.
+ El evento proviene de una dirección IP específica.
+ No existe un campo específico en el JSON del evento.
Para obtener más información, consulte [Operadores de comparación](eb-create-pattern-operators.md).
## Consideraciones sobre la creación de patrones de eventos
A continuación, se muestran algunos aspectos que debe considerar a la hora de crear sus patrones de eventos:
+ EventBridge ignora los campos del evento que no están incluidos en el patrón de eventos. El efecto es que hay un comodín `"*": "*"` para los campos que no aparecen en el patrón de eventos.
+ Los valores que coinciden con patrones de eventos siguen las reglas JSON. Puede incluir cadenas entre comillas (“), números y palabras clave `true`, `false` y `null`.
+ En el caso de las cadenas, EventBridge utiliza la character-by-character coincidencia exacta sin doblar mayúsculas y minúsculas ni normalizar ninguna otra cadena.
+ En el caso de los números, EventBridge utiliza la representación de cadenas. Por ejemplo, 300, 300.0 y 3.0e2 no se consideran iguales.
+ Si se especifican varios patrones para el mismo campo JSON, EventBridge solo usa el último.
+ Tenga en cuenta que cuando EventBridge compila patrones de eventos para su uso, utiliza un punto (.) como carácter de unión.
Esto significa que EventBridge tratará los siguientes patrones de eventos como idénticos:
```
## has no dots in keys
{ "detail" : { "state": { "status": [ "running" ] } } }
## has dots in keys
{ "detail" : { "state.status": [ "running" ] } }
```
Y que ambos patrones de eventos coincidirán con los dos eventos siguientes:
```
## has no dots in keys
{ "detail" : { "state": { "status": "running" } } }
## has dots in keys
{ "detail" : { "state.status": "running" } }
```
**nota**
Esto describe EventBridge el comportamiento actual y no se debe confiar en él para que no cambie.
+ Los patrones de eventos que contienen campos duplicados no son válidos. Si un patrón contiene campos duplicados, EventBridge solo tiene en cuenta el valor final del campo.
Por ejemplo, los siguientes patrones de eventos coincidirán con el mismo evento:
```
## has duplicate keys
{
"source": ["aws.s3"],
"source": ["aws.sns"],
"detail-type": ["AWS API Call via CloudTrail"],
"detail": {
"eventSource": ["s3.amazonaws.com"],
"eventSource": ["sns.amazonaws.com"]
}
}
## has unique keys
{
"source": ["aws.sns"],
"detail-type": ["AWS API Call via CloudTrail"],
"detail": { "eventSource": ["sns.amazonaws.com"] }
}
```
Y EventBridge trata los dos eventos siguientes como idénticos:
```
## has duplicate keys
{
"source": ["aws.s3"],
"source": ["aws.sns"],
"detail-type": ["AWS API Call via CloudTrail"],
"detail": [
{
"eventSource": ["s3.amazonaws.com"],
"eventSource": ["sns.amazonaws.com"]
}
]
}
## has unique keys
{
"source": ["aws.sns"],
"detail-type": ["AWS API Call via CloudTrail"],
"detail": [
{ "eventSource": ["sns.amazonaws.com"] }
]
}
```
**nota**
Esto describe EventBridge el comportamiento actual y no se debe confiar en él para que no cambie.
# Hacer coincidir los eventos con los valores de los campos de eventos
Puede usar todos los tipos de datos y valores JSON para hacer coincidir los eventos. A continuación, se muestran los eventos y los patrones de eventos que se corresponden con ellos.
## Coincidencia de campo
Puede hacer coincidir el valor de un campo. Considere el siguiente evento de Amazon EC2 Auto Scaling.
```
{
"version": "0",
"id": "3e3c153a-8339-4e30-8c35-687ebef853fe",
"detail-type": "EC2 Instance Launch Successful",
"source": "aws.autoscaling",
"account": "123456789012",
"time": "2015-11-11T21:31:47Z",
"region": "us-east-1",
"resources": [],
"detail": {
"eventVersion": "",
"responseElements": null
}
}
```
Para el evento anterior, puede utilizar el campo `"responseElements"` para que coincida.
```
{
"source": ["aws.autoscaling"],
"detail-type": ["EC2 Instance Launch Successful"],
"detail": {
"responseElements": [null]
}
}
```
## Coincidencia de valor
Considere el siguiente evento de Amazon Macie, que está truncado.
```
{
"version": "0",
"id": "0948ba87-d3b8-c6d4-f2da-732a1example",
"detail-type": "Macie Finding",
"source": "aws.macie",
"account": "123456789012",
"time": "2021-04-29T23:12:15Z",
"region":"us-east-1",
"resources": [
],
"detail": {
"schemaVersion": "1.0",
"id": "64b917aa-3843-014c-91d8-937ffexample",
"accountId": "123456789012",
"partition": "aws",
"region": "us-east-1",
"type": "Policy:IAMUser/S3BucketEncryptionDisabled",
"title": "Encryption is disabled for the S3 bucket",
"description": "Encryption is disabled for the Amazon S3 bucket. The data in the bucket isn’t encrypted
using server-side encryption.",
"severity": {
"score": 1,
"description": "Low"
},
"createdAt": "2021-04-29T15:46:02Z",
"updatedAt": "2021-04-29T23:12:15Z",
"count": 2,
.
.
.
```
El siguiente patrón de eventos coincide con cualquier evento que tenga una puntuación de gravedad de 1 y un recuento de 2.
```
{
"source": ["aws.macie"],
"detail-type": ["Macie Finding"],
"detail": {
"severity": {
"score": [1]
},
"count":[2]
}
}
```
# Eventos coincidentes en valores nulos y cadenas vacías en Amazon EventBridge
**importante**
En EventBridge, es posible crear reglas que pueden provocar higher-than-expected cargos y estrangulamientos. Por ejemplo, puede crear inadvertidamente una regla que conduzca a un bucle infinito, en el que una regla se active de forma recursiva sin fin. Supongamos que ACLs ha creado una regla para detectar los cambios en un bucket de Amazon S3 y activar el software para cambiarlos al estado deseado. Si la regla no está redactada con cuidado, el cambio posterior a la misma ACLs vuelve a activar la regla y se crea un bucle infinito.
Para obtener orientación sobre cómo escribir reglas y patrones de eventos precisos para minimizar estos resultados inesperados, consulte [Prácticas recomendadas para las reglas](eb-rules-best-practices.md) y [Prácticas recomendadas](eb-patterns-best-practices.md).
Puede crear un [patrón de eventos](eb-event-patterns.md) que coincida con un campo de un [evento](eb-events.md) que tenga un valor nulo o una cadena vacía. Considere el siguiente ejemplo de evento.
Consulte las mejores prácticas para evitar cargos y limitaciones superiores a lo esperado
```
{
"version": "0",
"id": "3e3c153a-8339-4e30-8c35-687ebef853fe",
"detail-type": "EC2 Instance Launch Successful",
"source": "aws.autoscaling",
"account": "123456789012",
"time": "2015-11-11T21:31:47Z",
"region": "us-east-1",
"resources": [
],
"detail": {
"eventVersion": "",
"responseElements": null
}
}
```
Para hacer coincidir eventos donde el valor de `eventVersion` es una cadena vacía, utilice el siguiente patrón de eventos, que coincide con el evento precedente.
```
{
"detail": {
"eventVersion": [""]
}
}
```
Para hacer coincidir eventos donde el valor de `responseElements` es una cadena vacía, utilice el siguiente patrón de eventos, que coincide con el evento precedente.
```
{
"detail": {
"responseElements": [null]
}
}
```
**nota**
Los valores nulos y las cadenas vacías no son intercambiables en coincidencia de patrones. Un patrón de eventos que coincide con cadenas vacías no coincide con los valores de `null`.
## Uso de valores nulos en AWS CloudFormation las plantillas
AWS CloudFormation no permite `null` valores en las plantillas. Si defines un patrón de eventos con un valor nulo mediante la sintaxis de objetos YAML o JSON, la validación de la plantilla falla y aparece el error:`'null' values are not allowed in templates`.
Para evitar esta limitación, especifica la `EventPattern` propiedad como una cadena JSON en lugar de un objeto YAML o JSON. En el siguiente ejemplo, se muestra cómo hacer coincidir los valores nulos de una AWS CloudFormation plantilla:
```
MyRule:
Type: AWS::Events::Rule
Properties:
EventPattern: '{"detail":{"responseElements":[null]}}'
```
# Hacer coincidir con varios valores de un campo de evento en Amazon EventBridge
El valor de cada campo de un [patrón de eventos](eb-event-patterns.md) es una matriz que contiene uno o más valores. Un patrón de eventos coincide con el [evento](eb-events.md) si alguno de los valores de la matriz coincide con el valor del evento. Si el valor en el evento es una matriz, entonces el patrón de eventos coincide si la intersección de la matriz de patrones de eventos y la matriz de eventos no está vacía.
**importante**
En EventBridge, es posible crear reglas que pueden generar cargos y limitaciones superiores a lo esperado. Por ejemplo, puede crear inadvertidamente una regla que conduzca a un bucle infinito, en el que una regla se active de forma recursiva sin fin. Imagine que creó una regla puede detectar que las ACL han cambiado en un bucket de Amazon S3 y activar software para cambiarlas al estado deseado. Si la regla no se ha escrito minuciosamente, un nuevo cambio de las ACL vuelve a activar la regla, lo que crea un bucle infinito.
Para obtener orientación sobre cómo escribir reglas y patrones de eventos precisos para minimizar estos resultados inesperados, consulte [Prácticas recomendadas para las reglas](eb-rules-best-practices.md) y [Prácticas recomendadas](eb-patterns-best-practices.md).
Por ejemplo, considere un patrón de eventos que incluya el siguiente campo.
```
"resources": [
"arn:aws:ec2:us-east-1:123456789012:instance/i-b188560f",
"arn:aws:ec2:us-east-1:111122223333:instance/i-b188560f",
"arn:aws:ec2:us-east-1:444455556666:instance/i-b188560f",
]
```
El patrón de eventos precedente coincide con un evento que incluye el siguiente texto, ya que el primer elemento de la matriz de patrones coincide con el segundo elemento de la matriz de eventos.
```
"resources": [
"arn:aws:autoscaling:us-east-1:123456789012:autoScalingGroup:eb56d16b-bbf0-401d-b893-d5978ed4a025:autoScalingGroupName/ASGTerminate",
"arn:aws:ec2:us-east-1:123456789012:instance/i-b188560f"
]
```
# Operadores de comparación para su uso en patrones de eventos en Amazon EventBridge
A continuación se muestra un resumen de todos los operadores de comparación disponibles en EventBridge.
Los operadores de comparación solo funcionan en los nodos secundarios, con la excepción de `$or` y `anything-but`.
| **Comparación** | **Ejemplo** | **Sintaxis de reglas** | **Soporte para buses de eventos** | **Soporte para canalizaciones** |
| --- | --- | --- | --- | --- |
| Y | El valor de Location (Ubicación) es “New York” y el de Day (Día) es “Monday” | `"Location": [ "New York" ], "Day": ["Monday"]` | Sí | Sí |
| [Anything-but](#eb-filtering-anything-but) | El valor de Estado es cualquier valor que no sea “inicializando”. | `"state": [ { "anything-but": "initializing" } ]` | Sí | Sí |
| [Anything-but (comienza por)](#eb-filtering-anything-but-prefix) | El valor de Región no se encuentra en EE. UU. | `"Region": [ { "anything-but": {"prefix": "us-" } } ]` | Sí | No |
| [Anything-but (termina con)](#eb-filtering-anything-but-suffix) | FileName no termina con la extensión.png. | `"FileName": [ { "anything-but": { "suffix": ".png" } } ]` | Sí | No |
| [Anything-but (omitir mayúsculas y minúsculas)](#eb-filtering-anything-but-ignore-case) | El estado es cualquier valor que no sea “inicializando” o cualquier otra variación entre mayúsculas y minúsculas, como “INICIALIZANDO”. | `"state": : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}` | Sí | No |
| [Anything-but con un carácter comodín](#eb-filtering-anything-but-wildcard) | FileName no es una ruta de archivo que incluya`/lib/`. | `"FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]` | Sí | No |
| [Comienza por](#eb-filtering-prefix-matching) | El valor de Región se encuentra en EE. UU. | `"Region": [ {"prefix": "us-" } ]` | Sí | Sí |
| Comienza por (omitir mayúsculas y minúsculas) | El nombre del servicio comienza por las letras “eventb”, independientemente del uso de las mayúsculas y minúsculas. | `{"service" : [{ "prefix": { "equals-ignore-case": "eventb" }}]}` | Sí | Sí |
| [Vacío](eb-event-patterns-null-values.md) | LastName está vacía. | `"LastName": [""]` | Sí | Sí |
| Igual a | El valor de Name (Nombre) es “Alice” | `"Name": [ "Alice" ]` | Sí | Sí |
| [Igual a (omitir mayúsculas y minúsculas)](#eb-filtering-equals-ignore-case-matching) | El valor de Name (Nombre) es “Alice” | `"Name": [ { "equals-ignore-case": "alice" } ]` | Sí | Sí |
| [Acaba con](#eb-filtering-suffix-matching) | FileName termina con una extensión.png | `"FileName": [ { "suffix": ".png" } ]` | Sí | Sí |
| Termina con (omitir mayúsculas y minúsculas) | El nombre del servicio termina con las letras “tbridge” o cualquier otra variante de mayúsculas y minúsculas, como “TBRIDGE”. | `{"service" : [{ "suffix": { "equals-ignore-case": "tBridge" }}]}` | Sí | Sí |
| [Existe](#eb-filtering-exists-matching) | ProductName existe | `"ProductName": [ { "exists": true } ]` | Sí | Sí |
| [No existe](#eb-filtering-exists-matching) | ProductName no existe | `"ProductName": [ { "exists": false } ]` | Sí | Sí |
| [No](#eb-filtering-anything-but) | El valor de Weather (Tiempo) es cualquier valor menos “Raining” (Lluvia) | `"Weather": [ { "anything-but": [ "Raining" ] } ]` | Sí | Sí |
| [Nulo](eb-event-patterns-null-values.md) | El valor de UserID (ID de usuario) es nulo | `"UserID": [ null ]` | Sí | Sí |
| [Valor numérico (igual a)](#filtering-numeric-matching) | El valor de Price (Precio) es 100 | `"Price": [ { "numeric": [ "=", 100 ] } ]` | Sí | Sí |
| [Valor numérico (rango)](#filtering-numeric-matching) | El valor de Price (Precio) es superior a 10 e inferior o igual a 20 | `"Price": [ { "numeric": [ ">", 10, "<=", 20 ] } ]` | Sí | Sí |
| O | PaymentType es «crédito» o «débito» | `"PaymentType": [ "Credit", "Debit"]` | Sí | Sí |
| [O (varios campos)](#eb-filtering-complex-example-or) | El valor de Location (Ubicación) es “New York” o el de Day (Día) es “Monday”. | `"$or": [ { "Location": [ "New York" ] }, { "Day": [ "Monday" ] } ]` | Sí | Sí |
| [Comodín](#eb-filtering-wildcard-matching) | Cualquier archivo con la extensión.png, ubicado dentro de la carpeta "dir" | `"FileName": [ { "wildcard": "dir/*.png" } ] ` | Sí | No |
## Coincidencia de prefijos
Puede hacer coincidir un evento dependiendo del prefijo de un valor en el origen del evento. Puede utilizar la coincidencia de prefijos para los valores de cadena.
Por ejemplo, el siguiente patrón de eventos coincidiría con cualquier evento en el que el campo `"time"` comenzara con `"2017-10-02"` como `"time": "2017-10-02T18:43:48Z"`.
```
{
"time": [ { "prefix": "2017-10-02" } ]
}
```
### El prefijo coincide y omite mayúsculas y minúsculas
También puede hacer coincidir el valor de un prefijo independientemente de las mayúsculas y minúsculas de los caracteres por los que comience un valor, utilizando `equals-ignore-case` junto con `prefix.`
Por ejemplo, el siguiente patrón de eventos coincidiría con cualquier evento en el que el campo `service` comenzara por la cadena de caracteres `EventB`, pero también coincidiría con `EVENTB`, `eventb` o cualquier otra combinación de mayúsculas y minúsculas de esos caracteres.
```
{
"detail": {"service" : [{ "prefix": { "equals-ignore-case": "EventB" }}]}
}
```
## Coincidencia de sufijos
Puede hacer coincidir un evento dependiendo del sufijo de un valor en el origen del evento. Puede utilizar la coincidencia de sufijos para los valores de cadena.
Por ejemplo, el siguiente patrón de eventos coincidiría con cualquier evento en el que el campo `"FileName"` terminara con la extensión de archivo `.png`.
```
{
"FileName": [ { "suffix": ".png" } ]
}
```
### El sufijo coincide y omite mayúsculas y minúsculas
También puede hacer coincidir el valor de un sufijo independientemente de las mayúsculas y minúsculas de los caracteres con los que termine un valor, utilizando `equals-ignore-case` junto con `suffix.`
Por ejemplo, el siguiente patrón de eventos coincidiría con cualquier evento en el que el campo `FileName` terminara con la cadena de caracteres `.png`, pero también `.PNG` o cualquier otra combinación de mayúsculas y minúsculas de esos caracteres.
```
{
"detail": {"FileName" : [{ "suffix": { "equals-ignore-case": ".png" }}]}
}
```
## Coincidencia "anything-but"
La coincidencia *anything-but* coincide con cualquier cosa excepto lo que se proporciona en la regla.
Puede utilizar la coincidencia anything-but con cadenas y valores numéricos, incluidas listas que contienen solo cadenas o solo números.
El siguiente patrón de eventos muestra la coincidencia anything-but con cadenas y números.
```
{
"detail": {
"state": [ { "anything-but": "initializing" } ]
}
}
{
"detail": {
"x-limit": [ { "anything-but": 123 } ]
}
}
```
El siguiente patrón de eventos muestra la coincidencia anything-but con una lista de cadenas.
```
{
"detail": {
"state": [ { "anything-but": [ "stopped", "overloaded" ] } ]
}
}
```
El siguiente patrón de eventos muestra la coincidencia anything-but con una lista de números.
```
{
"detail": {
"x-limit": [ { "anything-but": [ 100, 200, 300 ] } ]
}
}
```
### Coincidencia anything-but y omite mayúsculas y minúsculas
También se puede utilizar `equals-ignore-case` junto con `anything-but` para hacer coincidir los valores de las cadenas independientemente de las mayúsculas y minúsculas de los caracteres.
El siguiente patrón de eventos coincide con los campos `state` que no contienen la cadena “inicializando”, “INICIALIZANDO”, “Inicializando” o cualquier otra combinación de mayúsculas y minúsculas de esos caracteres.
```
{
"detail": {"state" : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}
}
```
También puede usar `equals-ignore-case` junto con `anything-but` para compararlo con una lista de valores:
```
{
"detail": {"state" : [{ "anything-but": { "equals-ignore-case": ["initializing", "stopped"] }}]}
}
```
### Coincidencia anything-but en prefijos
Puede usar `prefix` junto con `anything-but` para hacer coincidir valores de cadena que no comiencen por el valor especificado. Esto incluye valores únicos o una lista de valores.
El siguiente patrón de eventos muestra la coincidencia anything-but que coincide con cualquier evento que no tenga el prefijo `"init"` en el campo `"state"`.
```
{
"detail": {
"state": [ { "anything-but": { "prefix": "init" } } ]
}
}
```
El siguiente patrón de eventos muestra la coincidencia anything-but con una lista de valores de prefijos. Este patrón de eventos coincide con cualquier evento que no tenga el prefijo `"init"` ni `"stop"` en el campo `"state"`.
```
{
"detail": {
"state" : [{ "anything-but": { "prefix": ["init", "stop"] } } ] }
}
}
```
### Coincidencia anything-but en sufijos
Puede usar `suffix` junto con `anything-but` para hacer coincidir valores de cadena que no terminen con el valor especificado. Esto incluye valores únicos o una lista de valores.
El siguiente patrón de eventos coincide con cualquier valor del campo `FileName` que no termine con `.txt`.
```
{
"detail": {
"FileName": [ { "anything-but": { "suffix": ".txt" } } ]
}
}
```
El siguiente patrón de eventos muestra la coincidencia anything-but con una lista de valores de sufijos. Este patrón de eventos coincide con cualquier valor del campo `FileName` que no termine con `.txt` o `.rtf`.
```
{
"detail": {
"FileName": [ { "anything-but": { "suffix": [".txt", ".rtf"] } } ]
}
}
```
### Coincidencia anything-but con caracteres comodín
Puede utilizar el carácter comodín (\$1) en los valores que especifique para la coincidencia anything-but. Esto incluye valores únicos o una lista de valores.
El siguiente patrón de eventos coincide con cualquier valor del campo `FileName` que no contenga `/lib/`.
```
{
"detail": {
"FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]
}
}
```
El siguiente patrón de eventos muestra la coincidencia anything-but con una lista de valores que incluye caracteres comodín. Este patrón de eventos coincide con cualquier valor del campo `FileName` que no contenga `/lib/` o `/bin/`.
```
{
"detail": {
"FilePath" : [{ "anything-but": { "wildcard": ["*/lib/*", "*/bin/*"] }}]
}
}
```
Para obtener más información, consulte [Coincidencia con comodines](#eb-filtering-wildcard-matching).
## Coincidencia numérica
La coincidencia numérica funciona con valores que son números JSON. Está limitada a valores entre -5.0e9 y \$15.0e9 inclusive, con 15 dígitos de precisión o seis dígitos a la derecha del punto decimal.
A continuación, se muestra la coincidencia numérica de un patrón de eventos que solo coincide con los eventos que son verdaderos en todos los campos.
```
{
"detail": {
"c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ],
"d-count": [ { "numeric": [ "<", 10 ] } ],
"x-limit": [ { "numeric": [ "=", 3.018e2 ] } ]
}
}
```
## Coincidencia de direcciones IP
Puede utilizar la coincidencia de direcciones IP para IPv6 las direcciones IPv4 y. El siguiente patrón de eventos muestra las direcciones IP que coinciden con las direcciones IP que comienzan con 10.0.0 y terminan con un número entre 0 y 255.
```
{
"detail": {
"sourceIPAddress": [ { "cidr": "10.0.0.0/24" } ]
}
}
```
## Coincidencia exists
La *coincidencia exists* funciona en presencia o ausencia de un campo en la JSON del evento.
La coincidencia exists solo funciona en nodos secundarios. No funciona en nodos intermedios.
El siguiente patrón de eventos coincide con cualquier evento que tenga un campo `detail.state`.
```
{
"detail": {
"state": [ { "exists": true } ]
}
}
```
El patrón de eventos precedente coincide con el siguiente evento.
```
{
"version": "0",
"id": "7bf73129-1428-4cd3-a780-95db273d1602",
"detail-type": "EC2 Instance State-change Notification",
"source": "aws.ec2",
"account": "123456789012",
"time": "2015-11-11T21:29:54Z",
"region": "us-east-1",
"resources": ["arn:aws:ec2:us-east-1:123456789012:instance/i-abcd1111"],
"detail": {
"instance-id": "i-abcd1111",
"state": "pending"
}
}
```
El patrón de eventos anterior NO coincide con el evento siguiente porque no tiene un campo `detail.state`.
```
{
"detail-type": [ "EC2 Instance State-change Notification" ],
"resources": [ "arn:aws:ec2:us-east-1:123456789012:instance/i-02ebd4584a2ebd341" ],
"detail": {
"c-count" : {
"c1" : 100
}
}
}
```
## Equals-ignore-case coincidente
*La quals-ignore-case coincidencia E* funciona con valores de cadenas independientemente de las mayúsculas y minúsculas.
El siguiente patrón de eventos coincide con cualquier evento que tenga un campo `detail-type` que coincida con la cadena especificada, independientemente de las mayúsculas y minúsculas.
```
{
"detail-type": [ { "equals-ignore-case": "ec2 instance state-change notification" } ]
}
```
El patrón de eventos precedente coincide con el siguiente evento.
```
{
"detail-type": [ "EC2 Instance State-change Notification" ],
"resources": [ "arn:aws:ec2:us-east-1:123456789012:instance/i-02ebd4584a2ebd341" ],
"detail": {
"c-count" : {
"c1" : 100
}
}
}
```
## Coincidencia con comodines
Puede utilizar el carácter comodín (\$1) para hacer coincidir los valores de cadena en patrones de eventos.
**nota**
Actualmente, el carácter comodín solo se admite en las reglas del bus de eventos.
Consideraciones a la hora de utilizar caracteres comodín en los patrones de eventos:
+ Puede especificar cualquier número de caracteres comodín en un valor de cadena determinado; sin embargo, no se admiten caracteres comodín consecutivos.
+ EventBridge admite el uso del carácter de barra invertida (\$1) para especificar los caracteres literales \$1 y\$1 en los filtros de comodín:
+ La cadena `\*` representa el carácter \$1 literal
+ La cadena `\\` representa el carácter \$1 literal
No se admite el uso de la barra invertida para escapar de otros caracteres.
### Complejidad de caracteres comodín y patrones de eventos
Existe un límite en cuanto a la complejidad de una regla que utilice caracteres comodín. Si una regla es demasiado compleja, EventBridge devuelve un `InvalidEventPatternException` al intentar crearla. Si la regla genera un error de este tipo, considere la posibilidad de utilizar las siguientes instrucciones para reducir la complejidad del patrón de eventos:
+ **Reduzca el número de caracteres comodín utilizados**
Utilice caracteres comodín solo cuando realmente necesite hacer coincidir varios valores posibles. Por ejemplo, considere el siguiente patrón de eventos, en el que desea hacer coincidir los buses de evento de la misma región:
```
{
"EventBusArn": [ { "wildcard": "*:*:*:*:*:event-bus/*" } ]
}
```
En el caso anterior, muchas de las secciones de la ARN se basarán directamente en la región en la que residan los buses de evento. Por lo tanto, si utiliza la región `us-east-1`, el siguiente ejemplo podría ser un patrón menos complejo que aún coincida con los valores deseados:
```
{
"EventBusArn": [ { "wildcard": "arn:aws:events:us-east-1:*:event-bus/*" } ]
}
```
+ **Reduzca las secuencias de caracteres que se repiten después de un carácter comodín**
Si la misma secuencia de caracteres aparece varias veces después de usar un comodín, aumenta la complejidad del procesamiento del patrón de eventos. Rediseñe el patrón de eventos para minimizar las secuencias repetidas. Por ejemplo, considere el siguiente ejemplo, que coincide con el nombre de archivo `doc.txt` de cualquier usuario:
```
{
"FileName": [ { "wildcard": "/Users/*/dir/dir/dir/dir/dir/doc.txt" } ]
}
```
Si supiera que el archivo `doc.txt` solo aparecería en la ruta especificada, podría reducir la secuencia de caracteres repetidos de la siguiente manera:
```
{
"FileName": [ { "wildcard": "/Users/*/doc.txt" } ]
}
```
## Ejemplo complejo con coincidencia múltiple
Puede combinar varios criterios de coincidencia en un patrón de eventos más complejo. Por ejemplo, la siguiente regla combina los patrones de eventos `anything-but` y `numeric`.
```
{
"time": [ { "prefix": "2017-10-02" } ],
"detail": {
"state": [ { "anything-but": "initializing" } ],
"c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ],
"d-count": [ { "numeric": [ "<", 10 ] } ],
"x-limit": [ { "anything-but": [ 100, 200, 300 ] } ]
}
}
```
**nota**
Al crear patrones de eventos, si incluye una clave más de una vez, la última referencia será la que se utilice para evaluar los eventos. Por ejemplo, para el siguiente patrón:
```
{
"detail": {
"location": [ { "prefix": "us-" } ],
"location": [ { "anything-but": "us-east" } ]
}
}
```
solo se tendrá en cuenta `{ "anything-but": "us-east" }` a la hora de evaluar la `location`.
## Ejemplo complejo con coincidencia `$or`
También puede crear patrones de eventos complejos que comprueben si *alguno* de los valores de los campos coinciden en varios campos. Utilice `$or` para crear un patrón de eventos que coincida si alguno de los valores de varios campos coincide.
Tenga en cuenta que puede incluir otros tipos de filtros, como [coincidencia numérica](#filtering-numeric-matching) y [matrices](eb-event-patterns-arrays.md), en la coincidencia de patrones para los campos individuales del constructo `$or`.
El siguiente patrón de eventos coincide si se cumple alguna de las siguientes condiciones:
+ El campo `c-count` es mayor que 0 o menor o igual que 5.
+ El campo `d-count` tiene menos de 10.
+ El campo `x-limit` es igual a 3.018e2.
```
{
"detail": {
"$or": [
{ "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ] },
{ "d-count": [ { "numeric": [ "<", 10 ] } ] },
{ "x-limit": [ { "numeric": [ "=", 3.018e2 ] } ] }
]
}
}
```
**nota**
APIs los que acepten un patrón de eventos (como`PutRule`, `CreateArchive``UpdateArchive`, y`TestEventPattern`) arrojarán un valor `InvalidEventPatternException` si el uso de los `$or` resultados da como resultado más de 1000 combinaciones de reglas.
Para determinar el número de combinaciones de reglas en un patrón de eventos, multiplique el número total de argumentos de cada matriz `$or` del patrón de eventos. Por ejemplo, el patrón anterior contiene una sola matriz `$or` con tres argumentos, por lo que el número total de combinaciones de reglas también es tres. Si agrega otra matriz `$or` con dos argumentos, el total de combinaciones de reglas sería seis.
# Mejores prácticas para los patrones de EventBridge eventos de Amazon
A continuación, se muestran algunas prácticas recomendadas que se deben tener en cuenta al definir los patrones de eventos en sus reglas del bus de eventos.
## Evitar escribir bucles infinitos
En EventBridge, es posible crear reglas que conduzcan a bucles infinitos, en los que una regla se activa repetidamente. Por ejemplo, una regla puede detectar ACLs los cambios en un bucket de S3 y activar el software para cambiarlos al estado deseado. Si la regla no está redactada con cuidado, el cambio posterior a la misma ACLs vuelve a activar la regla y se crea un bucle infinito.
Para evitar estos problemas, escriba los patrones de eventos de sus reglas para que sean lo más precisos posible, de modo que solo coincidan con los eventos que realmente quiere que se envíen al destino. En el ejemplo anterior, crearía un patrón de eventos que coincidiera con los eventos, de modo que las acciones desencadenadas no vuelvan a activar la misma regla. Por ejemplo, cree un patrón de eventos en la regla que coincida con los eventos solo si ACLs se descubre que están en un estado incorrecto, en lugar de hacerlo después de cualquier cambio. Para obtener más información, consulte [Hacer que los patrones de eventos sean lo más precisos posible](#eb-patterns-best-practices-precision) y [Limitar sus patrones de eventos para tener en cuenta las actualizaciones del origen de los eventos](#eb-patterns-best-practices-future-proof).
Un bucle infinito puede generar cargos superiores a los esperados rápidamente. También puede provocar una limitación y un retraso en la entrega de los eventos. Puede controlar el límite superior de tus tasas de invocación para recibir alertas sobre picos de volumen inesperados.
Utilice la función de presupuestos para que le avise cuando los cargos superen el límite especificado. Para obtener más información, consulte [Gestión de costos con presupuestos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/budgets-managing-costs.html).
## Hacer que los patrones de eventos sean lo más precisos posible
Cuanto más preciso sea el patrón de eventos, mayor será la probabilidad de que coincida solo con los eventos que realmente desea y evitará coincidencias inesperadas cuando se agreguen nuevos eventos a un origen de eventos o se actualicen los eventos existentes para incluir nuevas propiedades.
Los patrones de eventos pueden incluir filtros que coincidan con:
+ Metadatos del evento sobre el evento, como `source`, `detail-type`, `account` o`region`.
+ Datos de eventos, es decir, los campos dentro del objeto `detail`.
+ El contenido del evento o los valores reales de los campos dentro del objeto `detail`.
La mayoría de los patrones son simples, como especificar solo los filtros `source` y `detail-type`. Sin embargo, EventBridge los patrones incluyen la flexibilidad de filtrar cualquier clave o valor del evento. Además, puede aplicar filtros de contenido, como filtros `prefix` y `suffix` para mejorar la precisión de sus patrones. Para obtener más información, consulte [Uso de operadores de comparación en los patrones de EventBridge eventos de Amazon](eb-create-pattern.md#eb-event-patterns-content-based-filtering).
### Especifique el origen del evento y el tipo de detalle como filtros
Puede reducir la generación de bucles infinitos y la coincidencia de eventos no deseados haciendo que sus patrones de eventos sean más precisos utilizando los campos de metadatos `source` y `detail-type`.
Cuando necesite hacer coincidir valores específicos dentro de dos o más campos, utilice el operador de comparación `$or` en lugar de enumerar todos los valores posibles dentro de una sola matriz de valores.
Para los eventos que se entreguen de AWS CloudTrail forma automática, te recomendamos que utilices el `eventName` campo como filtro.
El siguiente ejemplo de patrón de eventos coincide con `CreateQueue` o `SetQueueAttributes` desde el servicio Amazon Simple Queue Service `CreateKey` o con `DisableKeyRotation` eventos del AWS Key Management Service servicio.
```
{
"detail-type": ["AWS API Call via CloudTrail"],
"$or": [{
"source": [
"aws.sqs"
],
"detail": {
"eventName": [
"CreateQueue",
"SetQueueAttributes"
]
}
},
{
"source": [
"aws.kms"
],
"detail": {
"eventName": [
"CreateKey",
"DisableKeyRotation"
]
}
}
]
}
```
### Especificar la cuenta y la región como filtros
Inclusión de los campos `region` y `account` en el patrón de eventos le ayuda a limitar la coincidencia de eventos entre cuentas o regiones.
### Especificar los filtros de contenido
El filtrado basado en el contenido puede ayudar a mejorar la precisión del patrón de eventos y, al mismo tiempo, mantener la longitud del patrón de eventos al mínimo. Por ejemplo, la coincidencia basada en un rango numérico puede resultar útil en lugar de enumerar todos los valores numéricos posibles.
Para obtener más información, consulte [Uso de operadores de comparación en los patrones de EventBridge eventos de Amazon](eb-create-pattern.md#eb-event-patterns-content-based-filtering).
## Limitar sus patrones de eventos para tener en cuenta las actualizaciones del origen de los eventos
Al crear patrones de eventos, debe tener en cuenta que los esquemas y dominios de los eventos pueden evolucionar y expandirse con el tiempo. Una vez más, hacer que los patrones de eventos sean lo más precisos posible le ayuda a limitar las coincidencias inesperadas si el origen del evento cambia o se expande.
Por ejemplo, supongamos que está realizando la coincidencia con eventos de un nuevo microservicio que publica eventos relacionados con los pagos. Inicialmente, el servicio usa el dominio `acme.payments` y publica un solo evento, `Payment accepted`:
```
{
"detail-type": "Payment accepted",
"source": "acme.payments",
"detail": {
"type": "credit",
"amount": "100",
"date": "2023-06-10",
"currency": "USD"
}
}
}
```
En este punto, podría crear un patrón de eventos simple que coincida con los eventos de Pago aceptado:
```
{ “source” : “acme.payments” }
```
Sin embargo, supongamos que el servicio introduce más adelante un nuevo evento para los pagos rechazados:
```
{
"detail-type": "Payment rejected",
"source": "acme.payments",
"detail": {
}
}
```
En este caso, el patrón de eventos simple que creó ahora coincidirá con ambos `Payment accepted` `Payment rejected` eventos. EventBridge enruta ambos tipos de eventos al objetivo especificado para su procesamiento, lo que puede provocar errores de procesamiento y costes de procesamiento adicionales.
Para limitar el patrón de eventos a `Payment accepted` eventos únicamente, debes especificar ambos `source` y`detail-type`, como mínimo:
```
{
"detail-type": "Payment accepted",
"source": "acme.payments"
}
}
```
También puede especificar la cuenta y la región en el patrón de eventos para limitar aún más los eventos entre cuentas o regiones que coincidan con esta regla.
```
{
"account": "012345678910",
"source": "acme.payments",
"region": "AWS-Region",
"detail-type": "Payment accepted"
}
```
## Validar patrones de eventos
Para garantizar que las reglas coincidan con los eventos deseados, le recomendamos encarecidamente que valide sus patrones de eventos. Puede validar sus patrones de eventos mediante la EventBridge consola o la API:
+ En la EventBridge consola, puedes crear y probar patrones de eventos [como parte de la creación de una regla](eb-create-rule-visual.md) o por separado [mediante el Sandbox](eb-event-pattern-sandbox.md).
+ Puede probar sus patrones de eventos AWS CLI mediante el [test-event-pattern](https://docs.aws.amazon.com/cli/latest/reference/events/test-event-pattern.html)comando.