Avviso di fine del supporto: il 20 maggio 2026, AWS terminerà il supporto per AWS IoT Events. Dopo il 20 maggio 2026, non potrai più accedere alla AWS IoT Events console o AWS IoT Events alle risorse. Per ulteriori informazioni, consulta [AWS IoT Events Fine del supporto](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AWS IoT Events fine del supporto
Dopo un'attenta valutazione, abbiamo deciso di interrompere il supporto per il AWS IoT Events servizio a partire dal 20 maggio 2026. AWS IoT Events non accetterà più nuovi clienti a partire dal 20 maggio 2025. In qualità di cliente esistente con un account registrato al servizio prima del 20 maggio 2025, puoi continuare a utilizzare AWS IoT Events le funzionalità. Dopo il 20 maggio 2026, non potrai più utilizzarle. AWS IoT Events
Questa pagina fornisce istruzioni e considerazioni per consentire AWS IoT Events ai clienti di passare a una soluzione alternativa per soddisfare le esigenze aziendali.
**Nota**
Le soluzioni presentate in queste guide sono destinate a servire come esempi illustrativi, non a sostituire funzionalità pronte per la produzione. AWS IoT Events Personalizza il codice, il flusso di lavoro e AWS le risorse correlate in base alle tue esigenze aziendali.
**Topics**
+ [Considerazioni sulla migrazione da AWS IoT Events](#eos-considerations)
+ [Procedura di migrazione per i modelli di rilevatori in AWS IoT Events](eos-procedure-detector-models.md)
+ [Procedura di migrazione per gli AWS IoT SiteWise allarmi in AWS IoT Events](eos-procedure-alarms.md)
## Considerazioni sulla migrazione da AWS IoT Events
+ Implementa le migliori pratiche di sicurezza, incluso l'utilizzo di ruoli IAM con privilegi minimi per ogni componente e la crittografia dei dati a riposo e in transito. Per ulteriori informazioni, consulta [Best Practice di sicurezza in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) nella *Guida per l'utente di IAM*.
+ Considera il numero di shard per lo stream Kinesis in base ai requisiti di inserimento dei dati. *Per ulteriori informazioni sugli shard Kinesis, consulta la [terminologia e i concetti di Amazon Kinesis Data Streams nella Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/key-concepts.html) Developer Guide.*
+ Imposta il monitoraggio e il debug completi utilizzando metriche e log. CloudWatch [Per ulteriori informazioni, consulta Cos'è? CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) nella *Amazon CloudWatch User Guide*.
+ Considera la struttura della tua gestione degli errori, ad esempio come gestire i messaggi che non vengono elaborati ripetutamente, implementare politiche di ripetizione dei tentativi e impostare un processo per isolare e analizzare i messaggi problematici.
+ Utilizza il [calcolatore AWS dei prezzi](https://calculator.aws) per stimare i costi per il tuo caso d'uso specifico.
# Procedura di migrazione per i modelli di rilevatori in AWS IoT Events
Questa sezione descrive soluzioni alternative che offrono funzionalità simili a quelle dei modelli di rilevatori durante la migrazione. AWS IoT Events
È possibile migrare l'ingestione dei dati tramite AWS IoT Core regole a una combinazione di altri servizi. AWS Invece di importare i dati tramite l'[BatchPutMessage](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchPutMessage.html)API, i dati possono essere indirizzati all'argomento MQTT. AWS IoT Core
Questo approccio di migrazione sfrutta gli argomenti AWS IoT Core MQTT come punto di ingresso per i dati IoT, sostituendo l'input diretto a. AWS IoT Events Gli argomenti MQTT vengono scelti per diversi motivi principali. Offrono un'ampia compatibilità con i dispositivi IoT grazie all'uso diffuso di MQTT nel settore. Questi argomenti possono gestire elevati volumi di messaggi da numerosi dispositivi, garantendo la scalabilità. Offrono inoltre flessibilità nel routing e nel filtraggio dei messaggi in base al contenuto o al tipo di dispositivo. Inoltre, gli argomenti AWS IoT Core MQTT si integrano perfettamente con altri AWS servizi, facilitando il processo di migrazione.
I dati fluiscono da argomenti MQTT in un'architettura che combina Amazon Kinesis Data Streams, AWS Lambda una funzione, una tabella Amazon DynamoDB e pianificazioni Amazon. EventBridge Questa combinazione di servizi replica e migliora le funzionalità precedentemente fornite da AWS IoT Events, offrendoti maggiore flessibilità e controllo sulla pipeline di elaborazione dei dati IoT.
## Architetture a confronto
L' AWS IoT Events architettura attuale inserisce i dati tramite una AWS IoT Core regola e l'API. `BatchPutMessage` Questa architettura viene utilizzata AWS IoT Core per l'inserimento dei dati e la pubblicazione degli eventi, con i messaggi instradati attraverso AWS IoT Events gli input ai modelli di rilevatori che definiscono la logica di stato. Un ruolo IAM gestisce le autorizzazioni necessarie.
La nuova soluzione consente l'inserimento AWS IoT Core dei dati (ora con argomenti MQTT di input e output dedicati). Introduce Kinesis Data Streams per il partizionamento dei dati e una funzione Lambda di valutazione per la logica di stato. Gli stati dei dispositivi sono ora archiviati in una tabella DynamoDB e un ruolo IAM avanzato gestisce le autorizzazioni su questi servizi.
| Scopo | Soluzione | Differenze |
| --- | --- | --- |
| **Inserimento di dati**: riceve dati da dispositivi IoT | AWS IoT Core | Ora richiede due argomenti MQTT distinti: uno per l'acquisizione dei dati del dispositivo e un altro per la pubblicazione degli eventi di output |
| **Direzione dei messaggi**: indirizza i messaggi in arrivo ai servizi appropriati | AWS IoT Core regola di routing dei messaggi | Mantiene la stessa funzionalità di routing ma ora indirizza i messaggi a Kinesis Data Streams anziché AWS IoT Events |
| **Elaborazione dei dati**: gestisce e organizza i flussi di dati in entrata | Flussi di dati Kinesis | Sostituisce la funzionalità AWS IoT Events di input, fornendo l'inserimento dei dati con il partizionamento degli ID del dispositivo per l'elaborazione dei messaggi |
| **Valutazione logica**: elabora i cambiamenti di stato e attiva le azioni | Evaluator Lambda | Sostituisce il modello del AWS IoT Events rilevatore, fornendo una valutazione della logica di stato personalizzabile tramite codice anziché un flusso di lavoro visivo |
| **Gestione dello stato**: mantiene gli stati del dispositivo | DynamoDB tabella | Nuovo componente che fornisce l'archiviazione persistente degli stati del dispositivo, sostituendo la gestione interna AWS IoT Events dello stato |
| **Sicurezza**: gestisce le autorizzazioni di servizio | Ruolo IAM | Le autorizzazioni aggiornate ora includono l'accesso a Kinesis Data Streams, DynamoDB e, in aggiunta alle autorizzazioni esistenti EventBridge AWS IoT Core |
## Fase 1: Esporta le configurazioni del modello di rilevatore (facoltativo) AWS IoT Events
Prima di creare nuove risorse, esporta le definizioni del modello di AWS IoT Events rilevatore. Queste contengono la logica di elaborazione degli eventi e possono fungere da riferimento storico per l'implementazione della nuova soluzione.
------
#### [ Console ]
Utilizzando AWS IoT Events Console di gestione AWS, effettuate le seguenti operazioni per esportare le configurazioni del modello di rilevatore:
**Per esportare i modelli di rilevatori utilizzando il Console di gestione AWS**
1. Accedi alla [console AWS IoT Events](https://console.aws.amazon.com/iotevents/).
1. Nel riquadro di navigazione a sinistra, scegliere **Detector models (Modelli di rilevatore)**.
1. Selezionate il modello di rilevatore da esportare.
1. Scegli **Export** (Esporta). Leggete il messaggio informativo relativo all'output, quindi scegliete nuovamente **Esporta**.
1. Ripeti la procedura per ogni modello di rilevatore che desideri esportare.
Un file contenente un output JSON del modello di rilevatore viene aggiunto alla cartella di download del browser. Facoltativamente, è possibile salvare la configurazione di ogni modello di rilevatore per conservare i dati storici.
------
#### [ AWS CLI ]
Utilizzando AWS CLI, esegui i seguenti comandi per esportare le configurazioni del modello di rilevatore:
**Per esportare i modelli di rilevatori utilizzando AWS CLI**
1. Elenca tutti i modelli di rilevatori presenti nel tuo account:
```
aws iotevents list-detector-models
```
1. Per ogni modello di rilevatore, esporta la sua configurazione eseguendo:
```
aws iotevents describe-detector-model \
--detector-model-name your-detector-model-name
```
1. Salva l'output per ogni modello di rilevatore.
------
## Fase 2: creazione di un ruolo IAM
Crea un ruolo IAM per fornire le autorizzazioni per replicare la funzionalità di. AWS IoT Events Il ruolo in questo esempio concede l'accesso a DynamoDB per la gestione dello stato, per la pianificazione EventBridge, a Kinesis Data Streams per l'ingestione dei dati, per la pubblicazione di messaggi e per la registrazione. AWS IoT Core CloudWatch Insieme, questi servizi fungeranno da sostituto. AWS IoT Events
1. Creare un ruolo IAM con le seguenti autorizzazioni. Per istruzioni più dettagliate sulla creazione di un ruolo IAM, consulta [Creare un ruolo per delegare le autorizzazioni a un AWS servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella Guida per l'*utente 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. Aggiungi la seguente policy di fiducia per i ruoli IAM. Una policy di fiducia consente ai AWS servizi specificati di assumere il ruolo IAM in modo da poter eseguire le azioni necessarie. Per istruzioni più dettagliate sulla creazione di una policy di fiducia IAM, consulta [Create a role using custom trust policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html) nella *IAM User Guide*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"scheduler.amazonaws.com",
"lambda.amazonaws.com",
"iot.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Fase 3: creazione di Amazon Kinesis Data Streams
Crea Amazon Kinesis Data Streams Console di gestione AWS utilizzando o. AWS CLI
------
#### [ Console ]
Per creare un flusso di dati Kinesis utilizzando Console di gestione AWS, segui la procedura disponibile nella pagina [Crea un flusso di dati nella *Amazon Kinesis* Data Streams](https://docs.aws.amazon.com/streams/latest/dev/tutorial-stock-data-kplkcl-create-stream.html) Developer Guide.
Modifica il numero di frammenti in base al numero di dispositivi e alle dimensioni del payload dei messaggi.
------
#### [ AWS CLI ]
Utilizza AWS CLI, crea Amazon Kinesis Data Streams per importare e partizionare i dati dai tuoi dispositivi.
I Kinesis Data Streams vengono utilizzati in questa migrazione per sostituire la funzionalità di inserimento dei dati di. AWS IoT Events Fornisce un modo scalabile ed efficiente per raccogliere, elaborare e analizzare i dati di streaming in tempo reale dai dispositivi IoT, fornendo al contempo una gestione flessibile dei dati e l'integrazione con altri AWS servizi.
```
aws kinesis create-stream --stream-name your-kinesis-stream-name --shard-count 4 --region your-region
```
Regola il numero di frammenti in base al numero di dispositivi e alle dimensioni del payload dei messaggi.
------
## Fase 4: Creare o aggiornare la regola di routing dei messaggi MQTT
È possibile creare una nuova regola di routing dei messaggi MQTT o aggiornare una regola esistente.
------
#### [ Console ]
1. Determina se hai bisogno di una nuova regola di routing dei messaggi MQTT o se puoi aggiornare una regola esistente.
1. Apri la [AWS IoT Core console](https://console.aws.amazon.com/iot/).
1. **Nel riquadro di navigazione, scegli **Routing dei messaggi**, quindi scegli Regole.**
1. **Nella sezione **Gestisci**, scegli **Routing dei messaggi**, quindi Regole.**
1. Scegli **Crea regola**.
1. Nella pagina **Specificare le proprietà della regola**, inserisci il nome della AWS IoT Core regola per **Nome regola**. Per **Descrizione della regola, *facoltativo*, inserisci una descrizione per identificare che stai elaborando gli eventi e li inoltriamo a Kinesis Data Streams**.
1. **Nella pagina **Configura l'istruzione SQL**, inserisci quanto segue per l'**istruzione SQL**:**SELECT \$1 FROM 'your-database'**, quindi scegli Avanti.**
1. Nella pagina **Allega regole e in Azioni** **sulle regole**, scegli **kinesis**.
1. Scegli il tuo stream Kinesis per lo streaming. Per la chiave di partizione, inserire **your-instance-id**. Seleziona il ruolo appropriato per il ruolo IAM, quindi scegli **Aggiungi azione alla regola**.
Per ulteriori informazioni, consulta [Creazione di regole AWS IoT per indirizzare i dati dei dispositivi ad altri servizi](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules-tutorial.html).
------
#### [ AWS CLI ]
1. Crea un file JSON con i seguenti contenuti. Questo file di configurazione JSON definisce una AWS IoT Core regola che seleziona tutti i messaggi da un argomento e li inoltra al flusso Kinesis specificato, utilizzando l'ID dell'istanza come chiave di partizione.
```
{
"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. Crea la regola dell'argomento MQTT utilizzando. AWS CLI Questo passaggio utilizza la AWS CLI per creare una regola AWS IoT Core tematica utilizzando la configurazione definita nel `events_rule.json` file.
```
aws iot create-topic-rule \
--rule-name "your-iot-core-rule" \
--topic-rule-payload file://your-file-name.json
```
------
## Fase 5: Ottenere l'endpoint per l'argomento MQTT di destinazione
Utilizzate l'argomento MQTT di destinazione per configurare dove i vostri argomenti pubblicano i messaggi in uscita, sostituendo la funzionalità precedentemente gestita da. AWS IoT Events L'endpoint è unico per il tuo account e la tua regione AWS .
------
#### [ Console ]
1. Apri la [AWS IoT Core console](https://console.aws.amazon.com/iot/).
1. Nella sezione **Connect** del pannello di navigazione a sinistra, scegli **Configurazione del dominio**.
1. Scegli la configurazione del dominio **IoT:Data-ATS** per aprire la pagina dei dettagli della configurazione.
1. **Copia il valore del nome di dominio.** Questo valore è l'endpoint. Salva il valore dell'endpoint perché ti servirà nei passaggi successivi.
------
#### [ AWS CLI ]
Esegui il comando seguente per ottenere l' AWS IoT Core endpoint per la pubblicazione dei messaggi in uscita per il tuo account.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS --region your-region
```
------
## Fase 6: creare una tabella Amazon DynamoDB
Una tabella Amazon DynamoDB sostituisce la funzionalità AWS IoT Events di gestione dello stato di, fornendo un modo scalabile e flessibile per persistere e gestire lo stato dei dispositivi e la logica del modello di rilevamento nella nuova architettura della soluzione.
------
#### [ Console ]
Crea una tabella Amazon DynamoDB per mantenere lo stato dei modelli di rilevatori. Per ulteriori informazioni, consulta [Creare una tabella in DynamoDB nella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html) Amazon DynamoDB Developer *Guide*.
Usa quanto segue per i dettagli della tabella:
+ Per **Nome tabella**, inserisci un nome di tabella a tua scelta.
+ Per la **chiave di partizione**, inserisci il tuo ID di istanza.
+ È possibile utilizzare le **impostazioni predefinite per le impostazioni** della **tabella**
------
#### [ AWS CLI ]
Esegui il comando seguente per creare una tabella 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 \
```
------
## Fase 7: Creare una AWS Lambda funzione (console)
La funzione Lambda funge da motore di elaborazione principale, sostituendo la logica di valutazione del modello di rilevatore di. AWS IoT Events Nell'esempio, ci integriamo con altri AWS servizi per gestire i dati in entrata, gestire lo stato e attivare azioni in base alle regole definite dall'utente.
Crea una funzione Lambda con NodeJS runtime. Usa il seguente frammento di codice, sostituendo le costanti codificate:
1. Apri la [AWS Lambda console](https://console.aws.amazon.com/lambda/).
1. Scegli **Crea funzione**.
1. **Immettete un nome per il nome della funzione.**
1. **Seleziona **NodeJS** 22.x come Runtime.**
1. Nel menu a discesa **Modifica ruolo di esecuzione predefinito**, scegli **Usa ruolo esistente**, quindi seleziona il ruolo IAM creato nei passaggi precedenti.
1. Scegli **Crea funzione**.
1. Incolla il seguente frammento di codice dopo aver sostituito le costanti codificate.
1. Dopo la creazione della funzione, nella scheda **Codice**, incolla il seguente esempio di codice, sostituendo l'**your-destination-endpoint**endpoint con il tuo.
```
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
]
);
```
## Fase 8: aggiungere un trigger Amazon Kinesis Data Streams
Aggiungi un trigger Kinesis Data Streams alla funzione Lambda utilizzando o. Console di gestione AWS AWS CLI
L'aggiunta di un trigger Kinesis Data Streams alla funzione Lambda stabilisce la connessione tra la pipeline di inserimento dei dati e la logica di elaborazione, consentendole di valutare automaticamente i flussi di dati IoT in entrata e reagire agli eventi in tempo reale, in modo simile a come elabora gli input. AWS IoT Events
------
#### [ Console ]
*Per ulteriori informazioni, consulta [Creare una mappatura dell'origine degli eventi per richiamare una funzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/services-kinesis-create.html#services-kinesis-eventsourcemapping) nella Guida per gli sviluppatori.AWS Lambda *
Utilizzate quanto segue per i dettagli della mappatura delle sorgenti degli eventi:
+ Per **il nome della funzione**, inserisci il nome lambda utilizzato in. [Fase 7: Creare una AWS Lambda funzione (console)](#eos-detector-model-create-lambda-function)
+ Per **Consumer: facoltativo**, inserisci l'ARN per il tuo stream Kinesis.
+ Per **Dimensioni del batch**, immetti **10**.
------
#### [ AWS CLI ]
Esegui il comando seguente per creare il trigger della funzione 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
```
------
## Fase 9: Verificare la funzionalità di inserimento e output dei dati ()AWS CLI
Pubblicate un payload sull'argomento MQTT in base a ciò che avete definito nel modello del rilevatore. Di seguito è riportato un esempio di payload relativo all'argomento `your-topic-name` MQTT per testare un'implementazione.
```
{
"instanceId": "your-instance-id",
"payload": "{\"temperature\":78}"
}
```
Dovresti vedere un messaggio MQTT pubblicato su un argomento con il seguente contenuto (o simile):
```
{
"state": "alarm detected, timer started"
}
```
# Procedura di migrazione per gli AWS IoT SiteWise allarmi in AWS IoT Events
Questa sezione descrive soluzioni alternative che offrono funzionalità di allarme simili a quelle in cui ci si allontana. AWS IoT Events
Per AWS IoT SiteWise le proprietà che utilizzano AWS IoT Events allarmi, è possibile migrare a una soluzione che utilizza gli allarmi. CloudWatch Questo approccio offre solide funzionalità di monitoraggio con funzionalità consolidate SLAs e aggiuntive come il rilevamento delle anomalie e gli allarmi raggruppati.
## Architetture a confronto
*L'attuale configurazione degli AWS IoT Events allarmi per AWS IoT SiteWise le proprietà richiede la creazione `AssetModelCompositeModels` nel modello di asset, come descritto in [Definizione degli allarmi esterni AWS IoT SiteWise nella Guida](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/define-external-alarms.html) per l'AWS IoT SiteWise utente.* Le modifiche alla nuova soluzione vengono in genere gestite tramite la AWS IoT Events console.
La nuova soluzione fornisce la gestione degli allarmi CloudWatch sfruttando gli allarmi. Questo approccio utilizza AWS IoT SiteWise le notifiche per pubblicare punti dati di proprietà su argomenti AWS IoT Core MQTT, che vengono poi elaborati da una funzione Lambda. La funzione trasforma queste notifiche in CloudWatch metriche, abilitando il monitoraggio degli allarmi attraverso CloudWatch la struttura di allarme.
| Scopo | Soluzione | Differenze |
| --- | --- | --- |
| **Fonte dati: dati sulla proprietà** da AWS IoT SiteWise | AWS IoT SiteWise Notifiche MQTT | Sostituisce l'integrazione diretta di IoT Events con le notifiche MQTT delle proprietà AWS IoT SiteWise |
| **Elaborazione dei dati**: trasforma i dati delle proprietà | funzione Lambda | Elabora le notifiche sulle AWS IoT SiteWise proprietà e le converte in metriche CloudWatch |
| **Valutazione degli allarmi**: monitora le metriche e attiva gli allarmi | CloudWatch Allarmi Amazon | Sostituisce gli AWS IoT Events allarmi con gli CloudWatch allarmi, offrendo funzionalità aggiuntive come il rilevamento delle anomalie |
| **Integrazione: connessione con** AWS IoT SiteWise | AWS IoT SiteWise allarmi esterni | Capacità opzionale di reimportare gli CloudWatch allarmi AWS IoT SiteWise come allarmi esterni |
## Fase 1: Abilitare le notifiche MQTT sulla proprietà dell'asset
Se utilizzi AWS IoT Events integrazioni per gli AWS IoT SiteWise allarmi, puoi attivare le notifiche MQTT per ogni proprietà da monitorare.
1. Segui la AWS IoT SiteWise procedura [Configura gli allarmi sugli asset](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-alarms.html#configure-alarm-threshold-value-console) fino a completare il passaggio per **modificare le proprietà del modello** di asset.
1. **Per ogni proprietà da migrare, impostate **lo stato di notifica MQTT su ATTIVO**.**
![\[Una schermata che mostra la posizione del menu a discesa dello stato delle notifiche MQTT nella console. AWS IoT SiteWise\]](http://docs.aws.amazon.com/it_it/iotevents/latest/developerguide/images/events-eos-sw-asset-mqtt.png)
1. Nota il percorso dell'argomento in cui viene pubblicato l'avviso per ogni attributo di allarme modificato.
Per ulteriori informazioni, consulta le seguenti risorse di documentazione:
+ [Comprendete le proprietà degli asset negli argomenti MQTT](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/mqtt-topics.html) della *Guida per l'AWS IoT SiteWise utente*.
+ [Argomenti MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/topics.html) nella Guida per gli *AWS IoT sviluppatori*.
## Fase 2: Creare una funzione AWS Lambda
Crea una funzione Lambda per leggere l'array TQV pubblicato dall'argomento MQTT e pubblica i singoli valori su. CloudWatch Useremo questa funzione Lambda come azione di destinazione da attivare in AWS IoT Core Message Rules.
1. Apri la [AWS Lambda console](https://console.aws.amazon.com/lambda).
1. Scegli **Crea funzione**.
1. Inserisci un nome per il **nome della funzione**.
1. **Seleziona **NodeJS** 22.x come Runtime.**
1. Nel menu a discesa **Modifica ruolo di esecuzione predefinito**, scegli **Usa ruolo esistente**, quindi seleziona il ruolo IAM creato nei passaggi precedenti.
**Nota**
Questa procedura presuppone che tu abbia già migrato il tuo modello di rilevatore. Se non hai un ruolo IAM, consulta. [](eos-procedure-detector-models.md#eos-detector-model-create-iam-role)
1. Scegli **Crea funzione**.
1. Incolla il seguente frammento di codice dopo aver sostituito le costanti codificate.
```
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)}')
}
```
## Passaggio 3: Creare una regola di routing dei messaggi AWS IoT Core
+ Segui il [tutorial: Ripubblicazione di una procedura di messaggio MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-repub-rule.html) inserendo le seguenti informazioni quando richiesto:
1. Assegna un nome alla regola di routing dei messaggi. `SiteWiseToCloudwatchAlarms`
1. Per la query, è possibile utilizzare quanto segue:
```
SELECT * FROM '$aws/sitewise/asset-models/your-asset-model-id/assets/your-asset-id/properties/your-property-id'
```
1. In **Azioni delle regole**, seleziona l'azione **Lambda da** cui inviare i dati generati a AWS IoT SiteWise . CloudWatch Esempio:
![\[Una schermata che mostra l'azione della regola per la funzione Lambda.\]](http://docs.aws.amazon.com/it_it/iotevents/latest/developerguide/images/events-eos-lambda-rule-action.png)
## Fase 4: Visualizza le metriche CloudWatch
Man mano che si inseriscono i dati AWS IoT SiteWise, la proprietà selezionata in precedenza[Fase 1: Abilitare le notifiche MQTT sulla proprietà dell'asset](#eos-alarms-mqtt-asset-property), li indirizza alla funzione Lambda in cui li abbiamo creati. [Fase 2: Creare una funzione AWS Lambda](#eos-alarms-lambda-function) In questo passaggio, puoi verificare se Lambda invia le tue metriche a. CloudWatch
1. Apri [CloudWatch di Console di gestione AWS](https://console.aws.amazon.com/cloudwatch/).
1. **Nella barra di navigazione a sinistra, scegli **Metriche, quindi Tutte le metriche**.**
1. Scegli l'URL di un avviso per aprirlo.
1. Nella scheda **Sorgente**, l' CloudWatch output è simile a quello di questo esempio. Queste informazioni sulla fonte confermano che i dati metrici vengono inseriti 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"
}
```
## Fase 5: Creare allarmi CloudWatch
Segui la procedura [Crea un CloudWatch allarme basato su una soglia statica](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) nella *Amazon CloudWatch User Guide* per creare allarmi per ogni metrica pertinente.
**Nota**
Esistono molte opzioni per la configurazione degli allarmi in Amazon. CloudWatch Per ulteriori informazioni sugli CloudWatch allarmi, consulta [Using Amazon CloudWatch alarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) nella *Amazon CloudWatch User* Guide.
## Passaggio 6: (Facoltativo) importa l'allarme in CloudWatch AWS IoT SiteWise
Puoi configurare gli CloudWatch allarmi a cui inviare i dati AWS IoT SiteWise utilizzando azioni di CloudWatch allarme e Lambda. Questa integrazione consente di visualizzare gli stati e le proprietà degli allarmi nel portale SiteWise Monitor.
1. Configura l'allarme esterno come proprietà in un modello di asset. Per ulteriori informazioni, consulta [Definire gli allarmi esterni AWS IoT SiteWise nella](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/define-external-alarms.html) *Guida per l'AWS IoT SiteWise utente*.
1. Crea una funzione Lambda che utilizzi l'[BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html)API disponibile nella *Guida per l'AWS IoT SiteWise utente* a cui inviare i dati di allarme. AWS IoT SiteWise
1. Imposta le azioni di CloudWatch allarme per richiamare la funzione Lambda quando lo stato dell'allarme cambia. Per ulteriori informazioni, consulta la sezione [Azioni di allarme](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-and-actions.html) nella *Amazon CloudWatch User Guide*.