Transformation des EventBridge entrées Amazon - Amazon EventBridge
Variables prédéfiniesExemples de transformation d’entréeTransformation des entrées à l'aide de l' EventBridgeAPITransformation des données en utilisant AWS CloudFormationProblèmes courants liés à la transformation d’entrée

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Transformation des EventBridge entrées Amazon

Vous pouvez personnaliser le texte d'un événement avant de EventBridge transmettre les informations à la cible d'une règle. À l’aide du transformateur d’entrée de la console ou de l’API, vous définissez des variables qui utilisent le chemin JSON pour référencer les valeurs de la source d’événement d’origine. L’événement transformé est envoyé à une cible plutôt qu’à l’événement d’origine. Toutefois, les paramètres de chemin dynamiques doivent faire référence à l’événement d’origine, et non à l’événement transformé. Vous pouvez définir jusqu’à 100 variables, en attribuant à chacune une valeur à partir de l’entrée. Vous pouvez ensuite utiliser ces variables dans le modèle d'entrée au format <variable-name>.

Pour obtenir un didacticiel sur l’utilisation du transformateur d’entrée, consultez Didacticiel : Utilisation du transformateur d'entrée pour personnaliser les éléments qu'EventBridge transmet à la cible d'événement.

Note

EventBridge ne prend pas en charge toutes les syntaxes JSON Path et ne l'évalue pas lors de l'exécution. La syntaxe prise en charge inclut :

  • notation par points (par exemple, $.detail)

  • tirets

  • traits de soulignement

  • caractères alphanumériques

  • index de tableau

  • caractères génériques (*)

Dans cette rubrique :

Variables prédéfinies

Il existe des variables prédéfinies que vous pouvez utiliser sans définir de chemin JSON. Ces variables sont réservées et vous ne pouvez pas créer de variables avec ces noms :

  • aws.events.rule-arn— Le nom de ressource Amazon (ARN) de la EventBridge règle.

  • aws.events.rule-name— Le nom de la EventBridge règle.

  • aws.events.event.ingestion-time— L'heure à laquelle l'événement a été reçu par EventBridge. Il s’agit d’un horodatage ISO 8601. Cette variable est générée par EventBridge et ne peut pas être remplacée.

  • aws.events.event : la charge utile de l’événement d’origine au format JSON (sans le champ detail). Peut seulement être utilisée comme valeur pour un champ JSON, car son contenu n’est pas mis en échappement.

  • aws.events.event.json : la charge utile complète de l’événement d’origine au format JSON (avec le champ detail). Peut seulement être utilisée comme valeur pour un champ JSON, car son contenu n’est pas mis en échappement.

Exemples de transformation d’entrée

Voici un exemple d’événement Amazon EC2.


{
  "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-0123456789",
    "state": "RUNNING"
  }
}

Lorsque vous définissez une règle dans la console, sélectionnez l'option Transformateur d'entrée sous Configurer l'entrée. Cette option affiche deux zones de texte : une pour Chemin d'entrée et l'autre pour Modèle d'entrée.

Le chemin d’entrée est utilisé pour définir des variables. Utilisez le chemin JSON pour référencer des éléments dans votre événement et stocker ces valeurs dans des variables. Par exemple, vous pouvez créer un chemin d'entrée pour référencer des valeurs dans l'exemple d'événement en entrant les informations suivantes dans la première zone de texte. Vous pouvez également utiliser des crochets et des index pour obtenir des éléments à partir de tableaux.

Note

EventBridge remplace les transformateurs d'entrée lors de l'exécution pour garantir une sortie JSON valide. Pour cette raison, placez des guillemets autour des variables qui font référence aux paramètres de chemin JSON, mais ne placez pas de guillemets autour des variables qui font référence à des objets ou des tableaux JSON.

{
  "timestamp" : "$.time",
  "instance" : "$.detail.instance-id", 
  "state" : "$.detail.state",
  "resource" : "$.resources[0]"
}

Cela permet de définir quatre variables : <timestamp>, <instance>, <state> et <resource>. Vous pouvez référencer ces variables lors de la création de votre modèle d’entrée.

Le modèle d’entrée est un modèle pour les informations que vous souhaitez transmettre à votre cible. Vous pouvez créer un modèle qui transmet une chaîne ou un fichier JSON à la cible. À l'aide de l'événement précédent et du chemin d'entrée, les exemples de modèle d’entrée suivants transformeront l'événement en l’exemple de sortie suivant avant de l’acheminer vers une cible.

Description Modèle Sortie
Chaîne simple 
"instance <instance> is in <state>"
 
"instance i-0123456789 is in RUNNING"

Chaîne avec guillemets échappés

 
"instance \"<instance>\" is in <state>"
 
"instance \"i-0123456789\" is in RUNNING"

Notez qu'il s'agit du comportement de la EventBridge console. L’ AWS CLI échappe les caractères de barre oblique et le résultat est "instance "i-0123456789" is in RUNNING".

Fichier JSON simple

 
{
  "instance" : <instance>,
  "state": <state>
}
 
{
  "instance" : "i-0123456789",
  "state": "RUNNING"
}

Fichier JSON avec chaînes et variables

 
{
 "instance" : <instance>,
 "state": "<state>",
 "instanceStatus": "instance \"<instance>\" is in <state>"
}
 
{
 "instance" : "i-0123456789",
 "state": "RUNNING",
 "instanceStatus": "instance \"i-0123456789\" is in RUNNING"
}

Fichier JSON avec un mélange de variables et d'informations statiques

 
{
  "instance" : <instance>,
  "state": [ 9, <state>, true ],
  "Transformed" : "Yes"
}

{
  "instance" : "i-0123456789",
  "state": [
    9,
    "RUNNING",
    true
  ],
  "Transformed" : "Yes"
}

Inclut des variables réservées dans JSON

 
{
  "instance" : <instance>,
  "state": <state>,
  "ruleArn" : <aws.events.rule-arn>,
  "ruleName" : <aws.events.rule-name>,
  "originalEvent" : <aws.events.event.json>
}
 
{
  "instance" : "i-0123456789",
  "state": "RUNNING",
  "ruleArn" : "arn:aws:events:us-east-2:123456789012:rule/example",
  "ruleName" : "example",
  "originalEvent" : {
    ... // commented for brevity
  }
}

Inclut des variables réservées dans une chaîne

 
"<aws.events.rule-name> triggered"
 
"example triggered"

Groupe de CloudWatch journaux Amazon

 
{
  "timestamp" : <timestamp>,
  "message": "instance \"<instance>\" is in <state>"
}
 
{
  "timestamp" : 2015-11-11T21:29:54Z,
  "message": "instance "i-0123456789" is in RUNNING
}

Transformation des entrées à l'aide de l' EventBridgeAPI

Pour plus d'informations sur l'utilisation de l' EventBridge API pour transformer les entrées, voir Utiliser le transformateur d'entrée pour extraire les données d'un événement et les saisir dans la cible.

Transformation des données en utilisant AWS CloudFormation

Pour plus d'informations sur l'utilisation AWS CloudFormation pour transformer les entrées, consultez AWS::Events::Rule InputTransformer.

Problèmes courants liés à la transformation d’entrée

Voici quelques problèmes courants lors de la transformation des entrées en EventBridge :

  • Pour les chaînes, des guillemets sont requis.

  • Il n'y a pas de validation lors de la création du chemin JSON pour votre modèle.

  • Si vous spécifiez une variable à mettre en correspondance avec un chemin JSON qui n’existe pas dans l’événement, cette variable n’est pas créée et n’apparaîtra pas dans la sortie.

  • Les propriétés JSON telles que aws.events.event.json ne peuvent être utilisées que comme valeur d’un champ JSON, et non en ligne dans d’autres chaînes.

  • EventBridge n'échappe pas aux valeurs extraites par Input Path, lors du remplissage du modèle d'entrée pour une cible.

  • Si un chemin JSON fait référence à un objet ou à un tableau JSON, mais que la variable est référencée dans une chaîne, EventBridge supprime tous les guillemets internes pour garantir la validité de la chaîne. Par exemple, pour une variable <detail> pointée$.detail, « Detail is <detail>» entraînerait la EventBridge suppression des guillemets de l'objet.

    Par conséquent, si vous souhaitez générer un objet JSON basé sur une seule variable de chemin JSON, vous devez le placer sous forme de clé. Dans cet exemple, {"detail": <detail>}.

  • Les guillemets ne sont pas obligatoires pour les variables qui représentent des chaînes. Ils sont autorisés, mais ajoutent EventBridge automatiquement des guillemets aux valeurs des variables de chaîne lors de la transformation, afin de garantir que le résultat de la transformation est un JSON valide. EventBridge n'ajoute pas de guillemets aux variables qui représentent des objets ou des tableaux JSON. N’ajoutez pas de guillemets pour les variables qui représentent des objets ou des tableaux JSON.

    Par exemple, le modèle d’entrée suivant inclut des variables qui représentent à la fois des chaînes et des objets JSON :

    {
  "ruleArn" : <aws.events.rule-arn>,
  "ruleName" : <aws.events.rule-name>,
  "originalEvent" : <aws.events.event.json>
}

    Le résultat est un code JSON valide avec des guillemets appropriés :

    {
  "ruleArn" : "arn:aws:events:us-east-2:123456789012:rule/example",
  "ruleName" : "example",
  "originalEvent" : {
    ... // commented for brevity
  }
}

  • Pour une sortie de texte (non JSON) sous forme de chaînes multilignes, placez chaque ligne distincte de votre modèle de saisie entre guillemets doubles.

    Par exemple, si vous faisiez correspondre les événements de Amazon Inspector recherche au modèle d'événements suivant :

    {
  "detail": {
    "severity": ["HIGH"],
    "status": ["ACTIVE"]
  },
  "detail-type": ["Inspector2 Finding"],
  "source": ["inspector2"]
}

    Et en utilisant le chemin d'entrée suivant :

    {
  "account": "$.detail.awsAccountId",
  "ami": "$.detail.resources[0].details.awsEc2Instance.imageId",
  "arn": "$.detail.findingArn",
  "description": "$.detail.description",
  "instance": "$.detail.resources[0].id",
  "platform": "$.detail.resources[0].details.awsEc2Instance.platform",
  "region": "$.detail.resources[0].region",
  "severity": "$.detail.severity",
  "time": "$.time",
  "title": "$.detail.title",
  "type": "$.detail.type"
}

    Vous pouvez utiliser le modèle de saisie ci-dessous pour générer une sortie de chaîne multiligne :

    "<severity> severity finding <title>"
"Description: <description>"
"ARN: \"<arn>\""
"Type: <type>"
"AWS Account: <account>"
"Region: <region>"
"EC2 Instance: <instance>"
"Platform: <platform>"
"AMI: <ami>"