

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
<a name="eb-transform-target-input"></a>

Vous pouvez personnaliser le texte d'un [événement](eb-events.md) avant de EventBridge transmettre les informations à la [cible](eb-targets.md) d'une [règle](eb-rules.md). À 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](eb-targets.md#dynamic-path-parameters) 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* sous la forme < *variable-name* >. 

Pour obtenir un didacticiel sur l’utilisation du transformateur d’entrée, consultez [Tutoriel : Utiliser des transformateurs d'entrée pour transformer des événements en EventBridge](eb-input-transformer-tutorial.md).

**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 (\$1)
barres obliques vers l'avant

**Topics**
+ [Variables prédéfinies](#eb-transform-input-predefined)
+ [Exemples de transformation d’entrée](#eb-transform-input-examples)
+ [Transformation des entrées à l'aide de l' EventBridge API](#eb-transform-input-api)
+ [Transformation des données en utilisant AWS CloudFormation](#eb-transform-input-cfn)
+ [Problèmes courants liés à la transformation d’entrée](#eb-transform-input-issues)
+ [Configuration d'un transformateur d'entrée lors de la création d'une règle dans EventBridge](eb-transform-input-rule.md)
+ [Test d'un transformateur d'entrée cible à l'aide du EventBridge Sandbox](eb-sandbox-input-trans.md)

## Variables prédéfinies
<a name="eb-transform-input-predefined"></a>

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
<a name="eb-transform-input-examples"></a>

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*.

### Chemin d'entrée
<a name="eb-transform-target-input-path"></a>

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*.

**Note**  
Amazon CloudWatch Logs et les cibles SSM ne prennent pas en charge l'utilisation de `Input` et `InputPath` dans leurs transformateurs d'entrée.

### Modèle de saisie
<a name="eb-transform-target-input-template"></a>

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 | Output | 
| --- | --- | --- | 
| Chaîne simple |  <pre>"instance <instance> is in <state>"</pre> |  <pre>"instance i-0123456789 is in RUNNING"</pre>  | 
|  **Chaîne avec guillemets échappés**  |  <pre>"instance \"<instance>\" is in <state>"</pre> |  <pre>"instance \"i-0123456789\" is in RUNNING"</pre> 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**  |  <pre>{<br />  "instance" : <instance>,<br />  "state": <state><br />}</pre> |  <pre>{<br />  "instance" : "i-0123456789",<br />  "state": "RUNNING"<br />}</pre>  | 
|  **Fichier JSON avec chaînes et variables**  |  <pre>{<br /> "instance" : <instance>,<br /> "state": "<state>",<br /> "instanceStatus": "instance \"<instance>\" is in <state>"<br />}</pre>  |  <pre>{<br /> "instance" : "i-0123456789",<br /> "state": "RUNNING",<br /> "instanceStatus": "instance \"i-0123456789\" is in RUNNING"<br />}</pre>  | 
|  **Fichier JSON avec un mélange de variables et d'informations statiques**  |  <pre>{<br />  "instance" : <instance>,<br />  "state": [ 9, <state>, true ],<br />  "Transformed" : "Yes"<br />}<br /></pre> |  <pre>{<br />  "instance" : "i-0123456789",<br />  "state": [<br />    9,<br />    "RUNNING",<br />    true<br />  ],<br />  "Transformed" : "Yes"<br />}</pre>  | 
|  **Inclut des variables réservées dans JSON**  |  <pre>{<br />  "instance" : <instance>,<br />  "state": <state>,<br />  "ruleArn" : <aws.events.rule-arn>,<br />  "ruleName" : <aws.events.rule-name>,<br />  "originalEvent" : <aws.events.event.json><br />}</pre> |  <pre>{<br />  "instance" : "i-0123456789",<br />  "state": "RUNNING",<br />  "ruleArn" : "arn:aws:events:us-east-2:123456789012:rule/example",<br />  "ruleName" : "example",<br />  "originalEvent" : {<br />    ... // commented for brevity<br />  }<br />}</pre>  | 
|  **Inclut des variables réservées dans une chaîne**  | <pre>"<aws.events.rule-name> triggered"</pre> |  <pre>"example triggered"</pre>  | 
|  **Groupe de CloudWatch journaux Amazon**  | <pre>{<br />  "timestamp" : <timestamp>,<br />  "message": "instance \"<instance>\" is in <state>"<br />}</pre> |  <pre>{<br />  "timestamp" : 2015-11-11T21:29:54Z,<br />  "message": "instance "i-0123456789" is in RUNNING<br />}</pre>  | 

## Transformation des entrées à l'aide de l' EventBridge API
<a name="eb-transform-input-api"></a>

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](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutTargets.html#API_PutTargets_Example_2).

## Transformation des données en utilisant AWS CloudFormation
<a name="eb-transform-input-cfn"></a>

Pour plus d'informations sur l'utilisation AWS CloudFormation pour transformer les entrées, consultez [AWS::Events::Rule InputTransformer](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-inputtransformer.html).

## Problèmes courants liés à la transformation d’entrée
<a name="eb-transform-input-issues"></a>

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](https://docs.aws.amazon.com/inspector/latest/user/eventbridge-integration.html#event-finding) 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>"
  ```