

Avis de fin de support : le 20 mai 2026, AWS le support de AWS IoT Events. Après le 20 mai 2026, vous ne pourrez plus accéder à la AWS IoT Events console ni aux AWS IoT Events ressources. Pour plus d'informations, consultez [AWS IoT Events la fin du support](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).

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.

# Créez un AWS IoT Events détecteur pour deux états à l'aide de la CLI
<a name="iotevents-simple-example"></a>

Dans cet exemple, nous appelons les AWS CLI commandes AWS IoT Events APIs using pour créer un détecteur qui modélise deux états d'un moteur : un état normal et un état de surpression.

Lorsque la pression mesurée dans le moteur dépasse un certain seuil, le modèle passe en état de surpression et envoie un message Amazon Simple Notification Service (Amazon SNS) pour avertir le technicien de cette situation. Lorsque la pression chute en dessous du seuil pendant trois relevés de pression consécutifs, le modèle revient à l'état normal et envoie un autre message Amazon SNS pour confirmer que le problème est résolu. Nous avons besoin de trois mesures consécutives en dessous du seuil de pression afin d'éliminer le bégaiement éventuel dû à des messages de surpression ou à des messages normaux en cas de phase de reprise non linéaire ou de lecture anormale ponctuelle.

Vous trouverez ci-dessous un aperçu des étapes de création du détecteur.

**Créez des *entrées*.**  
Pour surveiller vos appareils et processus, vous devez pouvoir obtenir des données télémétriques dans AWS IoT Events. Cela se fait en envoyant des messages en tant qu'*entrées* à AWS IoT Events. Pour ce faire, plusieurs options s'offrent à vous :   
+ Utilisez l'[ BatchPutMessage](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchPutMessage.html)opération. Cette méthode est simple mais nécessite que vos appareils ou processus puissent accéder à l' AWS IoT Events API via un SDK ou le AWS CLI.
+ Dans AWS IoT Core, écrivez une règle [AWS IoT Events d'action](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html#iotevents-rule) pour le moteur de AWS IoT Core règles qui transfère les données de vos messages vers AWS IoT Events. Cela identifie l'entrée par son nom. Utilisez cette méthode si vos appareils ou processus peuvent envoyer des messages ou le font déjà AWS IoT Core. Cette méthode nécessite généralement moins de puissance de calcul de la part d'un appareil.
+ Dans AWS IoT Analytics, utilisez l'[ CreateDataset](https://docs.aws.amazon.com/iotanalytics/latest/userguide/automate.html#aws-iot-analytics-automate-create-dataset)opération pour créer un ensemble de données spécifiant `contentDeliveryRules` l' AWS IoT Events entrée, où le contenu de l'ensemble de données est envoyé automatiquement. Utilisez cette méthode si vous souhaitez contrôler vos appareils ou vos processus en fonction des données agrégées ou analysées dans AWS IoT Analytics.
Avant que vos appareils puissent envoyer des données de cette manière, vous devez définir une ou plusieurs entrées. Pour ce faire, attribuez un nom à chaque entrée et spécifiez les champs des données des messages entrants surveillés par l'entrée.

**Création d'un modèle de détecteur**  
Créez un *modèle de détecteur* (un modèle de votre équipement ou de votre processus) à l'aide *des états*. Pour chaque état, définissez une logique conditionnelle (booléenne) qui évalue les entrées entrantes afin de détecter les événements significatifs. Lorsqu'un événement est détecté, il peut changer d'état ou lancer des actions personnalisées ou prédéfinies à l'aide d'autres AWS services. Vous pouvez définir des événements supplémentaires qui déclenchent des actions lors de l'entrée ou de la sortie d'un état et, éventuellement, lorsqu'une condition est remplie.

**Surveillez plusieurs appareils ou processus**  
Si vous surveillez plusieurs appareils ou processus et que vous souhaitez suivre chacun d'eux séparément, spécifiez un champ dans chaque entrée qui identifie le périphérique ou le processus dont provient l'entrée. Voir le `key` champ dans`CreateDetectorModel`. Lorsqu'un nouveau dispositif est identifié (une nouvelle valeur apparaît dans le champ de saisie identifié par le`key`), une instance de détecteur est créée. La nouvelle instance de détecteur continue de répondre aux entrées provenant de cet appareil particulier jusqu'à ce que son modèle de détecteur soit mis à jour ou supprimé. Vous avez autant de détecteurs uniques (instances) qu'il y a de valeurs uniques dans les `key` champs de saisie.

**Surveillez un seul appareil ou processus**  
Si vous surveillez un seul processus (même si plusieurs appareils ou sous-processus envoient des entrées), vous ne spécifiez pas de `key` champ d'identification unique. Dans ce cas, un seul détecteur (instance) est créé lorsque la première entrée arrive. Par exemple, vous pouvez avoir des capteurs de température dans chaque pièce d'une maison, mais une seule unité CVC pour chauffer ou climatiser toute la maison. Vous ne pouvez donc contrôler cela que dans le cadre d'un processus unique, même si chaque occupant de la chambre souhaite que son vote (contribution) l'emporte.

**Envoyez des messages à partir de vos appareils ou processus en tant qu'entrées pour votre modèle de détecteur**  
Nous avons décrit les différentes manières d'envoyer un message à partir d'un appareil ou d'un processus en tant qu'entrée dans un AWS IoT Events détecteur dans *les entrées*. Après avoir créé les entrées et créé le modèle de détecteur, vous êtes prêt à commencer à envoyer des données.  
Lorsque vous créez un modèle de détecteur ou que vous mettez à jour un modèle existant, plusieurs minutes s'écoulent avant que le nouveau modèle de détecteur ou le modèle mis à jour ne commence à recevoir des messages et à créer des détecteurs (instances). Si le modèle de détecteur est mis à jour, il est possible que vous continuiez à observer un comportement basé sur la version précédente pendant cette période.

**Topics**
+ [Création d'une AWS IoT Events entrée pour capturer les données de l'appareil](iotevents-create-input.md)
+ [Créez un modèle de détecteur pour représenter les états des appareils dans AWS IoT Events](iotevents-create-detector.md)
+ [Envoyer des messages sous forme d'entrées à un détecteur dans AWS IoT Events](iotevents-batch-put-messages.md)

# Création d'une AWS IoT Events entrée pour capturer les données de l'appareil
<a name="iotevents-create-input"></a>

Lorsque vous configurez les entrées pour AWS IoT Events, vous pouvez les utiliser AWS CLI pour définir la manière dont vos appareils communiquent les données des capteurs. Par exemple, si vos appareils envoient des messages au format JSON avec des identifiants de moteur et des relevés de capteurs, vous pouvez capturer ces données en créant une entrée qui mappe des attributs spécifiques à partir des messages, tels que la pression et l'identifiant du moteur. Le processus commence par définir une entrée dans un fichier JSON, en spécifiant les points de données pertinents et en utilisant le AWS CLI pour enregistrer l'entrée pour AWS IoT Events. Cela permet AWS IoT de surveiller et de répondre aux conditions critiques sur la base des données des capteurs en temps réel.

Supposons, par exemple, que vos appareils envoient des messages au format suivant.

```
{
  "motorid": "Fulton-A32",
  "sensorData": {
    "pressure": 23,
    "temperature": 47
  }
}
```

Vous pouvez créer une entrée pour capturer les `pressure` données et `motorid` (qui identifie le périphérique spécifique qui a envoyé le message) à l'aide de la AWS CLI commande suivante.

```
aws iotevents create-input  --cli-input-json file://pressureInput.json 
```

Le fichier `pressureInput.json` contient les éléments suivants.

```
{
  "inputName": "PressureInput",
  "inputDescription": "Pressure readings from a motor",
  "inputDefinition": {
    "attributes": [
      { "jsonPath": "sensorData.pressure" },
      { "jsonPath": "motorid" }
    ]
  }
}
```

Lorsque vous créez vos propres entrées, n'oubliez pas de collecter d'abord des exemples de messages sous forme de fichiers JSON à partir de vos appareils ou processus. Vous pouvez les utiliser pour créer une entrée à partir de la console ou de la CLI.

# Créez un modèle de détecteur pour représenter les états des appareils dans AWS IoT Events
<a name="iotevents-create-detector"></a>

Dans[Création d'une AWS IoT Events entrée pour capturer les données de l'appareil](iotevents-create-input.md), vous avez créé un message `input` basé sur un message qui rapporte les données de pression d'un moteur. Pour continuer avec l'exemple, voici un modèle de détecteur qui répond à un événement de surpression dans un moteur.

Vous créez deux états : `Normal` « » et « `Dangerous` ». Chaque détecteur (instance) passe à l'état `Normal` « » lors de sa création. L'instance est créée lorsqu'une entrée avec une valeur unique pour le `key` « `motorid` » arrive.

Si l'instance du détecteur reçoit une valeur de pression supérieure ou égale à 70, elle passe à l'état `Dangerous` « » et envoie un message Amazon SNS en guise d'avertissement. Si les relevés de pression reviennent à la normale (moins de 70) pour trois entrées consécutives, le détecteur revient à l'état « `Normal` » et envoie un autre message Amazon SNS en guise de feu vert.

Cet exemple de modèle de détecteur suppose que vous avez créé deux rubriques Amazon SNS dont les noms de ressources Amazon (ARNs) apparaissent dans la définition sous `"targetArn": "arn:aws:sns:us-east-1:123456789012:underPressureAction"` la forme et. `"targetArn": "arn:aws:sns:us-east-1:123456789012:pressureClearedAction"` 

Pour plus d'informations, consultez le [guide du développeur Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/) et, plus précisément, la documentation de l'[CreateTopic](https://docs.aws.amazon.com/sns/latest/api/API_CreateTopic.html)opération dans le manuel *Amazon Simple Notification Service API Reference*.

Cet exemple suppose également que vous avez créé un rôle Gestion des identités et des accès AWS (IAM) doté des autorisations appropriées. L'ARN de ce rôle est indiqué dans la définition du modèle de détecteur sous la forme`"roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole"`. Suivez les étapes décrites [Configuration des autorisations pour AWS IoT Events](iotevents-permissions.md) pour créer ce rôle et copiez l'ARN du rôle à l'endroit approprié dans la définition du modèle de détecteur.

Vous pouvez créer le modèle de détecteur à l'aide de la AWS CLI commande suivante.

```
aws iotevents create-detector-model  --cli-input-json file://motorDetectorModel.json
```

Le fichier `"motorDetectorModel.json"` contient les éléments suivants.

```
{
  "detectorModelName": "motorDetectorModel",
  "detectorModelDefinition": {
    "states": [
      {
        "stateName": "Normal",
        "onEnter": {
          "events": [
            {
              "eventName": "init",
              "condition": "true",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "0"
                  }
                }
              ]
            }
          ]
        },
        "onInput": {
          "transitionEvents": [
            {
              "eventName": "Overpressurized",
              "condition": "$input.PressureInput.sensorData.pressure > 70",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "$variable.pressureThresholdBreached + 3"
                  }
                }
              ],
              "nextState": "Dangerous"
            }
          ]
        }
      }, 
      {
        "stateName": "Dangerous",
        "onEnter": {
          "events": [
            {
              "eventName": "Pressure Threshold Breached",
              "condition": "$variable.pressureThresholdBreached > 1",
              "actions": [
                {
                  "sns": {
                    "targetArn": "arn:aws:sns:us-east-1:123456789012:underPressureAction"
                  }
                }
              ]
            }
          ]
        },
        "onInput": {
          "events": [
            {
              "eventName": "Overpressurized",
              "condition": "$input.PressureInput.sensorData.pressure > 70",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "3"
                  }
                }
              ]
            },
            {
              "eventName": "Pressure Okay",
              "condition": "$input.PressureInput.sensorData.pressure <= 70",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "$variable.pressureThresholdBreached - 1"
                  }
                }
              ]
            }
          ],
          "transitionEvents": [
            {
              "eventName": "BackToNormal",
              "condition": "$input.PressureInput.sensorData.pressure <= 70 && $variable.pressureThresholdBreached <= 1",
              "nextState": "Normal"
            }
          ]
        },
        "onExit": {
          "events": [
            {
              "eventName": "Normal Pressure Restored",
              "condition": "true",
              "actions": [
                {
                  "sns": {
                    "targetArn": "arn:aws:sns:us-east-1:123456789012:pressureClearedAction"
                  }
                }
              ]
            }
          ]
        }
      }
    ],
    "initialStateName": "Normal"
  },
  "key" : "motorid",
  "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole"
}
```

# Envoyer des messages sous forme d'entrées à un détecteur dans AWS IoT Events
<a name="iotevents-batch-put-messages"></a>

Vous avez maintenant défini une entrée qui identifie les champs importants des messages envoyés depuis un appareil (voir[Création d'une AWS IoT Events entrée pour capturer les données de l'appareil](iotevents-create-input.md)). Dans la section précédente, vous avez créé un `detector model` qui répond à un événement de surpression dans un moteur (voir[Créez un modèle de détecteur pour représenter les états des appareils dans AWS IoT Events](iotevents-create-detector.md)).

Pour compléter l'exemple, envoyez des messages depuis un périphérique (dans ce cas, un ordinateur sur lequel le AWS CLI système est installé) comme entrées au détecteur. 

**Note**  
Lorsque vous créez un modèle de détecteur ou que vous mettez à jour un modèle existant, plusieurs minutes s'écoulent avant que le nouveau modèle de détecteur ou le modèle mis à jour ne commence à recevoir des messages et à créer des détecteurs (instances). Si vous mettez à jour le modèle du détecteur, il est possible que vous continuiez à observer un comportement basé sur la version précédente pendant cette période.

Utilisez la AWS CLI commande suivante pour envoyer un message contenant des données dépassant le seuil.

```
aws iotevents-data batch-put-message --cli-input-json file://highPressureMessage.json --cli-binary-format raw-in-base64-out
```

Le fichier « `highPressureMessage.json` » contient les éléments suivants.

```
{
  "messages": [
    {
      "messageId": "00001",
      "inputName": "PressureInput",
      "payload": "{\"motorid\": \"Fulton-A32\", \"sensorData\": {\"pressure\": 80, \"temperature\": 39} }"
    }
  ]
}
```

Vous devez modifier le `messageId` dans chaque message envoyé. Si vous ne le modifiez pas, le AWS IoT Events système déduplique les messages. AWS IoT Events ignore un message s'il contient le même message `messageID` qu'un autre envoyé au cours des cinq dernières minutes.

À ce stade, un détecteur (instance) est créé pour surveiller les événements du moteur`"Fulton-A32"`. Ce détecteur entre dans l'`"Normal"`état lorsqu'il est créé. Mais comme nous avons envoyé une valeur de pression supérieure au seuil, elle passe immédiatement à l'`"Dangerous"`état. Ce faisant, le détecteur envoie un message au point de terminaison Amazon SNS dont l'ARN est l'ARN. `arn:aws:sns:us-east-1:123456789012:underPressureAction`

Exécutez la AWS CLI commande suivante pour envoyer un message contenant des données inférieures au seuil de pression.

```
aws iotevents-data batch-put-message --cli-input-json file://normalPressureMessage.json --cli-binary-format raw-in-base64-out
```

Le fichier `normalPressureMessage.json` contient les éléments suivants.

```
{
  "messages": [
    {
      "messageId": "00002",
      "inputName": "PressureInput",
      "payload": "{\"motorid\": \"Fulton-A32\", \"sensorData\": {\"pressure\": 60, \"temperature\": 29} }"
    }
  ]
}
```

Vous devez le modifier `messageId` dans le fichier chaque fois que vous appelez la `BatchPutMessage` commande dans un délai de cinq minutes. Envoyez le message deux fois de plus. Une fois le message envoyé trois fois, le détecteur (instance) du moteur « `Fulton-A32` » envoie un message au point de terminaison Amazon SNS `"arn:aws:sns:us-east-1:123456789012:pressureClearedAction"` et entre à nouveau dans l'état. `"Normal"`

**Note**  
Vous pouvez envoyer plusieurs messages à la fois avec`BatchPutMessage`. Cependant, l'ordre dans lequel ces messages sont traités n'est pas garanti. Pour garantir que les messages (entrées) sont traités dans l'ordre, envoyez-les un par un et attendez une réponse positive chaque fois que l'API est appelée.

Vous trouverez ci-dessous des exemples de charges utiles de messages SNS créées par l'exemple de modèle de détecteur décrit dans cette section.

**sur l'événement « Seuil de pression dépassé »**

```
IoT> {
  "eventTime":1558129816420,
  "payload":{
    "actionExecutionId":"5d7444df-a655-3587-a609-dbd7a0f55267",
    "detector":{
      "detectorModelName":"motorDetectorModel",
      "keyValue":"Fulton-A32",
      "detectorModelVersion":"1"
    },
    "eventTriggerDetails":{
      "inputName":"PressureInput",
      "messageId":"00001",
      "triggerType":"Message"
    },
    "state":{
      "stateName":"Dangerous",
      "variables":{
        "pressureThresholdBreached":3
      },
      "timers":{}
    }
  },
  "eventName":"Pressure Threshold Breached"
}
```

**sur l'événement « Normal Pressure Restaurée »**

```
IoT> {
  "eventTime":1558129925568,
  "payload":{
    "actionExecutionId":"7e25fd38-2533-303d-899f-c979792a12cb",
    "detector":{
      "detectorModelName":"motorDetectorModel",
      "keyValue":"Fulton-A32",
      "detectorModelVersion":"1"
    },
    "eventTriggerDetails":{
      "inputName":"PressureInput",
      "messageId":"00004",
      "triggerType":"Message"
    },
    "state":{
      "stateName":"Dangerous",
      "variables":{
        "pressureThresholdBreached":0
      },
      "timers":{}
    }
  },
  "eventName":"Normal Pressure Restored"
}
```

Si vous avez défini des temporisateurs, leur état actuel est également affiché dans les charges utiles des messages SNS.

Les charges utiles des messages contiennent des informations sur l'état du détecteur (instance) au moment où le message a été envoyé (c'est-à-dire au moment où l'action SNS a été exécutée). Vous pouvez utiliser cette [https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_DescribeDetector.html](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_DescribeDetector.html) opération pour obtenir des informations similaires sur l'état du détecteur.