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.
# AWS IoT Events fin du support
Après mûre réflexion, nous avons décidé de mettre fin au support du AWS IoT Events service à compter du 20 mai 2026. AWS IoT Events n'acceptera plus de nouveaux clients à compter du 20 mai 2025. En tant que client existant disposant d'un compte inscrit au service avant le 20 mai 2025, vous pouvez continuer à utiliser les AWS IoT Events fonctionnalités. Après le 20 mai 2026, vous ne pourrez plus utiliser AWS IoT Events.
Cette page fournit des instructions et des éléments à prendre en compte pour aider les AWS IoT Events clients à passer à une autre solution répondant aux besoins de votre entreprise.
**Note**
Les solutions présentées dans ces guides sont destinées à servir d'exemples illustratifs, et non à remplacer des fonctionnalités prêtes à être produites. AWS IoT Events Personnalisez le code, le flux de travail et les AWS ressources connexes en fonction des besoins de votre entreprise.
**Topics**
+ [Considérations à prendre en compte lors de la migration hors de AWS IoT Events](#eos-considerations)
+ [Procédure de migration pour les modèles de détecteurs dans AWS IoT Events](eos-procedure-detector-models.md)
+ [Procédure de migration pour les AWS IoT SiteWise alarmes dans AWS IoT Events](eos-procedure-alarms.md)
## Considérations à prendre en compte lors de la migration hors de AWS IoT Events
+ Mettez en œuvre les meilleures pratiques de sécurité, notamment en utilisant des rôles IAM dotés de privilèges minimaux pour chaque composant et en chiffrant les données au repos et en transit. Pour plus d’informations, consultez [Bonnes pratiques de sécurité dans IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) dans le *Guide de l’utilisateur IAM*.
+ Tenez compte du nombre de partitions pour le flux Kinesis en fonction de vos exigences en matière d'ingestion de données. Pour plus d'informations sur les partitions Kinesis, consultez la [terminologie et les concepts relatifs à Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/key-concepts.html) dans le manuel du développeur *Amazon Kinesis Data Streams*.
+ Configurez une surveillance et un débogage complets à l'aide CloudWatch des métriques et des journaux. Pour plus d'informations, voir [Qu'est-ce que c'est CloudWatch ?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) dans le *guide de CloudWatch l'utilisateur Amazon*.
+ Réfléchissez à la structure de votre gestion des erreurs, notamment à la manière de gérer les messages dont le traitement échoue à plusieurs reprises, à la mise en œuvre de politiques de nouvelle tentative et à la mise en place d'un processus pour isoler et analyser les messages problématiques.
+ Utilisez le [calculateur de AWS prix](https://calculator.aws) pour estimer les coûts correspondant à votre cas d'utilisation spécifique.
# Procédure de migration pour les modèles de détecteurs dans AWS IoT Events
Cette section décrit les solutions alternatives qui fournissent des fonctionnalités de modèle de détecteur similaires à celles que vous utilisez lors de la migration AWS IoT Events.
Vous pouvez migrer l'ingestion de données via des AWS IoT Core règles vers une combinaison d'autres AWS services. Au lieu d'être ingérées via l'[BatchPutMessage](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchPutMessage.html)API, les données peuvent être acheminées vers le sujet AWS IoT Core MQTT.
Cette approche de migration utilise les sujets AWS IoT Core MQTT comme point d'entrée pour vos données IoT, en remplacement de la saisie directe dans. AWS IoT Events Les sujets MQTT sont choisis pour plusieurs raisons principales. Ils offrent une large compatibilité avec les appareils IoT en raison de l'utilisation généralisée du MQTT dans l'industrie. Ces rubriques peuvent traiter de gros volumes de messages provenant de nombreux appareils, ce qui garantit l'évolutivité. Ils offrent également une flexibilité dans le routage et le filtrage des messages en fonction du contenu ou du type d'appareil. De plus, les rubriques AWS IoT Core MQTT s'intègrent parfaitement aux autres AWS services, ce qui facilite le processus de migration.
Les données issues de sujets MQTT circulent vers une architecture combinant Amazon Kinesis Data Streams, AWS Lambda une fonction, une table Amazon DynamoDB et des plannings Amazon. EventBridge Cette combinaison de services reproduit et améliore les fonctionnalités précédemment fournies par AWS IoT Events, vous offrant ainsi plus de flexibilité et de contrôle sur votre pipeline de traitement des données IoT.
## Comparaison des architectures
L' AWS IoT Events architecture actuelle ingère les données par le biais d'une AWS IoT Core règle et de l'`BatchPutMessage`API. Cette architecture est utilisée AWS IoT Core pour l'ingestion de données et la publication d'événements, les messages étant acheminés via des AWS IoT Events entrées vers des modèles de détecteurs qui définissent la logique de l'état. Un rôle IAM gère les autorisations nécessaires.
La nouvelle solution prend en charge AWS IoT Core l'ingestion de données (désormais avec des rubriques MQTT dédiées aux entrées et aux sorties). Il introduit Kinesis Data Streams pour le partitionnement des données et une fonction Lambda d'évaluation pour la logique des états. Les états des appareils sont désormais stockés dans une table DynamoDB, et un rôle IAM amélioré gère les autorisations sur ces services.
| Objectif | Solution | Différences |
| --- | --- | --- |
| **Ingestion de données** — Reçoit les données des appareils IoT | AWS IoT Core | Nécessite désormais deux rubriques MQTT distinctes : l'une pour l'ingestion des données du périphérique et l'autre pour la publication des événements de sortie |
| **Orientation** des messages — Achemine les messages entrants vers les services appropriés | AWS IoT Core règle de routage des messages | Conserve les mêmes fonctionnalités de routage, mais dirige désormais les messages vers Kinesis Data Streams au lieu de AWS IoT Events |
| **Traitement des données** — Gère et organise les flux de données entrants | Kinesis Data Streams | Remplace la fonctionnalité de AWS IoT Events saisie, permettant l'ingestion des données avec le partitionnement des identifiants des appareils pour le traitement des messages |
| **Évaluation logique** — Traite les changements d'état et déclenche des actions | Évaluateur Lambda | Remplace le modèle AWS IoT Events de détecteur, fournissant une évaluation de la logique d'état personnalisable par le biais du code au lieu d'un flux de travail visuel |
| **Gestion des états** — Maintient l'état des appareils | Tableau DynamoDB | Nouveau composant qui fournit un stockage permanent des états des appareils, en remplacement de la gestion interne de AWS IoT Events l'état |
| **Sécurité** — Gère les autorisations de service | Rôle IAM | Les autorisations mises à jour incluent désormais l'accès à Kinesis Data Streams, à DynamoDB, EventBridge ainsi qu'aux autorisations existantes AWS IoT Core |
## Étape 1 : Exporter les configurations des modèles de AWS IoT Events détecteurs (facultatif)
Avant de créer de nouvelles ressources, exportez les définitions AWS IoT Events de vos modèles de détecteurs. Ils contiennent votre logique de traitement des événements et peuvent servir de référence historique pour la mise en œuvre de votre nouvelle solution.
------
#### [ Console ]
À l'aide du AWS IoT Events AWS Management Console, effectuez les étapes suivantes pour exporter les configurations de votre modèle de détecteur :
**Pour exporter des modèles de détecteurs à l'aide du AWS Management Console**
1. Connectez-vous à la [console AWS IoT Events](https://console.aws.amazon.com/iotevents/).
1. Dans le panneau de navigation de gauche, choisissez **Modèles de détecteur**.
1. Sélectionnez le modèle de détecteur à exporter.
1. Cliquez sur **Exporter**. Lisez le message d'information concernant la sortie, puis sélectionnez à nouveau **Exporter**.
1. Répétez le processus pour chaque modèle de détecteur que vous souhaitez exporter.
Un fichier contenant une sortie JSON de votre modèle de détecteur est ajouté au dossier de téléchargement de votre navigateur. Vous pouvez éventuellement enregistrer la configuration de chaque modèle de détecteur afin de préserver les données historiques.
------
#### [ AWS CLI ]
À l'aide de AWS CLI, exécutez les commandes suivantes pour exporter les configurations de votre modèle de détecteur :
**Pour exporter des modèles de détecteurs à l'aide de AWS CLI**
1. Répertoriez tous les modèles de détecteurs de votre compte :
```
aws iotevents list-detector-models
```
1. Pour chaque modèle de détecteur, exportez sa configuration en exécutant :
```
aws iotevents describe-detector-model \
--detector-model-name your-detector-model-name
```
1. Enregistrez la sortie pour chaque modèle de détecteur.
------
## Étape 2 : Créer un rôle IAM
Créez un rôle IAM pour fournir des autorisations permettant de répliquer les fonctionnalités de. AWS IoT Events Dans cet exemple, le rôle donne accès à DynamoDB pour la gestion des états, pour la planification EventBridge, à Kinesis Data Streams pour l' AWS IoT Core ingestion de données, pour la publication de messages et pour la journalisation. CloudWatch Ensemble, ces services remplaceront AWS IoT Events.
1. Créez un rôle IAM avec les autorisations suivantes. Pour des instructions plus détaillées sur la création d'un rôle IAM, consultez la section [Créer un rôle pour déléguer des autorisations à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) dans le Guide de l'*utilisateur IAM*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DynamoDBAccess",
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:Query",
"dynamodb:Scan"
],
"Resource": "arn:aws:dynamodb:us-east-1:123456789012:table/EventsStateTable"
},
{
"Sid": "SchedulerAccess",
"Effect": "Allow",
"Action": [
"scheduler:CreateSchedule",
"scheduler:DeleteSchedule"
],
"Resource": "arn:aws:scheduler:us-east-1:123456789012:schedule/*"
},
{
"Sid": "KinesisAccess",
"Effect": "Allow",
"Action": [
"kinesis:GetRecords",
"kinesis:GetShardIterator",
"kinesis:DescribeStream",
"kinesis:ListStreams"
],
"Resource": "arn:aws:kinesis:us-east-1:123456789012:stream/*"
},
{
"Sid": "IoTPublishAccess",
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": "arn:aws:iot:us-east-1:123456789012:topic/*"
},
{
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "arn:aws:logs:us-east-1:123456789012:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/your-lambda:*"
]
}
]
}
```
------
1. Ajoutez la politique de confiance des rôles IAM suivante. Une politique de confiance permet aux AWS services spécifiés d'assumer le rôle IAM afin qu'ils puissent effectuer les actions nécessaires. Pour des instructions plus détaillées sur la création d'une politique de confiance IAM, voir [Création d'un rôle à l'aide de politiques de confiance personnalisées](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) dans le Guide de l'*utilisateur IAM*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"scheduler.amazonaws.com",
"lambda.amazonaws.com",
"iot.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Étape 3 : Création d'Amazon Kinesis Data Streams
Créez Amazon Kinesis Data Streams à l'aide AWS Management Console du AWS CLI ou.
------
#### [ Console ]
Pour créer un flux de données Kinesis à l'aide de AWS Management Console, suivez la procédure décrite sur la page [Créer un flux de données du manuel *Amazon Kinesis Data* Streams](https://docs.aws.amazon.com/streams/latest/dev/tutorial-stock-data-kplkcl-create-stream.html) Developer Guide.
Ajustez le nombre de partitions en fonction du nombre d'appareils et de la taille de la charge utile des messages.
------
#### [ AWS CLI ]
Utilisez AWS CLI et créez Amazon Kinesis Data Streams pour ingérer et partitionner les données de vos appareils.
Les Kinesis Data Streams sont utilisés dans cette migration pour remplacer la fonctionnalité AWS IoT Events d'ingestion de données de. Il fournit un moyen évolutif et efficace de collecter, traiter et analyser les données de streaming en temps réel à partir de vos appareils IoT, tout en offrant une gestion flexible des données et une intégration avec d'autres AWS services.
```
aws kinesis create-stream --stream-name your-kinesis-stream-name --shard-count 4 --region your-region
```
Ajustez le nombre de partitions en fonction du nombre d'appareils et de la taille de la charge utile des messages.
------
## Étape 4 : Création ou mise à jour de la règle de routage des messages MQTT
Vous pouvez créer une nouvelle règle de routage des messages MQTT ou mettre à jour une règle existante.
------
#### [ Console ]
1. Déterminez si vous avez besoin d'une nouvelle règle de routage des messages MQTT ou si vous pouvez mettre à jour une règle existante.
1. Ouvrez la [AWS IoT Core console](https://console.aws.amazon.com/iot/).
1. Dans le volet de navigation, choisissez **Message Routing**, puis **Rules**.
1. Dans la section **Gérer**, choisissez **Routage des messages**, puis **Règles**.
1. Choisissez **Créer une règle**.
1. Sur la page **Spécifier les propriétés de la règle**, entrez le nom de la AWS IoT Core règle pour Nom de la **règle**. Dans le **champ Description de la règle *(facultatif)*, entrez une description pour indiquer que vous traitez des événements et que vous les transmettez à Kinesis Data Streams**.
1. Sur la page **Configurer l'instruction SQL**, entrez ce qui suit pour l'**instruction SQL** :**SELECT \$1 FROM 'your-database'**, puis choisissez **Next**.
1. Sur la page **Associer des actions aux règles**, et sous **Actions des règles**, sélectionnez **kinesis**.
1. Choisissez votre flux Kinesis pour le stream. Pour la clé de partition, saisissez **your-instance-id**. Sélectionnez le rôle approprié pour le rôle IAM, puis choisissez **Ajouter une action de règle**.
Pour plus d'informations, consultez la section [Création de règles AWS IoT pour acheminer les données des appareils vers d'autres services](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules-tutorial.html).
------
#### [ AWS CLI ]
1. Créez un fichier JSON avec le contenu suivant. Ce fichier de configuration JSON définit une AWS IoT Core règle qui sélectionne tous les messages d'un sujet et les transmet au flux Kinesis spécifié, en utilisant l'ID d'instance comme clé de partition.
```
{
"sql": "SELECT * FROM 'your-config-file'",
"description": "Rule to process events and forward to Kinesis Data Streams",
"actions": [
{
"kinesis": {
"streamName": "your-kinesis-stream-name",
"roleArn": "arn:aws:iam::your-account-id:role/service-role/your-iam-role",
"partitionKey": "${your-instance-id}"
}
}
],
"ruleDisabled": false,
"awsIotSqlVersion": "2016-03-23"
}
```
1. Créez la règle du sujet MQTT à l'aide du AWS CLI. Cette étape utilise le AWS CLI pour créer une règle de AWS IoT Core rubrique en utilisant la configuration définie dans le `events_rule.json` fichier.
```
aws iot create-topic-rule \
--rule-name "your-iot-core-rule" \
--topic-rule-payload file://your-file-name.json
```
------
## Étape 5 : Obtenir le point de terminaison pour le sujet MQTT de destination
Utilisez la rubrique MQTT de destination pour configurer l'endroit où vos rubriques publient les messages sortants, en remplacement de la fonctionnalité précédemment gérée par AWS IoT Events. Le point de terminaison est propre à votre AWS compte et à votre région.
------
#### [ Console ]
1. Ouvrez la [AWS IoT Core console](https://console.aws.amazon.com/iot/).
1. Dans la section **Connect** du panneau de navigation de gauche, choisissez **Configuration du domaine**.
1. Choisissez la configuration du domaine **IoT:Data-ATS** pour ouvrir la page détaillée de la configuration.
1. Copiez la valeur **du nom de domaine**. Cette valeur est le point final. Enregistrez la valeur du point de terminaison, car vous en aurez besoin ultérieurement.
------
#### [ AWS CLI ]
Exécutez la commande suivante pour obtenir le AWS IoT Core point de terminaison permettant de publier les messages sortants pour votre compte.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS --region your-region
```
------
## Étape 6 : Création d'une table Amazon DynamoDB
Une table Amazon DynamoDB remplace la fonctionnalité de gestion d'état AWS IoT Events de, fournissant un moyen évolutif et flexible de conserver et de gérer l'état de vos appareils ainsi que la logique du modèle de détecteur dans votre nouvelle architecture de solution.
------
#### [ Console ]
Créez une table Amazon DynamoDB pour conserver l'état des modèles de détecteurs. Pour plus d'informations, consultez la section [Créer une table dans DynamoDB dans](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html) le manuel Amazon *DynamoDB* Developer Guide.
Utilisez ce qui suit pour les détails du tableau :
+ Dans **Nom de la table**, entrez le nom de table de votre choix.
+ Pour **la clé de partition**, entrez votre propre ID d'instance.
+ Vous pouvez utiliser les **paramètres par défaut** pour les **paramètres du tableau**
------
#### [ AWS CLI ]
Exécutez la commande suivante pour créer une table DynamoDB.
```
aws dynamodb create-table \
--table-name your-table-name \
--attribute-definitions AttributeName=your-instance-id,AttributeType=S \
--key-schema AttributeName=your-instance-id,KeyType=HASH \
```
------
## Étape 7 : Création d'une AWS Lambda fonction (console)
La fonction Lambda sert de moteur de traitement principal, remplaçant la logique d'évaluation du modèle de détecteur de. AWS IoT Events Dans cet exemple, nous nous intégrons à d'autres AWS services pour gérer les données entrantes, gérer l'état et déclencher des actions en fonction des règles que vous avez définies.
Créez une fonction Lambda avec NodeJS runtime. Utilisez l'extrait de code suivant pour remplacer les constantes codées en dur :
1. Ouvrez la [AWS Lambda console](https://console.aws.amazon.com/lambda/).
1. Choisissez **Créer une fonction**.
1. Entrez un nom pour le **nom de la fonction**.
1. **Sélectionnez **NodeJS** 22.x comme environnement d'exécution.**
1. Dans la liste déroulante **Modifier le rôle d'exécution par défaut**, choisissez **Utiliser le rôle existant**, puis sélectionnez le rôle IAM que vous avez créé lors des étapes précédentes.
1. Choisissez **Créer une fonction**.
1. Collez l'extrait de code suivant après avoir remplacé les constantes codées en dur.
1. Une fois votre fonction créée, sous l'onglet **Code**, collez l'exemple de code suivant, en remplaçant le **your-destination-endpoint** point de terminaison par le vôtre.
```
import { DynamoDBClient, GetItemCommand } from '@aws-sdk/client-dynamodb';
import { PutItemCommand } from '@aws-sdk/client-dynamodb';
import { IoTDataPlaneClient, PublishCommand } from "@aws-sdk/client-iot-data-plane";
import { SchedulerClient, CreateScheduleCommand, DeleteScheduleCommand } from "@aws-sdk/client-scheduler"; // ES Modules import
//// External Clients and Constants
const scheduler = new SchedulerClient({});
const iot = new IoTDataPlaneClient({
endpoint: 'https://your-destination-endpoint-ats.iot.your-region.amazonaws.com/'
});
const ddb = new DynamoDBClient({});
//// Lambda Handler function
export const handler = async (event) => {
console.log('Incoming event:', JSON.stringify(event, null, 2));
if (!event.Records) {
throw new Error('No records found in event');
}
const processedRecords = [];
for (const record of event.Records) {
try {
if (record.eventSource !== 'aws:kinesis') {
console.log(`Skipping non-Kinesis record from ${record.eventSource}`);
continue;
}
// Assumes that we are processing records from Kinesis
const payload = record.kinesis.data;
const decodedData = Buffer.from(payload, 'base64').toString();
console.log("decoded payload is ", decodedData);
const output = await handleDecodedData(decodedData);
// Add additional processing logic here
const processedData = {
output,
sequenceNumber: record.kinesis.sequenceNumber,
partitionKey: record.kinesis.partitionKey,
timestamp: record.kinesis.approximateArrivalTimestamp
};
processedRecords.push(processedData);
} catch (error) {
console.error('Error processing record:', error);
console.error('Failed record:', record);
// Decide whether to throw error or continue processing other records
// throw error; // Uncomment to stop processing on first error
}
}
return {
statusCode: 200,
body: JSON.stringify({
message: 'Processing complete',
processedCount: processedRecords.length,
records: processedRecords
})
};
};
// Helper function to handle decoded data
async function handleDecodedData(payload) {
try {
// Parse the decoded data
const parsedData = JSON.parse(payload);
// Extract instanceId
const instanceId = parsedData.instanceId;
// Parse the input field
const inputData = JSON.parse(parsedData.payload);
const temperature = inputData.temperature;
console.log('For InstanceId: ', instanceId, ' the temperature is:', temperature);
await iotEvents.process(instanceId, inputData)
return {
instanceId,
temperature,
// Add any other fields you want to return
rawInput: inputData
};
} catch (error) {
console.error('Error handling decoded data:', error);
throw error;
}
}
//// Classes for declaring/defining the state machine
class CurrentState {
constructor(instanceId, stateName, variables, inputs) {
this.stateName = stateName;
this.variables = variables;
this.inputs = inputs;
this.instanceId = instanceId
}
static async load(instanceId) {
console.log(`Loading state for id ${instanceId}`);
try {
const { Item: { state: { S: stateContent } } } = await ddb.send(new GetItemCommand({
TableName: 'EventsStateTable',
Key: {
'InstanceId': { S: `${instanceId}` }
}
}));
const { stateName, variables, inputs } = JSON.parse(stateContent);
return new CurrentState(instanceId, stateName, variables, inputs);
} catch (e) {
console.log(`No state for id ${instanceId}: ${e}`);
return undefined;
}
}
static async save(instanceId, state) {
console.log(`Saving state for id ${instanceId}`);
await ddb.send(new PutItemCommand({
TableName: 'your-events-state-table-name',
Item: {
'InstanceId': { S: `${instanceId}` },
'state': { S: state }
}
}));
}
setVariable(name, value) {
this.variables[name] = value;
}
changeState(stateName) {
console.log(`Changing state from ${this.stateName} to ${stateName}`);
this.stateName = stateName;
}
async setTimer(instanceId, frequencyInMinutes, payload) {
console.log(`Setting timer ${instanceId} for frequency of ${frequencyInMinutes} minutes`);
const base64Payload = Buffer.from(JSON.stringify(payload)).toString();
console.log(base64Payload);
const scheduleName = `your-schedule-name-${instanceId}-schedule`;
const scheduleParams = {
Name: scheduleName,
FlexibleTimeWindow: {
Mode: 'OFF'
},
ScheduleExpression: `rate(${frequencyInMinutes} minutes)`,
Target: {
Arn: "arn:aws::kinesis:your-region:your-account-id:stream/your-kinesis-stream-name",
RoleArn: "arn:aws::iam::your-account-id:role/service-role/your-iam-role",
Input: base64Payload,
KinesisParameters: {
PartitionKey: instanceId,
},
RetryPolicy: {
MaximumRetryAttempts: 3
}
},
};
const command = new CreateScheduleCommand(scheduleParams);
console.log(`Sending command to set timer ${JSON.stringify(command)}`);
await scheduler.send(command);
}
async clearTimer(instanceId) {
console.log(`Cleaning timer ${instanceId}`);
const scheduleName = `your-schedule-name-${instanceId}-schedule`;
const command = new DeleteScheduleCommand({
Name: scheduleName
});
await scheduler.send(command);
}
async executeAction(actionType, actionPayload) {
console.log(`Will execute the ${actionType} with payload ${actionPayload}`);
await iot.send(new PublishCommand({
topic: `${this.instanceId}`,
payload: actionPayload,
qos: 0
}));
}
setInput(value) {
this.inputs = { ...this.inputs, ...value };
}
input(name) {
return this.inputs[name];
}
}
class IoTEvents {
constructor(initialState) {
this.initialState = initialState;
this.states = {};
}
state(name) {
const state = new IoTEventsState();
this.states[name] = state;
return state;
}
async process(instanceId, input) {
let currentState = await CurrentState.load(instanceId) || new CurrentState(instanceId, this.initialState, {}, {});
currentState.setInput(input);
console.log(`With inputs as: ${JSON.stringify(currentState)}`);
const state = this.states[currentState.stateName];
currentState = await state.evaluate(currentState);
console.log(`With output as: ${JSON.stringify(currentState)}`);
await CurrentState.save(instanceId, JSON.stringify(currentState));
}
}
class Event {
constructor(condition, action) {
this.condition = condition;
this.action = action;
}
}
class IoTEventsState {
constructor() {
this.eventsList = []
}
events(eventListArg) {
this.eventsList.push(...eventListArg);
return this;
}
async evaluate(currentState) {
for (const e of this.eventsList) {
console.log(`Evaluating event ${e.condition}`);
if (e.condition(currentState)) {
console.log(`Event condition met`);
// Execute any action as defined in iotEvents DM Definition
await e.action(currentState);
}
}
return currentState;
}
}
////// DetectorModel Definitions - replace with your own defintions
let processAlarmStateEvent = new Event(
(currentState) => {
const source = currentState.input('source');
return (
currentState.input('temperature') < 70
);
},
async (currentState) => {
currentState.changeState('normal');
await currentState.clearTimer(currentState.instanceId)
await currentState.executeAction('MQTT', `{"state": "alarm cleared, timer deleted" }`);
}
);
let processTimerEvent = new Event(
(currentState) => {
const source = currentState.input('source');
console.log(`Evaluating timer event with source ${source}`);
const booleanOutput = (source !== undefined && source !== null &&
typeof source === 'string' &&
source.toLowerCase() === 'timer' &&
// check if the currentState == state from the timer payload
currentState.input('currentState') !== undefined &&
currentState.input('currentState') !== null &&
currentState.input('currentState').toLowerCase !== 'normal');
console.log(`Timer event evaluated as ${booleanOutput}`);
return booleanOutput;
},
async (currentState) => {
await currentState.executeAction('MQTT', `{"state": "timer timed out in Alarming state" }`);
}
);
let processNormalEvent = new Event(
(currentState) => currentState.input('temperature') > 70,
async (currentState) => {
currentState.changeState('alarm');
await currentState.executeAction('MQTT', `{"state": "alarm detected, timer started" }`);
await currentState.setTimer(currentState.instanceId, 5, {
"instanceId": currentState.instanceId,
"payload":"{\"currentState\": \"alarm\", \"source\": \"timer\"}"
});
}
);
const iotEvents = new IoTEvents('normal');
iotEvents
.state('normal')
.events(
[
processNormalEvent
]);
iotEvents
.state('alarm')
.events([
processAlarmStateEvent,
processTimerEvent
]
);
```
## Étape 8 : ajouter un déclencheur Amazon Kinesis Data Streams
Ajoutez un déclencheur Kinesis Data Streams à la fonction Lambda à l'aide du ou. AWS Management Console AWS CLI
L'ajout d'un déclencheur Kinesis Data Streams à votre fonction Lambda établit le lien entre votre pipeline d'ingestion de données et votre logique de traitement, ce qui lui permet d'évaluer automatiquement les flux de données IoT entrants et de réagir aux événements en temps réel, de la même manière que le traitement des entrées. AWS IoT Events
------
#### [ Console ]
Pour plus d'informations, consultez la section [Créer un mappage de source d'événements pour appeler une fonction Lambda](https://docs.aws.amazon.com/lambda/latest/dg/services-kinesis-create.html#services-kinesis-eventsourcemapping) dans le Guide du *AWS Lambda développeur*.
Utilisez ce qui suit pour les détails du mappage des sources d'événements :
+ Pour **Nom de la fonction**, entrez le nom lambda utilisé dans[Étape 7 : Création d'une AWS Lambda fonction (console)](#eos-detector-model-create-lambda-function).
+ Pour **Consumer : facultatif**, entrez l'ARN de votre flux Kinesis.
+ Pour la **Taille de lot**, saisissez **10**.
------
#### [ AWS CLI ]
Exécutez la commande suivante pour créer le déclencheur de la fonction Lambda.
```
aws lambda create-event-source-mapping \
--function-name your-lambda-name \
--event-source arn:aws:kinesis:your-region:your-account-id:stream/your-kinesis-stream-name \
--batch-size 10 \
--starting-position LATEST \
--region your-region
```
------
## Étape 9 : Tester les fonctionnalités d'ingestion et de sortie des données (AWS CLI)
Publiez une charge utile dans la rubrique MQTT en fonction de ce que vous avez défini dans votre modèle de détecteur. Voici un exemple de charge utile pour la rubrique MQTT `your-topic-name` pour tester une implémentation.
```
{
"instanceId": "your-instance-id",
"payload": "{\"temperature\":78}"
}
```
Vous devriez voir un message MQTT publié sur un sujet avec le contenu suivant (ou similaire) :
```
{
"state": "alarm detected, timer started"
}
```
# Procédure de migration pour les AWS IoT SiteWise alarmes dans AWS IoT Events
Cette section décrit les solutions alternatives qui fournissent des fonctionnalités d'alarme similaires à celles que vous utilisez lors de la migration AWS IoT Events.
Pour les AWS IoT SiteWise propriétés qui utilisent des AWS IoT Events alarmes, vous pouvez migrer vers une solution utilisant des CloudWatch alarmes. Cette approche fournit des capacités de surveillance robustes avec des fonctionnalités établies SLAs et supplémentaires telles que la détection des anomalies et les alarmes groupées.
## Comparaison des architectures
La configuration AWS IoT Events d'alarme actuelle pour les AWS IoT SiteWise propriétés doit être créée `AssetModelCompositeModels` dans le modèle d'actif, comme décrit dans la section [Définition des alarmes externes](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/define-external-alarms.html) du *guide de AWS IoT SiteWise l'utilisateur*. AWS IoT SiteWise Les modifications apportées à la nouvelle solution sont généralement gérées via la AWS IoT Events console.
La nouvelle solution permet de gérer les alarmes en tirant parti des CloudWatch alarmes. Cette approche utilise des AWS IoT SiteWise notifications pour publier des points de données de propriété dans des rubriques AWS IoT Core MQTT, qui sont ensuite traités par une fonction Lambda. La fonction transforme ces notifications en CloudWatch métriques, permettant de surveiller les alarmes grâce à un cadre CloudWatch d'alarme.
| Objectif | Solution | Différences |
| --- | --- | --- |
| **Source de données** : données de propriété provenant de AWS IoT SiteWise | AWS IoT SiteWise Notifications MQTT | Remplace l'intégration directe d'IoT Events par les notifications MQTT provenant des propriétés AWS IoT SiteWise |
| **Traitement des données** — Transforme les données de propriété | Fonction Lambda | Traite les notifications relatives aux AWS IoT SiteWise propriétés et les convertit en CloudWatch métriques |
| **Évaluation des alarmes** — Surveille les métriques et déclenche des alarmes | CloudWatch Alarmes Amazon | Remplace AWS IoT Events les alarmes par des CloudWatch alarmes, offrant des fonctionnalités supplémentaires telles que la détection des anomalies |
| **Intégration** — Connexion avec AWS IoT SiteWise | AWS IoT SiteWise alarmes externes | Possibilité optionnelle de réimporter CloudWatch les alarmes en AWS IoT SiteWise tant qu'alarmes externes |
## Étape 1 : activer les notifications MQTT sur la propriété de l'actif
Si vous utilisez AWS IoT Events des intégrations pour les AWS IoT SiteWise alarmes, vous pouvez activer les notifications MQTT pour chaque propriété à surveiller.
1. Suivez la AWS IoT SiteWise procédure de [configuration des alarmes sur les actifs](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-alarms.html#configure-alarm-threshold-value-console) jusqu'à ce que vous passiez à chaque étape de **modification** des propriétés du modèle d'actifs.
1. Pour chaque propriété à migrer, remplacez le **statut de notification MQTT par** **ACTIVE**.
![\[Capture d'écran montrant le placement de la liste déroulante d'état des notifications MQTT dans la AWS IoT SiteWise console.\]](http://docs.aws.amazon.com/fr_fr/iotevents/latest/developerguide/images/events-eos-sw-asset-mqtt.png)
1. Notez le chemin de rubrique vers lequel l'alarme est publiée pour chaque attribut d'alarme modifié.
Pour plus d'informations, consultez les ressources de documentation suivantes :
+ [Découvrez les propriétés des actifs dans les rubriques MQTT](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/mqtt-topics.html) du *guide de l'AWS IoT SiteWise utilisateur*.
+ [Rubriques relatives au MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/topics.html) dans le *guide du AWS IoT développeur*.
## Étape 2 : Création d'une AWS Lambda fonction
Créez une fonction Lambda pour lire le tableau TQV publié par le sujet MQTT et publiez des valeurs individuelles dans. CloudWatch Nous utiliserons cette fonction Lambda comme action de destination à déclencher dans AWS IoT Core Message Rules.
1. Ouvrez la [AWS Lambda console](https://console.aws.amazon.com/lambda).
1. Choisissez **Créer une fonction**.
1. Entrez un nom pour le **nom de la fonction**.
1. **Sélectionnez **NodeJS** 22.x comme environnement d'exécution.**
1. Dans la liste déroulante **Modifier le rôle d'exécution par défaut**, choisissez **Utiliser le rôle existant**, puis sélectionnez le rôle IAM que vous avez créé lors des étapes précédentes.
**Note**
Cette procédure suppose que vous avez déjà migré votre modèle de détecteur. Si vous n'avez pas de rôle IAM, consultez[](eos-procedure-detector-models.md#eos-detector-model-create-iam-role).
1. Choisissez **Créer une fonction**.
1. Collez l'extrait de code suivant après avoir remplacé les constantes codées en dur.
```
import json
import boto3
from datetime import datetime
# Initialize CloudWatch client
cloudwatch = boto3.client('cloudwatch')
def lambda_handler(message, context):
try:
# Parse the incoming IoT message
# Extract relevant information
asset_id = message['payload']['assetId']
property_id = message['payload']['propertyId']
# Process each value in the values array
for value in message['payload']['values']:
# Extract timestamp and value
timestamp = datetime.fromtimestamp(value['timestamp']['timeInSeconds'])
metric_value = value['value']['doubleValue']
quality = value.get('quality', 'UNKNOWN')
# Publish to CloudWatch
response = cloudwatch.put_metric_data(
Namespace='IoTSiteWise/AssetMetrics',
MetricData=[
{
'MetricName': f'Property_your-property-id',
'Value': metric_value,
'Timestamp': timestamp,
'Dimensions': [
{
'Name': 'AssetId',
'Value': 'your-asset-id'
},
{
'Name': 'Quality',
'Value': quality
}
]
}
]
)
return {
'statusCode': 200,
'body': json.dumps('Successfully published metrics to CloudWatch')
}
except Exception as e:
print(f'Error processing message: {str(e)}')
return {
'statusCode': 500,
'body': json.dumps(f'Error: {str(e)}')
}
```
## Étape 3 : Création d'une règle de routage des AWS IoT Core messages
+ Suivez le [didacticiel : procédure de republication d'un message MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-repub-rule.html) en saisissant les informations suivantes lorsque vous y êtes invité :
1. Nom de la règle de routage des messages`SiteWiseToCloudwatchAlarms`.
1. Pour la requête, vous pouvez utiliser ce qui suit :
```
SELECT * FROM '$aws/sitewise/asset-models/your-asset-model-id/assets/your-asset-id/properties/your-property-id'
```
1. Dans **Actions de règles**, sélectionnez l'action **Lambda** à partir de laquelle envoyer les données générées à AWS IoT SiteWise . CloudWatch Par exemple :
![\[Capture d'écran illustrant l'action des règles pour la fonction Lambda.\]](http://docs.aws.amazon.com/fr_fr/iotevents/latest/developerguide/images/events-eos-lambda-rule-action.png)
## Étape 4 : Afficher les CloudWatch métriques
Lorsque vous ingérez des données AWS IoT SiteWise, la propriété sélectionnée précédemment achemine les données vers la fonction Lambda que nous avons créée dans[Étape 1 : activer les notifications MQTT sur la propriété de l'actif](#eos-alarms-mqtt-asset-property). [Étape 2 : Création d'une AWS Lambda fonction](#eos-alarms-lambda-function) Au cours de cette étape, vous pouvez vérifier que le Lambda envoie vos métriques à. CloudWatch
1. Ouvrez la [CloudWatch AWS Management Console](https://console.aws.amazon.com/cloudwatch/).
1. Dans le volet de navigation de gauche, choisissez **Metrics**, puis **All metrics**.
1. Choisissez l'URL d'une alarme pour l'ouvrir.
1. Sous l'onglet **Source**, le CloudWatch résultat est similaire à celui de cet exemple. Ces informations de source confirment que les données métriques alimentent CloudWatch.
```
{
"view": "timeSeries",
"stacked": false,
"metrics": [
[ "IoTSiteWise/AssetMetrics", "Property_your-property-id-hash", "Quality", "GOOD", "AssetId", "your-asset-id-hash", { "id": "m1" } ]
],
"region": "your-region"
}
```
## Étape 5 : créer des CloudWatch alarmes
Suivez la procédure de [création CloudWatch d'une alarme basée sur un seuil statique](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) du *guide de CloudWatch l'utilisateur Amazon* pour créer des alarmes pour chaque métrique pertinente.
**Note**
Il existe de nombreuses options de configuration des alarmes dans Amazon. CloudWatch Pour plus d'informations sur les CloudWatch alarmes, consultez la section [Utilisation des CloudWatch alarmes Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le *guide de CloudWatch l'utilisateur Amazon*.
## Étape 6 : (Facultatif) importez l' CloudWatch alarme dans AWS IoT SiteWise
Vous pouvez configurer des CloudWatch alarmes pour qu'elles renvoient des données à AWS IoT SiteWise l'aide CloudWatch d'actions d'alarme et de Lambda. Cette intégration vous permet de visualiser l'état et les propriétés des alarmes dans le portail SiteWise Monitor.
1. Configurez l'alarme externe en tant que propriété dans un modèle d'actif. Pour plus d'informations, reportez-vous à la section [Définition des alarmes externes AWS IoT SiteWise dans](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/define-external-alarms.html) le *guide de AWS IoT SiteWise l'utilisateur*.
1. Créez une fonction Lambda qui utilise l'[BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html)API figurant dans le *guide de l'AWS IoT SiteWise utilisateur* pour envoyer des données d'alarme à. AWS IoT SiteWise
1. Configurez des actions CloudWatch d'alarme pour appeler votre fonction Lambda lorsque l'état de l'alarme change. Pour plus d'informations, consultez la section [Actions d'alarme](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-and-actions.html) dans le *guide de CloudWatch l'utilisateur Amazon*.