EventBridge:Event patterns

Operadores suportados

A tabela a seguir resume todos os operadores de padrão. Cada operador é encapsulado em um array como valor do campo.

Como funciona a correspondência

O EventBridge avalia padrões usando dois operadores lógicos:

• AND entre chaves: Todas as chaves no padrão devem corresponder. Se um padrão especificar tanto source quanto type, o evento deve corresponder a ambos.

• OR entre valores em um array: O valor de cada chave é um array. Se o array contiver múltiplos valores, o evento corresponderá se qualquer um dos valores for compatível.

Regras adicionais de correspondência:

• O evento deve conter todos os campos especificados no padrão. Campos extras no evento são ignorados.

• A correspondência é caractere por caractere e diferencia maiúsculas de minúsculas. O EventBridge não modifica strings durante a avaliação.

• Todos os valores devem ser JSON válido: strings entre aspas duplas (""), palavras-chave sem aspas (true, false, null) ou valores numéricos.

Correspondência de valor exato

Faça a correspondência de eventos em que um campo seja igual a um valor específico. Encapsule o valor em um array.

O padrão a seguir corresponde a eventos onde source é acs.oss:

{
    "source": [
        "acs.oss"
    ]
}

Evento de exemplo (correspondido):

{
    "id": "7adc8c1a-645d-4476-bdef-5d6fb57f****",
    "source": "acs.oss",
    "specversion": "1.0",
    "type": "oss:ObjectCreated:PostObject",
    "datacontenttype": "application/json",
    "dataschema": "http://example.com/test.json",
    "subject": "acs:oss:cn-hangzhou:1234567:xls-papk/game_apk/123.jpg",
    "time": "2020-08-17T16:04:46.149Asia/Shanghai",
    "data": {
        "name": "test",
        "scope": 100
    }
}

Correspondência por prefixo

Identifique eventos cujo valor de campo comece com uma string especificada. Utilize o operador prefix.

O padrão abaixo corresponde a eventos onde source começa com acs.:

{
    "source": [
        {
            "prefix": "acs."
        }
    ]
}

Correspondência por sufixo

Selecione eventos em que o valor de um campo termine com uma string definida. Aplique o operador suffix.

O seguinte padrão combina condições de prefixo e sufixo. Um evento corresponde se o valor de subject começar com o prefixo especificado, OU terminar com .txt, OU terminar com .jpg:

{
    "subject": [
        {
            "prefix": "acs:oss:cn-hangzhou:1234567:xls-papk/"
        },
        {
            "suffix": ".txt"
        },
        {
            "suffix": ".jpg"
        }
    ]
}

Múltiplos valores no mesmo array são avaliados com lógica OR. Um evento corresponde se qualquer condição individual no array for satisfeita.

Correspondência por conteúdo (contains)

Encontre eventos onde o valor de um campo inclua uma substring especificada. Empregue o operador contains.

Substring única

Este padrão corresponde a eventos onde type contém Normal:

{
    "type": [
        {
            "contains": "Normal"
        }
    ]
}

Um evento com "type": "UserNormalEvent" corresponde. Já um evento com "type": "UserErrorEvent" não corresponde.

Múltiplas substrings (OR)

O padrão a seguir identifica eventos onde type contém Normal ou Error:

{
    "type": [
        {
            "contains": "Normal"
        },
        {
            "contains": "Error"
        }
    ]
}

Um evento com "type": "UserNormalEvent" corresponde. Um evento com "type": "UserErrorEvent" também corresponde. Por outro lado, um evento com "type": "UserOtherEvent" não apresenta correspondência.

Correspondência por exclusão (anything-but)

Filtre eventos onde o valor de um campo NÃO seja igual aos valores especificados. O operador anything-but suporta strings, números, arrays e exclusões baseadas em prefixo.

{
    "data": {
        "state": [
            {
                "anything-but": "initializing"
            }
        ]
    }
}

{
    "data": {
        "x-limit": [
            {
                "anything-but": 123
            }
        ]
    }
}

{
    "data": {
        "state": [
            {
                "anything-but": [
                    "stopped",
                    "overloaded"
                ]
            }
        ]
    }
}

{
    "data": {
        "x-limit": [
            {
                "anything-but": [
                    100,
                    200,
                    300
                ]
            }
        ]
    }
}

{
    "data": {
        "state": [
            {
                "anything-but": {
                    "prefix": "init"
                }
            }
        ]
    }
}

{
    "source": [
        {
            "anything-but": [
                "acs.ecs"
            ]
        }
    ]
}

{
    "source": [
        {
            "anything-but": {
                "prefix": "acs."
            }
        }
    ]
}

Correspondência numérica

Corresponda eventos onde um campo numérico seja igual a um valor específico ou esteja dentro de um intervalo. Use o operador numeric com um ou mais operadores de comparação: =, >, <, <=. Especifique um intervalo combinando dois operadores.

O padrão a seguir corresponde a eventos onde:

• data.c-count é maior que 0 e menor ou igual a 5

• data.d-count é menor que 10

• data.x-limit é igual a 301,8

{
    "data": {
        "c-count": [
            {
                "numeric": [
                    ">",
                    0,
                    "<=",
                    5
                ]
            }
        ],
        "d-count": [
            {
                "numeric": [
                    "<",
                    10
                ]
            }
        ],
        "x-limit": [
            {
                "numeric": [
                    "=",
                    301.8
                ]
            }
        ]
    }
}

Correspondência de endereço IP

Selecione eventos onde um campo de endereço IP esteja dentro de um bloco CIDR. Utilize o operador cidr em um campo do objeto data. Apenas endereços IPv4 são suportados.

O padrão abaixo corresponde a eventos onde data.source-ip está na sub-rede 10.0.0.0/24:

{
    "data": {
        "source-ip": [
            {
                "cidr": "10.0.0.0/24"
            }
        ]
    }
}

Um evento com "source-ip": "10.0.0.123" corresponde. Um evento com "source-ip": "192.168.0.123" não corresponde.

Correspondência de null e string vazia

{
    "data": {
        "eventVersion": [
            ""
        ]
    }
}

{
    "data": {
        "responseElements": [
            null
        ]
    }
}

Correspondência por existência de campo

Filtre eventos com base na existência ou não de um campo no objeto data. Use o operador exists.

O padrão a seguir corresponde a eventos onde o campo data.state não existe:

{
    "data": {
        "state": [
            {
                "exists": false
            }
        ]
    }
}

Defina "exists": true para corresponder a eventos onde o campo existe.

Correspondência de array

Os valores do padrão são arrays. Quando um campo do evento também é um array, o EventBridge verifica se os dois arrays possuem elementos comuns (interseção de conjuntos). Se a interseção não for vazia, o evento corresponde.

O padrão abaixo corresponde a eventos onde subject é igual a um dos três valores especificados:

{
    "subject": [
        "acs:oss:cn-hangzhou:1234567:xls-papk/game_apk/123.jpg",
        "acs:oss:cn-hangzhou:1112223:xls-papk/game_apk/123.jpg",
        "acs:oss:cn-hangzhou:4455667:xls-papk/game_apk/123.jpg"
    ]
}

Se o subject do evento for uma string única correspondente a qualquer um dos três valores, o evento corresponde. Caso o subject do evento seja um array, a correspondência ocorre quando pelo menos um elemento se sobrepõe ao array do padrão.

Condições combinadas

Combine múltiplos operadores em um único padrão para criar filtros precisos. O EventBridge aplica lógica AND em todas as chaves.

O padrão a seguir combina correspondências de prefixo, exclusão, CIDR e numéricas:

{
    "source": [
        {
            "prefix": "acs."
        }
    ],
    "data": {
        "state": [
            {
                "anything-but": "initializing"
            }
        ],
        "source-ip": [
            {
                "cidr": "10.0.0.0/24"
            }
        ],
        "c-count": [
            {
                "numeric": [
                    ">",
                    0,
                    "<=",
                    5
                ]
            }
        ],
        "d-count": [
            {
                "numeric": [
                    "<",
                    10
                ]
            }
        ],
        "x-limit": [
            {
                "anything-but": [
                    100,
                    200,
                    300
                ]
            }
        ]
    }
}

Um evento corresponde apenas quando TODAS as condições a seguir forem verdadeiras:

• source começa com acs.

• data.state não é initializing

• data.source-ip está dentro de 10.0.0.0/24

• data.c-count é maior que 0 e no máximo 5

• data.d-count é menor que 10

• data.x-limit não é 100, 200 ou 300

Limites