As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Criação de padrões de EventBridge eventos na Amazon
É provável que você não queira processar todos os eventos que são entregues a um determinado barramento de eventos ou pipe. Em vez disso, você provavelmente desejará selecionar um subconjunto de todos os eventos entregues, com base na origem do evento, no tipo de evento e nos and/or atributos desses eventos.
Para especificar quais eventos enviar a um destino, crie um *padrão de eventos*. Um padrão de evento define os dados EventBridge usados para determinar se o evento deve ser enviado ao destino. Se o padrão do evento corresponder ao evento, EventBridge envia o evento para o destino. Os padrões de eventos têm a mesma estrutura que os eventos aos quais correspondem. Um padrão de evento corresponde a um evento ou não corresponde.
**dica**
Você pode usar o EventBridge Sandbox para testar padrões de eventos em relação a eventos de amostra antes de criar ou atualizar regras. Para obter mais informações, consulte [Testando padrões de eventos usando o EventBridge Sandbox](eb-event-pattern-sandbox.md).
Por exemplo, considere o seguinte evento da 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"
}
}
```
O padrão de eventos a seguir seleciona todos os EC2 `instance-termination` eventos da Amazon. Ele faz isso especificando três requisitos para ter correspondência com um evento:
1. A origem do evento deve ser a Amazon EC2.
1. O evento deve ser uma notificação de EC2 mudança de estado da Amazon.
1. O estado da EC2 instância da Amazon deve ser`terminated`.
```
{
"source": ["aws.ec2"],
"detail-type": ["EC2 Instance State-change Notification"],
"detail": {
"state": ["terminated"]
}
}
```
Observe que, neste exemplo, o padrão de eventos inclui campos *sobre* o evento, `source` e `detail-type`, bem como um campo do corpo do evento, `state`.
**Importante**
Em EventBridge, é possível criar regras que podem gerar higher-than-expected cobranças e estrangulamentos. Por exemplo, é possível criar, por engano, uma regra que leva a um loop infinito, em que uma regra é acionada recursivamente sem fim. Suponha que você ACLs tenha criado uma regra para detectar as alterações em um bucket do Amazon S3 e acionar o software para alterá-las para o estado desejado. Se a regra não for escrita com cuidado, a alteração subsequente na ACLs acionará a regra novamente, criando um loop infinito.
Para obter orientação sobre como escrever regras precisas e padrões de eventos para minimizar esses resultados inesperados, consulte [Práticas recomendadas para regras](eb-rules-best-practices.md) e [Práticas recomendadas](eb-patterns-best-practices.md).
## Padrões de evento para barramentos de eventos
Para barramentos de eventos, você pode especificar um padrão de eventos para cada regra criada para o barramento. Dessa forma, você pode selecionar quais eventos enviar a destinos específicos. Os padrões de eventos para barramentos de eventos podem corresponder à fonte do evento, aos metadados do evento e aos valores de detalhes and/or do evento.
![\[Um evento é comparado ao padrão de eventos de cada regra do barramento e enviado ao destino, se houver correspondência.\]](http://docs.aws.amazon.com/pt_br/eventbridge/latest/userguide/images/event-pattern-bus_eventbridge_architecture.svg)
O seguinte vídeo aborda os conceitos básicos dos padrões de eventos para barramentos de eventos:
## Padrões de eventos para EventBridge Pipes
Para EventBridge Pipes, você pode especificar padrões de eventos para filtrar os eventos da fonte de tubulação que você deseja entregar ao destino da tubulação. Como cada canal tem uma única fonte de eventos, os padrões de eventos dos canais podem corresponder aos valores and/or detalhados dos metadados do evento.
![\[Um evento é comparado com o padrão de eventos do pipe e enviado ao destino, se houver correspondência.\]](http://docs.aws.amazon.com/pt_br/eventbridge/latest/userguide/images/event-pattern-pipes_eventbridge_architecture.svg)
Nem todos os campos de eventos podem ser usados para construir padrões de eventos do pipe. Para obter mais informações, consulte [Filtrar](eb-pipes-event-filtering.md).
# Sintaxe do padrão de evento
Para criar um padrão de evento, especifique os campos aos quais o padrão de evento deve corresponder. Especifique somente os campos usados para fazer a correspondência.
Por exemplo, o exemplo de padrão de evento a seguir fornece valores somente para três campos: os campos de nível superior `"source"` e`"detail-type"`, e o `"state"` campo dentro do campo do `"detail"` objeto. EventBridgeignora todos os outros campos do evento ao aplicar a regra.
```
{
"source": ["aws.ec2"],
"detail-type": ["EC2 Instance State-change Notification"],
"detail": {
"state": ["terminated"]
}
}
```
Para que um padrão de evento corresponda a um evento, o evento deve conter todos os nomes de campos listados no padrão do evento. Os nomes de campos também devem aparecer no evento com a mesma estrutura de aninhamento.
Ao gravar padrões de regras para corresponder, pode usar a API `TestEventPattern` ou o comando `test-event-pattern` da CLI para garantir que o padrão corresponda ao JSON correto. Para obter mais informações, consulte [TestEventPattern](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_TestEventPattern.html).
## Valores de eventos correspondentes
Em um padrão de evento, o valor correspondente está em uma matriz JSON, entre colchetes ("[", "]") para que possa fornecer vários valores. Por exemplo, para combinar eventos da Amazon EC2 ou AWS Fargate, você pode usar o seguinte padrão, que corresponde a eventos em que o valor do `"source"` campo é `"aws.ec2"` ou`"aws.fargate"`.
```
{
"source": ["aws.ec2", "aws.fargate"]
}
```
Para obter mais informações, consulte [Fazer a correspondência com vários valores de campo](eb-event-patterns-arrays.md).
## Usando operadores de comparação nos padrões de EventBridge eventos da Amazon
A Amazon EventBridge oferece suporte à filtragem declarativa de conteúdo usando padrões de eventos. Com a filtragem de conteúdo, é possível escrever padrões de eventos complexos que só são acionados sob condições muito específicas. Por exemplo, é possível criar um padrão de evento que corresponda a um evento quando:
+ Um campo do evento está dentro de um intervalo numérico específico.
+ O evento vem de um endereço IP específico.
+ Não existe um campo específico no JSON do evento.
Para obter mais informações, consulte [Operadores de comparação](eb-create-pattern-operators.md).
## Considerações ao criar padrões de eventos
A seguir, algumas considerações ao criar seus padrões de eventos:
+ EventBridge ignora os campos do evento que não estão incluídos no padrão do evento. O efeito é que há um curinga `"*": "*"` para campos que não aparecem no padrão do evento.
+ Os valores de correspondência nos padrões de evento seguem regras JSON. Você pode incluir strings entre aspas (“), números e as palavras-chave `true`, `false` e `null`.
+ Para strings, EventBridge usa a character-by-character correspondência exata sem dobrar maiúsculas e minúsculas ou qualquer outra normalização de string.
+ Para números, EventBridge usa representação de string. Por exemplo, 300, 300.0 e 3.0e2 não são considerados iguais.
+ Se vários padrões forem especificados para o mesmo campo JSON, usará EventBridge somente o último.
+ Lembre-se de que, ao EventBridge compilar padrões de eventos para uso, ele usa ponto (.) como caractere de junção.
Isso significa que EventBridge tratará os seguintes padrões de eventos como idênticos:
```
## has no dots in keys
{ "detail" : { "state": { "status": [ "running" ] } } }
## has dots in keys
{ "detail" : { "state.status": [ "running" ] } }
```
E que os dois padrões de eventos corresponderão aos dois seguintes eventos:
```
## has no dots in keys
{ "detail" : { "state": { "status": "running" } } }
## has dots in keys
{ "detail" : { "state.status": "running" } }
```
**nota**
Isso descreve EventBridge o comportamento atual e não se deve confiar que não mude.
+ Os padrões de eventos contendo campos duplicados são inválidos. Se um padrão contiver campos duplicados, considerará EventBridge apenas o valor final do campo.
Por exemplo, os seguintes padrões de eventos corresponderão ao mesmo 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"] }
}
```
E EventBridge trata os dois eventos a seguir 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**
Isso descreve EventBridge o comportamento atual e não se deve confiar que não mude.
# Fazer a correspondência de eventos com valores de campo de eventos
É possível usar todos os tipos e valores de dados JSON para combinar eventos. Os exemplos a seguir mostram eventos e os padrões de eventos que correspondem a eles.
## Correspondência de campos
É possível combinar o valor de um campo. Considere o seguinte evento do 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 o evento anterior, é possível usar o campo `"responseElements"` para corresponder.
```
{
"source": ["aws.autoscaling"],
"detail-type": ["EC2 Instance Launch Successful"],
"detail": {
"responseElements": [null]
}
}
```
## Valor para corresponder
Considere o evento do Amazon Macie, que está truncado, a seguir.
```
{
"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,
.
.
.
```
O padrão de evento a seguir corresponde a qualquer evento que tenha uma pontuação de gravidade de 1 e uma contagem de 2.
```
{
"source": ["aws.macie"],
"detail-type": ["Macie Finding"],
"detail": {
"severity": {
"score": [1]
},
"count":[2]
}
}
```
# Eventos correspondentes em valores nulos e strings vazias na Amazon EventBridge
**Importante**
Em EventBridge, é possível criar regras que podem gerar higher-than-expected cobranças e estrangulamentos. Por exemplo, é possível criar, por engano, uma regra que leva a um loop infinito, em que uma regra é acionada recursivamente sem fim. Suponha que você ACLs tenha criado uma regra para detectar as alterações em um bucket do Amazon S3 e acionar o software para alterá-las para o estado desejado. Se a regra não for escrita com cuidado, a alteração subsequente na ACLs acionará a regra novamente, criando um loop infinito.
Para obter orientação sobre como escrever regras precisas e padrões de eventos para minimizar esses resultados inesperados, consulte [Práticas recomendadas para regras](eb-rules-best-practices.md) e [Práticas recomendadas](eb-patterns-best-practices.md).
Também é possível criar um [padrão de evento](eb-event-patterns.md) que corresponde a um [evento](eb-events.md) de campo que tem um valor nulo ou uma string vazia. Considere o exemplo de evento a seguir:
Veja as práticas recomendadas para evitar cobranças e controle de utilização acima do 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 corresponder eventos onde o valor de `eventVersion` é uma string vazia, use o padrão a seguir, que corresponderia com o exemplo de evento.
```
{
"detail": {
"eventVersion": [""]
}
}
```
Para corresponder eventos onde o valor de `responseElements` é nulo, use o padrão a seguir, que corresponderia com o exemplo de evento.
```
{
"detail": {
"responseElements": [null]
}
}
```
**nota**
Valores Null e Strings vazias não são permutáveis em correspondência padrão. Um padrão de evento que corresponde a strings vazias não corresponde aos valores de `null`.
## Usando valores nulos em modelos AWS CloudFormation
AWS CloudFormation não permite `null` valores em modelos. Se você definir um padrão de evento com um valor nulo usando a sintaxe de objeto YAML ou JSON, a validação do modelo falhará com o erro:. `'null' values are not allowed in templates`
Para contornar essa limitação, especifique a `EventPattern` propriedade como uma string JSON em vez de um objeto YAML ou JSON. O exemplo a seguir mostra como combinar valores nulos em um AWS CloudFormation modelo:
```
MyRule:
Type: AWS::Events::Rule
Properties:
EventPattern: '{"detail":{"responseElements":[null]}}'
```
# Fazer a correspondência com vários valores de um campo de evento no Amazon EventBridge
O valor de cada campo em um [padrão de evento](eb-event-patterns.md) é uma matriz contendo um ou mais valores. Um padrão de evento corresponde ao [evento](eb-events.md) se algum dos valores na matriz corresponder ao valor no evento. Se o valor no evento for uma matriz, o padrão do evento será correspondente se a interseção da matriz do padrão do evento e da matriz do evento for não vazia.
**Importante**
No EventBridge, é possível criar regras que possam resultar em cobranças e controle de utilização mais altos do que o esperado. Por exemplo, é possível criar, por engano, uma regra que leva a um loop infinito, em que uma regra é acionada recursivamente sem fim. Supõe-se que uma regra possa detectar que as ACLs foram alteradas em um bucket do Amazon S3 e acionar o software para alterá-las para o estado desejado. Se a regra não for gravada cuidadosamente, a alteração subsequente às ACLs disparará a regra novamente, criando um loop infinito.
Para obter orientação sobre como escrever regras precisas e padrões de eventos para minimizar esses resultados inesperados, consulte [Práticas recomendadas para regras](eb-rules-best-practices.md) e [Práticas recomendadas](eb-patterns-best-practices.md).
Por exemplo, considere um padrão de evento que inclui o seguinte 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",
]
```
O padrão de exemplo anterior corresponderia a um evento que inclui o campo a seguir porque o primeiro item na matriz de padrão do evento corresponde ao segundo item na matriz de evento.
```
"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 comparação para uso em padrões de eventos na Amazon EventBridge
Abaixo, um resumo de todos os operadores de comparação disponíveis em EventBridge.
Os operadores de comparação só funcionam em nós folha, com exceção de `$or` e `anything-but`.
| **Comparação** | **Exemplo** | **Sintaxe da regra** | **Compatível com barramento de eventos** | **Compatível com pipe** |
| --- | --- | --- | --- | --- |
| E | Local é “Nova York” e o dia é “Segunda-feira” | `"Location": [ "New York" ], "Day": ["Monday"]` | Sim | Sim |
| [Tudo, exceto](#eb-filtering-anything-but) | Estado é qualquer valor além de “inicializar”. | `"state": [ { "anything-but": "initializing" } ]` | Sim | Sim |
| [Tudo, exceto (começa com)](#eb-filtering-anything-but-prefix) | A região não é nos EUA. | `"Region": [ { "anything-but": {"prefix": "us-" } } ]` | Sim | Não |
| [Tudo, exceto (termina com)](#eb-filtering-anything-but-suffix) | FileName não termina com uma extensão.png. | `"FileName": [ { "anything-but": { "suffix": ".png" } } ]` | Sim | Não |
| [Tudo, exceto (ignorar maiúsculas e minúsculas)](#eb-filtering-anything-but-ignore-case) | Estado é qualquer valor além de “inicializar” ou qualquer outra variação de maiúsculas e minúsculas, como “INICIALIZAR”. | `"state": : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}` | Sim | Não |
| [Tudo, exceto usando um curinga](#eb-filtering-anything-but-wildcard) | FileName não é um caminho de arquivo que inclua`/lib/`. | `"FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]` | Sim | Não |
| [Começa com](#eb-filtering-prefix-matching) | A região é nos EUA. | `"Region": [ {"prefix": "us-" } ]` | Sim | Sim |
| Começa com (ignorar maiúsculas e minúsculas) | O nome do serviço começa com as letras “eventb”, sem diferenciar maiúsculas e minúsculas. | `{"service" : [{ "prefix": { "equals-ignore-case": "eventb" }}]}` | Sim | Sim |
| [Vazio](eb-event-patterns-null-values.md) | LastName está vazio. | `"LastName": [""]` | Sim | Sim |
| Igual | Name é “Alice” | `"Name": [ "Alice" ]` | Sim | Sim |
| [É igual a (ignorar maiúsculas e minúsculas)](#eb-filtering-equals-ignore-case-matching) | Name é “Alice” | `"Name": [ { "equals-ignore-case": "alice" } ]` | Sim | Sim |
| [Termina com](#eb-filtering-suffix-matching) | FileName termina com uma extensão.png | `"FileName": [ { "suffix": ".png" } ]` | Sim | Sim |
| Termina com (ignorar maiúsculas e minúsculas) | O nome do serviço termina com as letras “tbridge” ou qualquer outra variação de maiúsculas e minúsculas, como “TBRIDGE”. | `{"service" : [{ "suffix": { "equals-ignore-case": "tBridge" }}]}` | Sim | Sim |
| [Existe](#eb-filtering-exists-matching) | ProductName existe | `"ProductName": [ { "exists": true } ]` | Sim | Sim |
| [Não existe](#eb-filtering-exists-matching) | ProductName não existe | `"ProductName": [ { "exists": false } ]` | Sim | Sim |
| [Não](#eb-filtering-anything-but) | Weather é qualquer valor, exceto “Raining” (Chovendo) | `"Weather": [ { "anything-but": [ "Raining" ] } ]` | Sim | Sim |
| [Nulo](eb-event-patterns-null-values.md) | UserID é null | `"UserID": [ null ]` | Sim | Sim |
| [Numérico (é iguais a)](#filtering-numeric-matching) | Price é 100 | `"Price": [ { "numeric": [ "=", 100 ] } ]` | Sim | Sim |
| [Numérico (intervalo)](#filtering-numeric-matching) | Price é superior a 10 e menor que ou igual a 20 | `"Price": [ { "numeric": [ ">", 10, "<=", 20 ] } ]` | Sim | Sim |
| Ou | PaymentType é “Crédito” ou “Débito” | `"PaymentType": [ "Credit", "Debit"]` | Sim | Sim |
| [Ou (vários campos)](#eb-filtering-complex-example-or) | Location é “New York” ou Day é “Monday”. | `"$or": [ { "Location": [ "New York" ] }, { "Day": [ "Monday" ] } ]` | Sim | Sim |
| [Curinga](#eb-filtering-wildcard-matching) | Qualquer arquivo com extensão .png, localizado na pasta "dir" | `"FileName": [ { "wildcard": "dir/*.png" } ] ` | Sim | Não |
## Correspondência de prefixo
É possível fazer uma correspondência de um evento com um valor na origem do evento no prefixo. É possível usar a correspondência de prefixos para valores de string.
Por exemplo, haveria correspondência do padrão de evento a seguir em qualquer evento em que o campo `"time"` começasse com `"2017-10-02"`, como `"time": "2017-10-02T18:43:48Z"`.
```
{
"time": [ { "prefix": "2017-10-02" } ]
}
```
### Correspondência de prefixo ignorando maiúsculas e minúsculas
Você também pode fazer a correspondência com um valor de prefixo, sem diferenciar maiúsculas e minúsculas dos caracteres que iniciam um valor, usando `equals-ignore-case` com `prefix.`
Por exemplo, haveria correspondência do padrão de eventos a seguir com qualquer evento em que o campo `service` começasse com a string de caracteres `EventB`, mas também `EVENTB`, `eventb` ou qualquer combinação de maiúsculas e minúsculas desses caracteres.
```
{
"detail": {"service" : [{ "prefix": { "equals-ignore-case": "EventB" }}]}
}
```
## Correspondência de sufixo
É possível combinar um evento dependendo do sufixo de um valor na origem do evento. É possível usar a correspondência de sufixos para valores de string.
Por exemplo, haveria correspondência do padrão de evento a seguir em qualquer evento em que o campo `"FileName"` terminasse com a extensão de arquivo `.png`.
```
{
"FileName": [ { "suffix": ".png" } ]
}
```
### Correspondência de sufixo ignorando maiúsculas e minúsculas
Você também pode fazer a correspondência com um valor de sufixo, sem diferenciar maiúsculas e minúsculas dos caracteres que terminam com um valor, usando `equals-ignore-case` com `suffix.`
Por exemplo, haveria correspondência do padrão de eventos a seguir com qualquer evento em que o campo `FileName` começasse com a string de caracteres `.png`, mas também `.PNG` ou qualquer outra combinação de maiúsculas e minúsculas desses caracteres.
```
{
"detail": {"FileName" : [{ "suffix": { "equals-ignore-case": ".png" }}]}
}
```
## Correspondência anything-but
A correspondência *tudo, exceto* faz a correspondência com qualquer valor, exceto o que for especificado na regra.
É possível excluir correspondências com strings e valores numéricos, incluindo listas que contenham somente strings ou números.
O evento a seguir mostra tudo menos uma correspondência com uma lista de strings e números.
```
{
"detail": {
"state": [ { "anything-but": "initializing" } ]
}
}
{
"detail": {
"x-limit": [ { "anything-but": 123 } ]
}
}
```
O evento a seguir mostra tudo menos uma correspondência com uma lista de strings.
```
{
"detail": {
"state": [ { "anything-but": [ "stopped", "overloaded" ] } ]
}
}
```
O evento a seguir mostra tudo menos uma correspondência com uma lista de números.
```
{
"detail": {
"x-limit": [ { "anything-but": [ 100, 200, 300 ] } ]
}
}
```
### Correspondência “tudo, exceto” ignorando maiúsculas e minúsculas
Você também pode usar `equals-ignore-case` com `anything-but` para fazer a correspondência com valores de string sem diferenciar maiúsculas e minúsculas.
O padrão de eventos a seguir faz a correspondência com os campos `state` que não contêm a string “inicializar”, “INICIALIZAR”, “Inicializar” ou qualquer outra combinação de maiúsculas e minúsculas desses caracteres.
```
{
"detail": {"state" : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}
}
```
Você também pode usar `equals-ignore-case` com `anything-but` para fazer a correspondência com uma lista de valores:
```
{
"detail": {"state" : [{ "anything-but": { "equals-ignore-case": ["initializing", "stopped"] }}]}
}
```
### Correspondência “tudo, exceto” em prefixos
Você pode usar `prefix` com `anything-but` para fazer a correspondência com valores de string que não iniciam com o valor especificado. Isso inclui valores únicos ou uma lista de valores.
O padrão de eventos a seguir mostra a correspondência “tudo, exceto” que faz a correspondência com qualquer evento que não tenha o prefixo `"init"` no campo `"state"`.
```
{
"detail": {
"state": [ { "anything-but": { "prefix": "init" } } ]
}
}
```
O padrão de eventos a seguir mostra a correspondência “tudo, exceto” com uma lista de valores de prefixos. Esse padrão de eventos faz a correspondência com qualquer evento que não tenha os prefixos `"init"` ou `"stop"` no campo `"state"`.
```
{
"detail": {
"state" : [{ "anything-but": { "prefix": ["init", "stop"] } } ] }
}
}
```
### Correspondência “tudo, exceto” em sufixos
Você pode usar `suffix` com `anything-but` para fazer a correspondência com valores de string que não terminam com o valor especificado. Isso inclui valores únicos ou uma lista de valores.
O padrão de eventos a seguir faz a correspondência com a qualquer valor do campo `FileName` que não termina com `.txt`.
```
{
"detail": {
"FileName": [ { "anything-but": { "suffix": ".txt" } } ]
}
}
```
O padrão de eventos a seguir mostra a correspondência “tudo, exceto” com uma lista de valores de sufixos. Este padrão de eventos faz a correspondência com qualquer valor do campo `FileName` que não termina com `.txt` ou `.rtf`.
```
{
"detail": {
"FileName": [ { "anything-but": { "suffix": [".txt", ".rtf"] } } ]
}
}
```
### Correspondência “tudo, exceto” usando curingas
É possível usar o caractere curinga (\$1) dentro dos valores que você especificar para a correspondência “tudo, exceto”. Isso inclui valores únicos ou uma lista de valores.
O padrão de eventos a seguir faz a correspondência com qualquer valor do campo `FileName` que não contém `/lib/`.
```
{
"detail": {
"FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]
}
}
```
O padrão de eventos a seguir mostra a correspondência “tudo, exceto” com uma lista de valores que inclui curingas. Este padrão de eventos faz a correspondência com qualquer valor do campo `FileName` que não contém `/lib/` ou `/bin/`.
```
{
"detail": {
"FilePath" : [{ "anything-but": { "wildcard": ["*/lib/*", "*/bin/*"] }}]
}
}
```
Para obter mais informações, consulte [Como corresponder usando curingas](#eb-filtering-wildcard-matching).
## Correspondência numérica
A correspondência numérica funciona com valores que são números JSON. Está limitada a valores entre -5.0e9 e \$15.0e9 inclusive, com 15 dígitos de precisão ou seis dígitos à direita do ponto decimal.
O exemplo a seguir mostra a correspondência numérica para um padrão de evento que corresponde somente aos eventos que são verdadeiros para todos os campos.
```
{
"detail": {
"c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ],
"d-count": [ { "numeric": [ "<", 10 ] } ],
"x-limit": [ { "numeric": [ "=", 3.018e2 ] } ]
}
}
```
## Correspondência de endereço IP
Você pode usar a correspondência de endereços IP para IPv4 e IPv6 endereços. O padrão de eventos a seguir mostra o endereço IP correspondente aos endereços IP que começam com 10.0.0 e terminam com um número entre 0 e 255.
```
{
"detail": {
"sourceIPAddress": [ { "cidr": "10.0.0.0/24" } ]
}
}
```
## Existe correspondência
A *correspondência existe* funciona na presença ou ausência de um campo no JSON do evento.
A correspondência “existe” funciona somente em nós folha. Ela não funciona em nós intermediários.
O padrão de evento a seguir corresponde a qualquer evento que tenha um campo `detail.state`.
```
{
"detail": {
"state": [ { "exists": true } ]
}
}
```
Os padrões de evento anterior seriam correspondentes ao evento de exemplo a seguir.
```
{
"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"
}
}
```
O padrão do evento anterior NÃO corresponde ao evento seguinte porque não tem um 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 combinando
*A quals-ignore-case correspondência E* funciona em valores de string, independentemente do caso.
O padrão de evento a seguir corresponde a qualquer evento que tenha um campo `detail-type` que corresponda à string especificada, independentemente do caso.
```
{
"detail-type": [ { "equals-ignore-case": "ec2 instance state-change notification" } ]
}
```
Os padrões de evento anterior seriam correspondentes ao evento de exemplo a seguir.
```
{
"detail-type": [ "EC2 Instance State-change Notification" ],
"resources": [ "arn:aws:ec2:us-east-1:123456789012:instance/i-02ebd4584a2ebd341" ],
"detail": {
"c-count" : {
"c1" : 100
}
}
}
```
## Como corresponder usando curingas
É possível usar o caractere curinga (\$1) para encontrar o valor correspondente a valores de string em padrões de eventos.
**nota**
No momento, o caractere curinga é compatível somente com as regras do barramento de eventos.
Considerações ao usar curingas em seus padrões de eventos:
+ É possível especificar qualquer número de caracteres curinga em um determinado valor de cadeia de caracteres; no entanto, caracteres curinga consecutivos não são compatíveis.
+ EventBridge suporta o uso do caractere de barra invertida (\$1) para especificar os caracteres literais \$1 e\$1 em filtros curinga:
+ A string `\*` representa o caractere literal \$1
+ A string `\\` representa o caractere literal \$1
Não há compatibilidade para usar a barra invertida no escape de outros caracteres.
### Curingas e complexidade do padrão de eventos
Há um limite para a complexidade de uma regra que usa curingas. Se uma regra for muito complexa, EventBridge retornará um `InvalidEventPatternException` ao tentar criar a regra. Se sua regra gerar esse erro, considere usar a orientação abaixo para reduzir a complexidade do padrão do evento:
+ **Reduza o número de caracteres curinga usados**
Use somente caracteres curinga quando realmente precisar comparar com vários valores possíveis. Por exemplo, considere o seguinte padrão de eventos, em que deseja comparar com os barramentos de eventos na mesma região:
```
{
"EventBusArn": [ { "wildcard": "*:*:*:*:*:event-bus/*" } ]
}
```
No caso acima, muitas das seções do ARN serão baseadas diretamente na região em que seus barramentos de eventos residem. Portanto, se estiver usando a região `us-east-1`, um padrão menos complexo que ainda corresponda aos valores desejados pode ser o seguinte exemplo:
```
{
"EventBusArn": [ { "wildcard": "arn:aws:events:us-east-1:*:event-bus/*" } ]
}
```
+ **Reduza as sequências de caracteres repetidas que ocorrem após um caractere curinga**
Ter a mesma sequência de caracteres aparecendo várias vezes após o uso de um curinga aumenta a complexidade do processamento do padrão do evento. Reformule seu padrão de eventos para minimizar sequências repetidas. Por exemplo, considere o seguinte exemplo, que corresponde ao arquivo de nome `doc.txt` de arquivo de qualquer usuário:
```
{
"FileName": [ { "wildcard": "/Users/*/dir/dir/dir/dir/dir/doc.txt" } ]
}
```
Se soubesse que o arquivo `doc.txt` só ocorreria no caminho especificado, poderia reduzir a sequência de caracteres repetidos desta forma:
```
{
"FileName": [ { "wildcard": "/Users/*/doc.txt" } ]
}
```
## Exemplo complexo com correspondência múltipla
Você pode combinar vários critérios de correspondência em um padrão de eventos mais complexo. Por exemplo, o padrão de evento a seguir combina `anything-but` e `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**
Ao criar padrões de eventos, se incluir uma chave mais de uma vez, a última referência será aquela usada para avaliar eventos. Por exemplo, para o seguinte padrão:
```
{
"detail": {
"location": [ { "prefix": "us-" } ],
"location": [ { "anything-but": "us-east" } ]
}
}
```
somente `{ "anything-but": "us-east" }` serão levados em consideração ao avaliar a `location`.
## Exemplo complexo com correspondências de `$or`
Também é possível criar padrões de eventos complexos que verificam se os valores de *algum* campo coincidem em vários campos. Use `$or` para criar um padrão de evento que corresponda se algum dos valores de vários campos for correspondido.
Observe que pode incluir outros tipos de filtro, como [correspondência numérica](#filtering-numeric-matching) e [matrizes](eb-event-patterns-arrays.md), na correspondência de padrões para campos individuais em sua estrutura `$or`.
O seguinte padrão de evento corresponderá se alguma das condições a seguir for atendida:
+ O campo `c-count` é maior que 0 ou menor que ou igual a 5.
+ O campo `d-count` é inferior a 10.
+ O campo `x-limit` é igual a 3.018e2.
```
{
"detail": {
"$or": [
{ "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ] },
{ "d-count": [ { "numeric": [ "<", 10 ] } ] },
{ "x-limit": [ { "numeric": [ "=", 3.018e2 ] } ] }
]
}
}
```
**nota**
APIs que aceitam um padrão de evento (como`PutRule`, `CreateArchive``UpdateArchive`, e`TestEventPattern`) gerarão um `InvalidEventPatternException` if o uso de `$or` resultados em mais de 1000 combinações de regras.
Para determinar o número de combinações de regras em um padrão de evento, multiplique o número total de argumentos de cada matriz `$or` no padrão de evento. Por exemplo, o padrão acima contém uma única matriz `$or` com três argumentos, então o número total de combinações de regras também é três. Se adicionasse outra matriz `$or` com dois argumentos, o total de combinações de regras seria então seis.
# Melhores práticas para padrões de EventBridge eventos da Amazon
Abaixo estão algumas das práticas recomendadas a serem consideradas ao definir padrões de eventos em suas regras de barramento de eventos.
## Evite escrever loops infinitos
Em EventBridge, é possível criar regras que levam a loops infinitos, onde uma regra é acionada repetidamente. Por exemplo, uma regra pode detectar que ACLs foram alteradas em um bucket do S3 e acionar o software para alterá-las para o estado desejado. Se a regra não for escrita com cuidado, a alteração subsequente na ACLs acionará a regra novamente, criando um loop infinito.
Para evitar esses problemas, escreva os padrões de eventos para que suas regras sejam o mais precisas possível, para que correspondam apenas aos eventos que você realmente deseja enviar ao destino. No exemplo acima, seria criado um padrão de evento para corresponder aos eventos para que as ações acionadas não disparassem novamente a mesma regra. Por exemplo, crie um padrão de evento em sua regra que corresponda aos eventos somente se ACLs eles estiverem em um estado ruim, em vez de após qualquer alteração. Para obter mais informações, consulte [Tornar os padrões de eventos o mais precisos possível](#eb-patterns-best-practices-precision) e [Defina seus padrões de eventos para considerar as atualizações da origem de eventos](#eb-patterns-best-practices-future-proof).
Um loop infinito pode rapidamente causar cobranças acima do esperado. Isto também pode levar ao controle de utilização e atraso na entrega do evento. É possível monitorar o limite superior de suas taxas de invocação para receber avisos sobre picos inesperados no volume.
Use o orçamento para alertar você quando as cobranças excederem o limite especificado. Para obter mais informações, consulte [Gerenciamento de seus custos com orçamentos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/budgets-managing-costs.html).
## Tornar os padrões de eventos o mais precisos possível
Quanto mais preciso for o padrão de eventos, maior será a probabilidade dele corresponder somente aos eventos que você realmente deseja e evitar correspondências inesperadas quando novos eventos forem adicionados a uma origem de eventos ou eventos existentes forem atualizados para incluir novas propriedades.
Os padrões de eventos podem incluir filtros que correspondem a:
+ Metadados do evento sobre o evento, como `source`, `detail-type`, `account` ou `region`.
+ Dados do evento, ou seja, os campos dentro do objeto `detail`.
+ Conteúdo do evento ou os valores reais dos campos dentro do objeto `detail`.
A maioria dos padrões é simples, como especificar somente filtros `source` e `detail-type`. No entanto, EventBridge os padrões incluem a flexibilidade de filtrar qualquer chave ou valor do evento. Além disso, é possível aplicar filtros de conteúdo, como filtros `prefix` e `suffix`, para melhorar a precisão de seus padrões. Para obter mais informações, consulte [Usando operadores de comparação nos padrões de EventBridge eventos da Amazon](eb-create-pattern.md#eb-event-patterns-content-based-filtering).
### Especifique a origem do evento e o tipo de detalhe como filtros
É possível reduzir a geração de loops infinitos e a correspondência de eventos indesejados tornando seus padrões de eventos mais precisos usando os campos de metadados `source` e `detail-type`.
Quando precisar combinar valores específicos em dois ou mais campos, use o operador de comparação `$or`, em vez de listar todos os valores possíveis em uma única matriz de valores.
Para eventos entregues por meio de AWS CloudTrail, recomendamos que você use o `eventName` campo como filtro.
O exemplo de padrão de evento a seguir corresponde a `CreateQueue` ou `SetQueueAttributes` do serviço Amazon Simple Queue Service `CreateKey` ou a `DisableKeyRotation` eventos do AWS Key Management Service serviço.
```
{
"detail-type": ["AWS API Call via CloudTrail"],
"$or": [{
"source": [
"aws.sqs"
],
"detail": {
"eventName": [
"CreateQueue",
"SetQueueAttributes"
]
}
},
{
"source": [
"aws.kms"
],
"detail": {
"eventName": [
"CreateKey",
"DisableKeyRotation"
]
}
}
]
}
```
### Especifique conta e região como filtros
Incluir os campos `account` e `region` em seu padrão de eventos ajuda a limitar a correspondência de eventos entre contas ou regiões.
### Especifique filtros de conteúdo
A filtragem baseada em conteúdo pode ajudar a melhorar a precisão do padrão de eventos ao mesmo tempo em que mantém a duração do padrão de eventos no mínimo. Por exemplo, a correspondência com base em um intervalo numérico pode ser útil em vez de listar todos os valores numéricos possíveis.
Para obter mais informações, consulte [Usando operadores de comparação nos padrões de EventBridge eventos da Amazon](eb-create-pattern.md#eb-event-patterns-content-based-filtering).
## Defina seus padrões de eventos para considerar as atualizações da origem de eventos
Ao criar padrões de eventos, é necessário levar em consideração que os esquemas e domínios de eventos podem evoluir e se expandir com o tempo. Aqui, novamente, tornar seus padrões de eventos o mais precisos possível ajuda a limitar correspondências inesperadas se a origem do evento mudar ou se expandir.
Por exemplo, suponha que você esteja comparando eventos de um novo microsserviço que publica eventos relacionados a pagamentos. Inicialmente, o serviço usa o domínio `acme.payments` e publica um único evento, `Payment accepted`:
```
{
"detail-type": "Payment accepted",
"source": "acme.payments",
"detail": {
"type": "credit",
"amount": "100",
"date": "2023-06-10",
"currency": "USD"
}
}
}
```
Nesse momento, é possível criar um padrão de evento simples que corresponda aos eventos aceitos por pagamento:
```
{ “source” : “acme.payments” }
```
No entanto, suponha que o serviço introduza posteriormente um novo evento para pagamentos rejeitados:
```
{
"detail-type": "Payment rejected",
"source": "acme.payments",
"detail": {
}
}
```
Nesse caso, o padrão de evento simples que você criou agora corresponderá aos `Payment rejected` eventos `Payment accepted` e. EventBridge direciona os dois tipos de eventos para o destino especificado para processamento, possivelmente introduzindo falhas de processamento e custos adicionais de processamento.
Para definir o escopo do seu padrão de eventos somente `Payment accepted` para eventos, é preciso especificar tanto `source` como `detail-type`, no mínimo:
```
{
"detail-type": "Payment accepted",
"source": "acme.payments"
}
}
```
Também é possível especificar conta e região em seu padrão de eventos, para limitar ainda mais quando eventos entre contas ou regiões correspondem a essa regra.
```
{
"account": "012345678910",
"source": "acme.payments",
"region": "AWS-Region",
"detail-type": "Payment accepted"
}
```
## Validar padrões de eventos
Para garantir que as regras correspondam aos eventos desejados, é altamente recomendável que você valide seus padrões de eventos. Você pode validar seus padrões de eventos usando o EventBridge console ou a API:
+ No EventBridge console, você pode criar e testar padrões de eventos [como parte da criação de uma regra](eb-create-rule-visual.md) ou separadamente [usando o Sandbox](eb-event-pattern-sandbox.md).
+ Você pode testar seus padrões de eventos AWS CLI usando o [test-event-pattern](https://docs.aws.amazon.com/cli/latest/reference/events/test-event-pattern.html)comando.