EventBridge:Event patterns

Opérateurs pris en charge

Le tableau suivant résume tous les opérateurs de modèle. Chaque opérateur est encapsulé dans un tableau en tant que valeur du champ.

Fonctionnement de la mise en correspondance

EventBridge évalue les modèles à l'aide de deux opérateurs logiques :

• ET entre les clés : Toutes les clés du modèle doivent correspondre. Si un modèle spécifie à la fois source et type, l'événement doit correspondre aux deux.

• OU entre les valeurs d'un tableau : La valeur de chaque clé est un tableau. Si le tableau contient plusieurs valeurs, l'événement correspond si l'une des valeurs correspond.

Règles de correspondance supplémentaires :

• L'événement doit contenir tous les champs spécifiés dans le modèle. Les champs supplémentaires présents dans l'événement sont ignorés.

• La correspondance s'effectue caractère par caractère et respecte la casse. EventBridge ne modifie pas les chaînes lors de l'évaluation.

• Toutes les valeurs doivent être valides au format JSON : chaînes entre guillemets doubles (""), mots-clés non entre guillemets (true, false, null), ou valeurs numériques.

Correspondance de valeur exacte

Faites correspondre les événements où un champ est égal à une valeur spécifique. Encapsulez la valeur dans un tableau.

Le modèle suivant fait correspondre les événements dont la source est acs.oss :

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

Événement exemple (correspondance) :

{
    "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
    }
}

Correspondance par préfixe

Faites correspondre les événements dont la valeur d'un champ commence par une chaîne spécifiée. Utilisez l'opérateur prefix.

Le modèle suivant fait correspondre les événements dont la source commence par acs. :

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

Correspondance par suffixe

Faites correspondre les événements dont la valeur d'un champ se termine par une chaîne spécifiée. Utilisez l'opérateur suffix.

Le modèle suivant combine des conditions de préfixe et de suffixe. Un événement correspond si la valeur de subject commence par le préfixe spécifié, OU se termine par .txt, OU se termine par .jpg :

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

Plusieurs valeurs dans le même tableau sont évaluées avec une logique OU. Un événement correspond si une seule condition du tableau est satisfaite.

Correspondance par inclusion

Faites correspondre les événements dont la valeur d'un champ inclut une sous-chaîne spécifiée. Utilisez l'opérateur contains.

Sous-chaîne unique

Le modèle suivant fait correspondre les événements dont le type contient Normal :

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

Un événement avec "type": "UserNormalEvent" correspond. Un événement avec "type": "UserErrorEvent" ne correspond pas.

Plusieurs sous-chaînes (OU)

Le modèle suivant fait correspondre les événements dont le type contient Normal ou Error :

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

Un événement avec "type": "UserNormalEvent" correspond. Un événement avec "type": "UserErrorEvent" correspond également. Un événement avec "type": "UserOtherEvent" ne correspond pas.

Correspondance par exclusion (anything-but)

Faites correspondre les événements dont la valeur d'un champ n'est PAS égale aux valeurs spécifiées. L'opérateur anything-but prend en charge les chaînes, les nombres, les tableaux et les exclusions basées sur un préfixe.

{
    "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."
            }
        }
    ]
}

Correspondance numérique

Faites correspondre les événements dont un champ numérique est égal à une valeur spécifique ou se situe dans une plage. Utilisez l'opérateur numeric avec un ou plusieurs opérateurs de comparaison : =, >, <, <=. Spécifiez une plage en associant deux opérateurs.

Le modèle suivant fait correspondre les événements où :

• data.c-count est supérieur à 0 et inférieur ou égal à 5

• data.d-count est inférieur à 10

• data.x-limit est égal à 301,8

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

Correspondance d'adresse IP

Faites correspondre les événements dont un champ d'adresse IP se situe dans un bloc CIDR. Utilisez l'opérateur cidr sur un champ de l'objet data. Seules les adresses IPv4 sont prises en charge.

Le modèle suivant fait correspondre les événements dont data.source-ip se trouve dans le sous-réseau 10.0.0.0/24 :

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

Un événement avec "source-ip": "10.0.0.123" correspond. Un événement avec "source-ip": "192.168.0.123" ne correspond pas.

Correspondance de valeur nulle et de chaîne vide

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

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

Correspondance d'existence de champ

Faites correspondre les événements selon qu'un champ existe ou non dans l'objet data. Utilisez l'opérateur exists.

Le modèle suivant fait correspondre les événements où le champ data.state n'existe pas :

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

Définissez "exists": true pour faire correspondre les événements où le champ existe.

Correspondance de tableau

Les valeurs du modèle sont des tableaux. Lorsqu'un champ d'événement est également un tableau, EventBridge vérifie si les deux tableaux ont des éléments communs (intersection d'ensembles). Si l'intersection n'est pas vide, l'événement correspond.

Le modèle suivant fait correspondre les événements dont subject est égal à l'une des trois valeurs spécifiées :

{
    "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"
    ]
}

Si le subject de l'événement est une chaîne unique correspondant à l'une des trois valeurs, l'événement correspond. Si le subject de l'événement est un tableau, l'événement correspond lorsqu'au moins un élément chevauche le tableau du modèle.

Conditions combinées

Combinez plusieurs opérateurs dans un seul modèle pour créer des filtres précis. EventBridge applique une logique ET à toutes les clés.

Le modèle suivant combine la correspondance par préfixe, par exclusion, par CIDR et numérique :

{
    "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
                ]
            }
        ]
    }
}

Un événement correspond uniquement si TOUTES les conditions suivantes sont remplies :

• source commence par acs.

• data.state n'est pas initializing

• data.source-ip se situe dans 10.0.0.0/24

• data.c-count est supérieur à 0 et au maximum égal à 5

• data.d-count est inférieur à 10

• data.x-limit n'est ni 100, ni 200, ni 300

Limites