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à.
# Creazione di AWS IoT regole per indirizzare i dati del dispositivo ad altri servizi
Questi tutorial mostrano come creare e testare AWS IoT regole utilizzando alcune delle azioni più comuni.
AWS IoT le regole inviano dati dai dispositivi ad altri AWS servizi. Ascoltano messaggi MQTT specifici, formattano i dati nei payload dei messaggi e inviano il risultato ad altri servizi AWS .
Ti suggeriamo di provarli nell'ordine in cui vengono mostrati qui, anche se il tuo obiettivo è creare una regola che utilizzi una funzione Lambda o qualcosa di più complesso. I tutorial sono presentati in ordine dal più semplice al più complesso. Presentano nuovi concetti in modo incrementale per aiutarti ad apprendere i concetti che è possibile utilizzare per creare le operazioni delle regole che non dispongono di un tutorial specifico.
**Nota**
AWS IoT le regole ti aiutano a inviare i dati dai tuoi dispositivi IoT ad altri AWS servizi. Per farlo correttamente, tuttavia, è necessaria una conoscenza operativa degli altri servizi in cui si desidera inviare i dati. Sebbene questi tutorial forniscano le informazioni necessarie per completare le attività, potrebbe essere utile ottenere ulteriori informazioni sui servizi a cui si desidera inviare i dati prima di utilizzarli nella soluzione. Una spiegazione dettagliata degli altri AWS servizi non rientra nell'ambito di questi tutorial.
**Panoramica dello scenario tutorial**
Lo scenario di questi tutorial consiste in un dispositivo con sensore meteo che pubblica periodicamente i suoi dati. In questo sistema immaginario sono presenti molti dispositivi sensori di questo tipo. I tutorial in questa sezione, tuttavia, si concentrano su un singolo dispositivo mentre mostrano come è possibile ospitare più sensori.
I tutorial di questa sezione mostrano come utilizzare AWS IoT le regole per eseguire le seguenti attività con questo sistema immaginario di dispositivi con sensori meteorologici.
+
**[Tutorial: ripubblicazione di un messaggio MQTT](iot-repub-rule.md)**
Questo tutorial mostra come ripubblicare un messaggio MQTT ricevuto dai sensori meteorologici come messaggio contenente solo l'ID del sensore e il valore della temperatura. Utilizza solo i servizi AWS IoT Core e dimostra una semplice query SQL e come utilizzare il client MQTT per testare la regola.
+
**[Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md)**
Questo tutorial mostra come inviare un messaggio SNS quando un valore di un dispositivo con sensore meteorologico supera un valore specifico. Si basa sui concetti presentati nel tutorial precedente e spiega come lavorare con un altro AWS servizio, [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html) (Amazon SNS).
Se non hai mai utilizzato Amazon SNS, consulta le [Nozioni di base](https://docs.aws.amazon.com//sns/latest/dg/sns-getting-started.html) prima di iniziare questo tutorial.
+
**[Tutorial: Archiviazione dei dati del dispositivo in una tabella DynamoDB](iot-ddb-rule.md)**
Questo tutorial mostra come memorizzare i dati dai dispositivi con sensori meteorologici in una tabella di database. Utilizza l'istruzione di query della regola e i modelli di sostituzione per formattare i dati dei messaggi per il servizio di destinazione [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html).
Se non hai mai usato DynamoDB, consulta le [Nozioni di base](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) prima di iniziare questo tutorial.
+
**[Tutorial: Formattazione di una notifica utilizzando una funzione AWS Lambda](iot-lambda-rule.md)**
Questo tutorial mostra come chiamare una funzione Lambda per riformattare i dati del dispositivo e quindi inviarli come messaggio di testo. Aggiunge uno script Python e funzioni AWS SDK in una [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)funzione per formattare con i dati del payload del messaggio dai dispositivi dei sensori meteorologici e inviare un messaggio di testo.
Se non hai mai usato Lambda, consulta le [Nozioni di base](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) prima di iniziare questo tutorial.
**AWS IoT panoramica delle regole**
Tutti questi tutorial creano AWS IoT regole.
Per inviare i dati da un dispositivo a un altro AWS servizio, una AWS IoT regola utilizza:
+ Un'istruzione di query della regola costituita da:
+ Una clausola SQL SELECT che seleziona e formatta i dati dal payload del messaggio
+ Un filtro argomento (l'oggetto FROM nell'istruzione query della regola) che identifica i messaggi da utilizzare
+ Un'istruzione condizionale facoltativa (una clausola SQL WHERE) che specifica condizioni specifiche su cui agire
+ Almeno un'operazione della regola
I dispositivi pubblicano i messaggi MQTT negli argomenti. Il filtro argomento nell'istruzione SQL SELECT identifica gli argomenti MQTT a cui applicare la regola. I campi specificati nell'istruzione SQL SELECT formattano i dati del payload dei messaggi MQTT in arrivo per l'utilizzo da parte delle azioni della regola. Per un elenco completo delle operazioni delle regole, consulta [Operazioni delle regole AWS IoT](iot-rule-actions.md).
**Topics**
+ [Tutorial: ripubblicazione di un messaggio MQTT](iot-repub-rule.md)
+ [Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md)
+ [Tutorial: Archiviazione dei dati del dispositivo in una tabella DynamoDB](iot-ddb-rule.md)
+ [Tutorial: Formattazione di una notifica utilizzando una funzione AWS Lambda](iot-lambda-rule.md)
# Tutorial: ripubblicazione di un messaggio MQTT
Questo tutorial dimostra come creare una AWS IoT regola che pubblichi un messaggio MQTT quando viene ricevuto un messaggio MQTT specificato. Il payload del messaggio in arrivo può essere modificato dalla regola prima della pubblicazione. In questo modo è possibile creare messaggi su misura per applicazioni specifiche senza la necessità di modificare il dispositivo o il firmware. È inoltre possibile utilizzare l'aspetto filtrante di una regola per pubblicare messaggi solo quando viene soddisfatta una condizione specifica.
I messaggi ripubblicati in base a una regola agiscono come messaggi inviati da qualsiasi altro dispositivo o client. AWS IoT I dispositivi possono sottoscrivere i messaggi ripubblicati nello stesso modo in cui possono iscriversi a qualsiasi altro argomento del messaggio MQTT.
**Cosa imparerai in questo tutorial:**
+ Come utilizzare semplici query SQL e funzioni in un'istruzione di query della regola
+ Come usare il client MQTT per testare una regola AWS IoT
Questo tutorial dura circa 30 minuti.
**Topics**
+ [Consulta gli argomenti e AWS IoT le regole di MQTT](#iot-repub-rule-mqtt)
+ [Fase 1: Creare una AWS IoT regola per ripubblicare un messaggio MQTT](#iot-repub-rule-define)
+ [Fase 2. Test della nuova regola](#iot-repub-rule-test)
+ [Fase 3: Esamina i risultati e i passaggi successivi](#iot-repub-rule-review)
**Prima di iniziare questo tutorial, assicurati di disporre di:**
+
**[Configurare Account AWS](setting-up.md)**
Avrai bisogno della tua Account AWS AWS IoT console per completare questo tutorial.
+
**Aver rivisto [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md)**
Assicurati di poter usare il client MQTT per sottoscrivere e pubblicare un argomento. Utilizzerai il client MQTT per testare la nuova regola in questa procedura.
## Consulta gli argomenti e AWS IoT le regole di MQTT
Prima di parlare AWS IoT delle regole, è utile comprendere il protocollo MQTT. Nelle soluzioni IoT, il protocollo MQTT offre alcuni vantaggi rispetto ad altri protocolli di comunicazione di rete, come HTTP, così da renderlo una scelta popolare per l'uso da parte dei dispositivi IoT. Questa sezione esamina gli aspetti chiave di MQTT applicati a questo tutorial. Per informazioni sul confronto tra MQTT e HTTP, consulta [Scelta di un protocollo applicativo per la comunicazione del dispositivo](protocols.md#protocol-selection).
**Protocollo MQTT**
Il protocollo MQTT utilizza un modello di publish/subscribe comunicazione con il suo host. Per inviare dati, i dispositivi pubblicano messaggi identificati da argomenti nel broker di AWS IoT messaggi. Per ricevere messaggi dal broker di messaggi, i dispositivi sottoscrivono gli argomenti che riceveranno inviando al broker messaggi filtri argomento nelle richieste di sottoscrizione. Il motore di regole AWS IoT riceve i messaggi MQTT dal broker di messaggi.
**AWS IoT regole**
AWS IoT le regole sono costituite da un'istruzione di interrogazione delle regole e da una o più azioni relative alle regole. Quando il motore di regole AWS IoT riceve un messaggio MQTT, questi elementi agiscono sul messaggio come segue.
+
**Istruzione query della regola**
L'istruzione query della regola descrive gli argomenti MQTT da utilizzare, interpreta i dati del payload del messaggio e formatta i dati come descritto da un'istruzione SQL simile alle istruzioni utilizzate dai database SQL più diffusi. Il risultato dell'istruzione della query sono i dati inviati alle azioni della regola.
+
**Operazione delle regole**
Ogni azione contenuta in una regola agisce sui dati risultanti dall'istruzione di interrogazione della regola. AWS IoT supporta [molte azioni relative alle regole](iot-rule-actions.md). In questo tutorial, tuttavia, ti concentrerai sull’operazione della regola [Ripubblica](republish-rule-action.md), che pubblica il risultato dell'istruzione query come messaggio MQTT con un argomento specifico.
## Fase 1: Creare una AWS IoT regola per ripubblicare un messaggio MQTT
La AWS IoT regola che creerai in questo tutorial riguarda gli argomenti `device/device_id/data` MQTT dove si *device\$1id* trova l'ID del dispositivo che ha inviato il messaggio. Questi argomenti sono descritti da un [filtro argomenti](topics.md#topicfilters) come `device/+/data`, dove `+` è un carattere jolly che corrisponde a qualsiasi stringa tra i due caratteri di barra in avanti.
Quando la regola riceve un messaggio da un argomento corrispondente, estrae i valori `device_id` e `temperature` e li ripubblica come nuovo messaggio MQTT con l’argomento `device/data/temp`.
Ad esempio, il payload di un messaggio MQTT con l’argomento `device/22/data` è simile a questo:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
La regola prende il valore `temperature` dal payload del messaggio e il valore `device_id` dall'argomento e li ripubblica come messaggio MQTT con l’argomento `device/data/temp` e un payload del messaggio simile al seguente:
```
{
"device_id": "22",
"temperature": 28
}
```
Con questa regola, i dispositivi che richiedono solo l'ID del dispositivo e i dati di temperatura si sottoscrivono all’argomento `device/data/temp` per ricevere solo tali informazioni.
**Creazione di una regola che ripubblica un messaggio MQTT**
1. Apri [l'hub **Rules** della AWS IoT console](https://console.aws.amazon.com//iot/home#/rulehub).
1. In **Rules (Regole)**, scegli **Create (Crea)** e inizia a creare la nuova regola.
1. Nella parte superiore di **Create a rule (Crea una regola)**:
1. In **Name (Nome)**, inserisci il nome della regola. Per questo tutorial, rinominala **republish\$1temp**.
Ricorda che un nome di regola deve essere univoco all'interno dell’account e della regione e che non può contenere spazi. Abbiamo usato un carattere di sottolineatura in questo nome per separare le due parole nel nome della regola.
1. In **Description (Descrizione)**, descrivi la regola.
Una descrizione significativa ti aiuta a ricordare cosa fa questa regola e perché l'hai creata. La descrizione può essere lunga quanto necessario, quindi sii il più dettagliato possibile.
1. In **Rule query statement (Istruzione query regola)** di **Create a rule (Crea una regola)**:
1. In **Using SQL version (Uso della versione SQL)**, seleziona **2016-03-23**.
1. Nella casella di modifica **Rule query statement (Istruzione query regola)**, inserisci l'istruzione:
```
SELECT topic(2) as device_id, temperature FROM 'device/+/data'
```
Questa istruzione:
+ Ascolta i messaggi MQTT con un argomento che corrisponde al filtro argomenti `device/+/data`.
+ Seleziona il secondo elemento dalla stringa dell'argomento e lo assegna al campo `device_id`.
+ Seleziona il valore del campo `temperature` dal payload del messaggio e lo assegna al campo `temperature`.
1. In **Set one or more actions (Imposta una o più operazioni)**:
1. Per aprire l'elenco delle azioni della regola per questa regola, scegli **Add action (Aggiungi operazione)**.
1. In **Seleziona un'azione**, scegli **Ripubblica un messaggio su un AWS IoT argomento**.
1. Nella parte inferiore dell'elenco delle azioni, scegli **Configure action (Configura operazione)** per aprire la pagina di configurazione dell'azione selezionata.
1. In **Configure action (Configura operazione)**:
1. In **Topic (Argomento)**, inserisci **device/data/temp**. Questo è l'argomento MQTT del messaggio che questa regola pubblicherà.
1. In **Quality of Service (Qualità del servizio)**, scegli **0 - Il messaggio viene recapitato zero o più volte**.
1. In **Scegli o crea un ruolo a cui concedere AWS IoT l'accesso per eseguire questa azione**:
1. Selezionare **Crea ruolo**. Si aprirà la finestra di dialogo **Create a new role (Crea un nuovo ruolo)**.
1. Inserisci un nome che descrive il nuovo ruolo. In questo tutorial, utilizza **republish\$1role**.
Quando si crea un nuovo ruolo, le policy corrette per eseguire l'operazione della regola vengono create e associate al nuovo ruolo. Se si modifica l'argomento dell'operazione della regola o si utilizza questo ruolo in un'altra operazione della regola, è necessario aggiornare la policy per tale ruolo per autorizzare il nuovo argomento o operazione. Per aggiornare un ruolo esistente, scegli **Update role (Aggiorna ruolo)** in questa sezione.
1. Scegli **Create role (Crea ruolo)** per creare il ruolo e chiudere la finestra di dialogo.
1. Scegli **Add action (Aggiungi operazione)** per aggiungere l'operazione alla regola e tornare alla pagina **Create a rule (Crea una regola)**.
1. L'azione **Ripubblica un messaggio su un AWS IoT argomento** è ora elencata in **Imposta una o più azioni**.
Nel titolo della nuova azione, sotto **Republish a message to an AWS IoT topic (Ripubblicazione di un messaggio in un argomento di Amazon IoT)**, è possibile visualizzare l'argomento in cui verrà pubblicata l'operazione di ripubblicazione.
Questa è l'unica operazione della regola che aggiungerai a questa regola.
1. In **Create a rule (Crea una regola)**, scorri verso il basso e seleziona **Create rule (Crea regola)** per creare la regola e completare questo passaggio.
## Fase 2. Test della nuova regola
Per testare la nuova regola, utilizza il client MQTT per pubblicare e sottoscrivere i messaggi MQTT utilizzati da questa regola.
Apri il [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test) in una nuova finestra. In questo modo è possibile modificare la regola senza perdere la configurazione del client MQTT. Il client MQTT non conserva sottoscrizioni o registri dei messaggi se si lascia per andare a un'altra pagina della console.
**Utilizzare il client MQTT per testare la regola**
1. Nel [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test), effettua la sottoscrizione agli argomenti di input, in questo caso, `device/+/data`.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)** scegli **Subscribe to a topic (Effettua la sottoscrizione a un argomento)**.
1. In **Subscription topic (Argomento sottoscrizione)**, inserisci l'argomento del filtro dell’argomento di input, **device/\$1/data**.
1. Lascia gli altri campi ai valori predefiniti.
1. Scegli **Subscribe to topic (Effettua sottoscrizione all'argomento)**.
Nella colonna **Subscriptions (Sottoscrizioni)**, sotto **Publish to a topic (Pubblicaz in un argomento)**, viene visualizzato **device/\$1/data**.
1. Effettua la sottoscrizione all'argomento che verrà pubblicato dalla regola: `device/data/temp`.
1. Sotto **Subscriptions (Sottoscrizioni)**, scegli di nuovo **Subscribe to a topic (Sottoscrizione a un argomento)**, e in **Subscription topic (Argomento sottoscrizione)** inserisci l'argomento del messaggio ripubblicato, **device/data/temp**.
1. Lascia gli altri campi ai valori predefiniti.
1. Scegli **Subscribe to topic (Effettua sottoscrizione all'argomento)**.
Nella colonna **Subscriptions (Sottoscrizioni)**, sotto **device/\$1/data (dispositivo/\$1/dati)**, **device/data/temp** viene visualizzato.
1. Pubblicazione di un messaggio nell'argomento di input con un ID dispositivo specifico, **device/22/data**. Non è possibile pubblicare su argomenti MQTT che contengono caratteri jolly.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)** scegli **Publish to topic (Pubblica in un argomento)**.
1. Nel campo **Publish (Pubblica)**, inserisci il nome dell'argomento di input, **device/22/data**.
1. Copia i dati di esempio mostrati qui e, nella casella di modifica sotto il nome dell'argomento, incolla i dati di esempio.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Per inviare il messaggio MQTT, scegli **Publish to topic (Pubblica in un argomento)**.
1. Esamina i messaggi che sono stati inviati.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, accanto ai due argomenti a cui hai effettuato la sottoscrizione in precedenza, è presente un punto verde.
I punti verdi indicano che uno o più nuovi messaggi sono stati ricevuti dall'ultima volta che li hai guardati.
1. Sotto **Subscriptions (Sottoscrizioni)**, scegli **device/\$1/data (dispositivo/\$1/dati)** per verificare che il payload del messaggio corrisponda a quello che hai appena pubblicato e assomigli a questo:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. In **Abbonamenti**, scegli di **device/data/temp**verificare che il payload del messaggio ripubblicato abbia il seguente aspetto:
```
{
"device_id": "22",
"temperature": 28
}
```
Nota che il valore `device_id` è una stringa tra virgolette e il valore `temperature` è numerico. Questo perché la funzione [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) ha estratto la stringa dal nome dell'argomento del messaggio di input mentre il valore `temperature` utilizza il valore numerico dal payload del messaggio di input.
Se desideri rendere il valore `device_id` un valore numerico, sostituisci `topic(2)`nell'istruzione query della regola con:
```
cast(topic(2) AS DECIMAL)
```
Nota che la trasformazione del valore `topic(2)` in un valore numerico funzionerà solo se la parte dell'argomento contiene solo caratteri numerici.
1. Se vedi che sull'**device/data/temp**argomento è stato pubblicato il messaggio corretto, allora la tua regola ha funzionato. Scopri di più sull'azione Ripubblica regola nella sezione successiva.
Se non vedi che il messaggio corretto è stato pubblicato sul **dispositivo/\$1/data** o **device/data/temp**sugli argomenti, consulta i suggerimenti per la risoluzione dei problemi.
### Risoluzione dei problemi della regola di ripubblicazione dei messaggi
Ecco alcune cose da controllare nel caso in cui non vedi i risultati che ti aspetti.
+
**Hai un banner di errore**
Se viene visualizzato un errore quando è stato pubblicato il messaggio di input, correggilo prima. I seguenti passaggi potrebbero aiutarti a correggere l'errore.
+
**Il messaggio di input non viene visualizzato nel client MQTT**
Ogni volta che pubblichi il messaggio di input nell’argomento `device/22/data`, tale messaggio dovrebbe essere visualizzato nel client MQTT se hai effettuato la sottoscrizione al filtro argomento `device/+/data` come descritto nella procedura.
**Controlli**
+
**Controlla il filtro degli argomenti a cui hai effettuato la sottoscrizione**
Se hai effettuato la sottoscrizione all'argomento del messaggio di input come descritto nella procedura, visualizzerai una copia del messaggio di input ogni volta che lo pubblichi.
Se il messaggio non viene visualizzato, controlla il nome dell'argomento sottoscritto e confrontalo con l'argomento in cui è stato pubblicato. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento a cui è stato sottoscritto deve essere identico all'argomento in cui hai pubblicato il payload dei messaggi.
+
**Controlla la funzione di pubblicazione dei messaggi**
Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, scegli **device/\$1/data (dispositivo/\$1/dati)**, controlla l'argomento del messaggio di pubblicazione e quindi scegli **Publish to topic (Pubblica in un argomento)**. Dovresti vedere il payload del messaggio dalla casella di modifica sotto l'argomento visualizzato nell'elenco dei messaggi.
+
**Il messaggio ripubblicato non viene visualizzato nel client MQTT**
Affinché la regola funzioni, deve disporre della policy corretta che la autorizzi a ricevere e ripubblicare un messaggio e deve ricevere il messaggio.
**Controlli**
+
**Controlla il Regione AWS tuo client MQTT e la regola che hai creato**
La console in cui si esegue il client MQTT deve trovarsi nella stessa regione AWS della regola creata.
+
**Controlla l'argomento del messaggio di input nell'istruzione query della regola**
Affinché la regola funzioni, è necessario che venga visualizzato un messaggio con il nome dell'argomento corrispondente al filtro dell’argomento nella clausola FROM dell'istruzione query della regola.
Controlla l'ortografia del filtro argomento nell'istruzione query regola con quella dell'argomento nel client MQTT. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento del messaggio deve corrispondere al filtro argomento nell'istruzione query della regola.
+
**Controllare il contenuto del payload del messaggio di input**
Affinché la regola funzioni, è necessario trovare il campo dati nel payload del messaggio dichiarato nell'istruzione SELECT.
Controlla l'ortografia del campo `temperature` nell'istruzione query della regola con quella del payload del messaggio nel client MQTT. I nomi dei campi fanno distinzione tra maiuscole e minuscole e il campo `temperature`nell'istruzione query della regola deve essere identico a quello del campo `temperature` nel payload del messaggio.
Assicurati che il documento JSON nel payload del messaggio sia formattato correttamente. Se il JSON presenta errori, come una virgola mancante, la regola non sarà in grado di leggerlo.
+
**Controlla l'argomento del messaggio ripubblicato nell'operazione della regola**
L'argomento a cui l'operazione Ripubblica regola pubblica il nuovo messaggio deve corrispondere all'argomento a cui è stato sottoscritto nel client MQTT.
Apri la regola creata nella console e controlla l'argomento in cui l'operazione della regola ripubblicherà il messaggio.
+
**Controlla il ruolo utilizzato dalla regola**
L'operazione della regola deve disporre dell'autorizzazione per ricevere l'argomento originale e pubblicare il nuovo argomento.
Le policy che autorizzano la regola a ricevere i dati dei messaggi e a ripubblicarli sono specifiche degli argomenti utilizzati. Se si modifica l'argomento utilizzato per ripubblicare i dati del messaggio, è necessario aggiornare il ruolo dell'operazione della regola per aggiornare la policy in modo che corrisponda all'argomento corrente.
Se si sospetta che questo sia il problema, modificare l'operazione Ripubblica regola e creare un nuovo ruolo. I nuovi ruoli creati dall'operazione della regola ricevono le autorizzazioni necessarie per eseguire queste operazioni.
## Fase 3: Esamina i risultati e i passaggi successivi
**In questo tutorial**
+ È stata utilizzata una query SQL semplice e un paio di funzioni in un'istruzione di query della regola per produrre un nuovo messaggio MQTT.
+ Hai creato una regola che ha ripubblicato il nuovo messaggio.
+ Hai usato il client MQTT per testare la tua AWS IoT regola.
**Fasi successive**
Dopo aver ripubblicato alcuni messaggi con questa regola, provare a sperimentarla per verificare come la modifica di alcuni aspetti del tutorial influisca sul messaggio ripubblicato. Ecco alcune idee per iniziare.
+ *device\$1id*Modificate l'argomento del messaggio di input e osservate l'effetto nel payload del messaggio ripubblicato.
+ Modifica i campi selezionati nell'istruzione query della regola e osserva l'effetto nel payload del messaggio ripubblicato.
+ Prova il prossimo tutorial di questa serie e scopri come [Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md).
L'operazione Ripubblica regola utilizzata in questo tutorial consente inoltre di eseguire il debug delle istruzioni di query della regola. Ad esempio, è possibile aggiungere questa operazione a una regola per verificare come l'istruzione della regola query formatta i dati utilizzati dalle relative operazioni delle regole.
# Tutorial: Invio di una notifica Amazon SNS
Questo tutorial dimostra come creare una AWS IoT regola che invii i dati dei messaggi MQTT a un argomento di Amazon SNS in modo che possano essere inviati come messaggio di testo SMS.
In questo tutorial potrai creare una regola per l'invio dei dati dei messaggi da un sensore meteo a tutti i sottoscrittori di un argomento Amazon SNS, ogni volta che la temperatura supera il valore impostato nella regola. La regola rileva quando la temperatura segnalata supera il valore impostato dalla regola e quindi crea un nuovo payload del messaggio che include solo l'ID del dispositivo, la temperatura segnalata e il limite di temperatura superato. La regola invia il nuovo payload del messaggio come documento JSON a un argomento SNS, che notifica a tutti gli abbonati l'argomento SNS.
**Cosa imparerai in questo tutorial:**
+ Come creare e testare una notifica Amazon SNS
+ Come richiamare una notifica Amazon SNS da una regola AWS IoT
+ Come utilizzare semplici query SQL e funzioni in un'istruzione di query della regola
+ Come utilizzare il client MQTT per testare una regola AWS IoT
Questo tutorial dura circa 30 minuti.
**Topics**
+ [Fase 1: creare un argomento Amazon SNS che invii un messaggio di testo SMS](#iot-sns-rule-create-sns-topic)
+ [Passaggio 2: crea una AWS IoT regola per inviare il messaggio di testo](#iot-sns-rule-create-rule)
+ [Fase 3: Verifica la AWS IoT regola e la notifica di Amazon SNS](#iot-sns-rule-test-rule)
+ [Fase 4: Esamina i risultati e i passaggi successivi](#iot-sns-rule-review-results)
**Prima di iniziare questo tutorial, assicurati di disporre di:**
+
**[Configurare Account AWS](setting-up.md)**
Avrai bisogno della tua Account AWS AWS IoT console per completare questo tutorial.
+
**Aver rivisto [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md)**
Assicurati di poter usare il client MQTT per sottoscrivere e pubblicare un argomento. Utilizzerai il client MQTT per testare la nuova regola in questa procedura.
+
**Aver rivisto [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html)**
Se non hai mai utilizzato Amazon SNS, consulta [Configurazione degli accessi per Amazon SNS](https://docs.aws.amazon.com//sns/latest/dg/sns-setting-up.html). Se hai già completato altri AWS IoT tutorial, Account AWS dovresti già essere configurato correttamente.
## Fase 1: creare un argomento Amazon SNS che invii un messaggio di testo SMS
Questa procedura spiega come creare l'argomento Amazon SNS a cui il sensore meteo può inviare i dati dei messaggi. L'argomento Amazon SNS notificherà quindi a tutti i suoi abbonati tramite un messaggio di testo SMS il limite di temperatura superato.
**Per creare un argomento Amazon SNS per l'invio di un SMS di testo**
1. **Creazione di un argomento Amazon SNS.**
1. Accedi alla [console Amazon SNS](https://console.aws.amazon.com//sns/home).
1. Nel pannello di navigazione a sinistra, selezionare **Topics (Argomenti)**.
1. Nella pagina **Topics (Argomenti)**, seleziona **Create topic (Crea argomento)**.
1. In **Details (Dettagli)**, scegli il tipo **standard**. Per impostazione predefinita, la console crea un argomento FIFO.
1. In **Name (Nome)**, inserisci il nome dell'argomento SNS. Per questo tutorial, digita **high\$1temp\$1notice**.
1. Scorri fino alla parte inferiore della pagina e scegli **Crea argomento**.
La console apre la pagina **Details (Dettagli)** del nuovo argomento.
1. **Creazione di una sottoscrizione Amazon SNS.**
**Nota**
Il numero di telefono utilizzato in questo abbonamento potrebbe comportare costi di messaggistica di testo per i messaggi inviati in questo tutorial.
1. Nella pagina dei dettagli dell'argomento **high\$1temp\$1notice**, scegli **Create subscription (Crea sottoscrizione)**.
1. In **Create subscription (Crea sottoscrizione)**, nella sezione **Details (Dettagli)** nell’elenco **Protocol (Protocollo)**, scegli **SMS**.
1. In **Endpoint**, inserisci il numero di un telefono che può ricevere messaggi di testo. Assicurati di inserirlo in modo che inizi con un `+`, includa il paese e il prefisso locale e non includa altri caratteri di punteggiatura.
1. Scegli **Create Subscription** (Crea sottoscrizione).
1. **Testa la notifica di Amazon SNS.**
1. Nella [console Amazon SNS](https://console.aws.amazon.com//sns/home), nel pannello di navigazione a sinistra, scegli **Topics (Argomenti)**.
1. Per aprire la pagina dei dettagli dell'argomento, in **Topics (Argomenti)**, nell'elenco degli argomenti, seleziona **high\$1temp\$1notice**.
1. Per aprire la pagina **Publish message to topic (Pubblica il messaggio nell'argomento)**, nella pagina dei dettagli **high\$1temp\$1notice**, scegli **Publish message (Pubblica messaggio)**.
1. In **Publish message to topic (Pubblica il messaggio nell'argomento)**, nella sezione ** Message body (Corpo del messaggio)**, in **Message body to send to the endpoint (Corpo del messaggio da inviare all'endpoint)**, inserisci un breve messaggio.
1. Scorri fino alla parte inferiore della pagina e scegli **Publish message (Pubblica messaggio)**.
1. Sul telefono con il numero che hai usato in precedenza durante la creazione della sottoscrizione, conferma che il messaggio è stato ricevuto.
Se non hai ricevuto il messaggio di prova, controlla due volte il numero di telefono e le impostazioni del tuo cellulare.
Assicurati di poter pubblicare i messaggi di prova dalla [Console Amazon SNS](https://console.aws.amazon.com//sns/home) prima di continuare il tutorial.
## Passaggio 2: crea una AWS IoT regola per inviare il messaggio di testo
La AWS IoT regola che creerai in questo tutorial riguarda gli argomenti `device/device_id/data` MQTT dove si `device_id` trova l'ID del dispositivo che ha inviato il messaggio. Questi argomenti sono descritti in un filtro argomento come `device/+/data`, dove `+` è un carattere jolly che corrisponde a qualsiasi stringa tra i due caratteri di barra in avanti. Questa regola verifica anche il valore del campo `temperature` nel payload del messaggio.
Quando la regola riceve un messaggio da un argomento corrispondente, prende il `device_id` dal nome dell'argomento, il valore `temperature` dal payload del messaggio, aggiunge un valore costante per il limite che sta testando e invia questi valori come documento JSON a un argomento di notifica Amazon SNS.
Ad esempio, un messaggio MQTT dal dispositivo sensore meteo numero 32 utilizza l’argomento `device/32/data` e ha un payload del messaggio simile al seguente:
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
L'istruzione di query regola della regola accetta il valore `temperature` dal payload del messaggio, il valore `device_id` dal nome dell'argomento e aggiunge il valore costante `max_temperature` per inviare un payload del messaggio simile a questo all'argomento Amazon SNS:
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30
}
```
**Per creare una AWS IoT regola per rilevare un valore di temperatura superiore al limite e creare i dati da inviare all'argomento Amazon SNS**
1. Apri [l'hub **Rules** della console. AWS IoT](https://console.aws.amazon.com//iot/home#/rulehub)
1. Se è la prima regola, scegli **Create (Crea)** oppure **Create a rule (Crea una regola)**.
1. In **Create a rule (Crea una regola)**:
1. In **Nome**, inserisci **temp\$1limit\$1notify**.
Ricorda che il nome di una regola deve essere univoco all'interno della tua regione Account AWS e non può avere spazi. Abbiamo usato un carattere di sottolineatura in questo nome per separare le parole nel nome della regola.
1. In **Description (Descrizione)**, descrivi la regola.
Una descrizione significativa ti aiuta a ricordare cosa fa questa regola e perché l'hai creata. La descrizione può essere lunga quanto necessario, quindi sii il più dettagliato possibile.
1. In **Rule query statement (Istruzione query regola)** di **Create a rule (Crea una regola)**:
1. In **Using SQL version (Uso della versione SQL)**, seleziona **23/03/2016**.
1. Nella casella di modifica **Rule query statement (Istruzione query regola)**, inserisci l'istruzione:
```
SELECT topic(2) as device_id,
temperature as reported_temperature,
30 as max_temperature
FROM 'device/+/data'
WHERE temperature > 30
```
Questa istruzione:
+ Ascolta i messaggi MQTT con un argomento che corrisponde al filtro dell’argomento `device/+/data` e che hanno un valore `temperature` maggiore di 30.
+ Seleziona il secondo elemento dalla stringa dell'argomento e lo assegna al campo `device_id`.
+ Seleziona il valore del campo `temperature` dal payload del messaggio e lo assegna al campo `reported_temperature`.
+ Crea un valore costante `30` per rappresentare il valore limite e lo assegna al campo `max_temperature`.
1. Per aprire l'elenco delle azioni della regola per questa regola, in **Set one or more actions (Imposta una o più azioni)**, scegli **Add action (Aggiungi operazione)**.
1. In **Select an action (Seleziona un’operazione)**, scegli **Send a message as an SNS push notification (Invia un messaggio come notifica push SNS)**.
1. Per aprire la pagina di configurazione dell'operazione selezionata, nella parte inferiore dell'elenco delle operazioni, scegli **Configure action (Configura operazione)**.
1. In **Configure action (Configura operazione)**:
1. In **SNS target (Obiettivo SNS)**, scegli **Select (Seleziona)**, trova l'argomento SNS denominato **high\$1temp\$1notice** e scegli **Select (Seleziona)**.
1. In **Message format (Formato messaggio)**, scegli **RAW**.
1. In **Scegli o crea un ruolo a cui concedere AWS IoT l'accesso per eseguire questa azione**, scegli **Crea ruolo**.
1. In **Create a new role (Crea un nuovo ruolo)**, in **Name (Nome)**, inserisci un nome univoco per il nuovo ruolo. Ai fini di questo tutorial, utilizza **sns\$1rule\$1role**.
1. Scegli **Crea ruolo**.
Se si ripete questo tutorial o si riutilizza un ruolo esistente, scegli **Update role (Aggiorna ruolo)** prima di continuare. In questo modo il documento della policy del ruolo viene aggiornato in modo che funzioni con la destinazione SNS.
1. Scegli **Add action (Aggiungi operazione)** e torna alla pagina **Create a rule (Crea una regola)**.
Nel titolo della nuova operazione, sotto **Send a message as an SNS push notification (Invia un messaggio come notifica push SNS)**, è possibile visualizzare l'argomento SNS che verrà chiamato dalla regola.
Questa è l'unica operazione della regola che aggiungerai a questa regola.
1. Per creare la regola e completare questo passaggio, in **Create a rule (Crea una regola)**, scorri verso il basso e scegli **Create a rule (Crea una regola)**.
## Fase 3: Verifica la AWS IoT regola e la notifica di Amazon SNS
Per testare la nuova regola, utilizza il client MQTT per pubblicare e sottoscrivere i messaggi MQTT utilizzati da questa regola.
Apri il [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test) in una nuova finestra. In questo modo è possibile modificare la regola senza perdere la configurazione del client MQTT. Se abbandoni il client MQTT per andare su un'altra pagina della console, non conserverà nessuna sottoscrizione o registri di messaggi.
**Utilizzare il client MQTT per testare la regola**
1. Nel [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test), effettua la sottoscrizione agli argomenti di input, in questo caso, `device/+/data`.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)** scegli **Subscribe to a topic (Effettua la sottoscrizione a un argomento)**.
1. In **Subscription topic (Argomento sottoscrizione)**, inserisci l'argomento del filtro dell’argomento di input, **device/\$1/data**.
1. Lascia gli altri campi ai valori predefiniti.
1. Scegli **Subscribe to topic (Effettua sottoscrizione all'argomento)**.
Nella colonna **Subscriptions (Sottoscrizioni)**, sotto **Publish to a topic (Pubblica un argomento)**, **device/\$1/data** viene visualizzato.
1. Pubblicazione di un messaggio nell'argomento di input con un ID dispositivo specifico, **device/32/data**. Non è possibile pubblicare su argomenti MQTT che contengono caratteri jolly.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)** scegli **Publish to topic (Pubblica in un argomento)**.
1. Nel campo **Publish (Pubblica)**, inserisci il nome dell'argomento di input, **device/32/data**.
1. Copia i dati di esempio mostrati qui e, nella casella di modifica sotto il nome dell'argomento, incolla i dati di esempio.
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Scegli **Publish to topic (Pubblica in un argomento)** per pubblicare il messaggio MQTT.
1. Conferma che il messaggio di testo è stato inviato.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, accanto all'argomento a cui hai effettuato la sottoscrizione in precedenza è presente un punto verde.
I punti verdi indicano che uno o più nuovi messaggi sono stati ricevuti dall'ultima volta che li hai visualizzati.
1. Sotto **Subscriptions (Sottoscrizioni)**, scegli **device/\$1/data (dispositivo/\$1/dati)** per verificare che il payload del messaggio corrisponda a quello che hai appena pubblicato e assomigli a questo:
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Controlla il telefono che hai usato per effettuare la sottoscrizione all'argomento SNS e conferma che il contenuto del payload del messaggio sia simile al seguente:
```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```
Nota che il valore `device_id` è una stringa tra virgolette e il valore `temperature` è numerico. Questo perché la funzione [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) ha estratto la stringa dal nome dell'argomento del messaggio di input mentre il valore `temperature` utilizza il valore numerico dal payload del messaggio di input.
Se desideri rendere il valore `device_id` un valore numerico, sostituisci `topic(2)` nell'istruzione query della regola con:
```
cast(topic(2) AS DECIMAL)
```
Nota che la trasformazione del valore `topic(2)` in un valore numerico `DECIMAL` funzionerà solo se quella parte dell'argomento contiene solo caratteri numerici.
1. Prova a inviare un messaggio MQTT in cui la temperatura non supera il limite.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, scegli **Publish to topic (Pubblica in un argomento)**.
1. Nel campo **Publish (Pubblica)**, inserisci il nome dell'argomento di input, **device/33/data**.
1. Copia i dati di esempio mostrati qui e, nella casella di modifica sotto il nome dell'argomento, incolla i dati di esempio.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Per inviare il messaggio MQTT, scegli **Publish to topic (Pubblica in un argomento)**.
Dovrebbe essere visualizzato il messaggio inviato nella sottoscrizione **device/\$1/data**. Tuttavia, poiché il valore della temperatura è inferiore alla temperatura massima nell'istruzione di query della regola, non si dovrebbe ricevere un messaggio di testo.
Se il comportamento non viene visualizzato correttamente, controlla i suggerimenti per la risoluzione dei problemi.
### Risoluzione dei problemi della regola di messaggi SNS
Ecco alcune cose da controllare nel caso in cui non stai vedendo i risultati che ti aspetti.
+
**Hai un banner di errore**
Se viene visualizzato un errore quando è stato pubblicato il messaggio di input, correggilo prima. I seguenti passaggi potrebbero aiutarti a correggere l'errore.
+
**Il messaggio di input non viene visualizzato nel client MQTT**
Ogni volta che pubblichi il tuo messaggio di input nell’argomento `device/22/data`, tale messaggio dovrebbe essere visualizzato nel client MQTT, se hai effettuato la sottoscrizione al filtro dell’argomento `device/+/data` come descritto nella procedura.
**Controlli**
+
**Controlla il filtro degli argomenti a cui hai effettuato la sottoscrizione**
Se hai effettuato la sottoscrizione all'argomento del messaggio di input come descritto nella procedura, visualizzerai una copia del messaggio di input ogni volta che lo pubblichi.
Se il messaggio non viene visualizzato, controlla il nome dell'argomento sottoscritto e confrontalo con l'argomento in cui è stato pubblicato. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento a cui è stato sottoscritto deve essere identico all'argomento in cui hai pubblicato il payload dei messaggi.
+
**Controlla la funzione di pubblicazione dei messaggi**
Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, scegli **device/\$1/data (dispositivo/\$1/dati)**, controlla l'argomento del messaggio di pubblicazione e quindi scegli **Publish to topic (Pubblica in un argomento)**. Dovresti vedere il payload del messaggio dalla casella di modifica sotto l'argomento visualizzato nell'elenco dei messaggi.
+
**Se non ricevi un messaggio SMS**
Affinché la regola funzioni, deve disporre della policy corretta che la autorizzi a ricevere un messaggio e inviare una notifica SNS e deve ricevere il messaggio.
**Controlli**
+
**Controlla il Regione AWS tuo client MQTT e la regola che hai creato**
La console in cui si esegue il client MQTT deve trovarsi nella stessa regione AWS della regola creata.
+
**Verifica che il valore della temperatura nel payload del messaggio superi la soglia di prova**
Se il valore della temperatura è minore o uguale a 30, come definito nell'istruzione query della regola, la regola non eseguirà alcuna delle operazioni.
+
**Controlla l'argomento del messaggio di input nell'istruzione query della regola**
Affinché la regola funzioni, è necessario che venga visualizzato un messaggio con il nome dell'argomento corrispondente al filtro dell’argomento nella clausola FROM dell'istruzione query della regola.
Controlla l'ortografia del filtro argomento nell'istruzione query regola con quella dell'argomento nel client MQTT. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento del messaggio deve corrispondere al filtro argomento nell'istruzione query della regola.
+
**Controllare il contenuto del payload del messaggio di input**
Affinché la regola funzioni, è necessario trovare il campo dati nel payload del messaggio dichiarato nell'istruzione SELECT.
Controlla l'ortografia del campo `temperature` nell'istruzione query della regola con quella del payload del messaggio nel client MQTT. I nomi dei campi fanno distinzione tra maiuscole e minuscole e il campo `temperature`nell'istruzione query della regola deve essere identico a quello del campo `temperature` nel payload del messaggio.
Assicurati che il documento JSON nel payload del messaggio sia formattato correttamente. Se il JSON presenta errori, come una virgola mancante, la regola non sarà in grado di leggerlo.
+
**Controlla l'argomento del messaggio ripubblicato nell'operazione della regola**
L'argomento a cui l'operazione Ripubblica regola pubblica il nuovo messaggio deve corrispondere all'argomento a cui è stato sottoscritto nel client MQTT.
Apri la regola creata nella console e controlla l'argomento in cui l'operazione della regola ripubblicherà il messaggio.
+
**Controlla il ruolo utilizzato dalla regola**
L'operazione della regola deve disporre dell'autorizzazione per ricevere l'argomento originale e pubblicare il nuovo argomento.
Le policy che autorizzano la regola a ricevere i dati dei messaggi e a ripubblicarli sono specifiche degli argomenti utilizzati. Se si modifica l'argomento utilizzato per ripubblicare i dati del messaggio, è necessario aggiornare il ruolo dell'operazione della regola per aggiornare la policy in modo che corrisponda all'argomento corrente.
Se si sospetta che questo sia il problema, modificare l'operazione Ripubblica regola e creare un nuovo ruolo. I nuovi ruoli creati dall'operazione della regola ricevono le autorizzazioni necessarie per eseguire queste operazioni.
## Fase 4: Esamina i risultati e i passaggi successivi
**In questo tutorial:**
+ Hai creato e testato un argomento di notifica e una sottoscrizione Amazon SNS.
+ È stata utilizzata una query SQL semplice che funziona in un'istruzione di query della regola per creare un nuovo messaggio per la notifica.
+ Hai creato una AWS IoT regola per inviare una notifica Amazon SNS che utilizza il tuo payload di messaggi personalizzato.
+ Hai usato il client MQTT per testare la tua regola. AWS IoT
**Fasi successive**
Dopo aver inviato alcuni messaggi di testo con questa regola, prova a sperimentarla per vedere come la modifica di alcuni aspetti del tutorial influisce sul messaggio e quando viene inviato. Ecco alcune idee per iniziare.
+ *device\$1id*Modificate l'argomento del messaggio di input e osservate l'effetto nel contenuto del messaggio di testo.
+ Modifica i campi selezionati nell'istruzione query della regola e osserva l'effetto nel contenuto del messaggio di testo.
+ Modifica il test nell'istruzione query della regola per verificare una temperatura minima anziché una temperatura massima. Ricordati di cambiare il nome di `max_temperature`\$1
+ Aggiungi un'operazione della regola di ripubblicazione per inviare un messaggio MQTT quando viene inviata una notifica SNS.
+ Prova il prossimo tutorial di questa serie e scopri come [Tutorial: Archiviazione dei dati del dispositivo in una tabella DynamoDB](iot-ddb-rule.md).
# Tutorial: Archiviazione dei dati del dispositivo in una tabella DynamoDB
Questo tutorial dimostra come creare una AWS IoT regola che invii i dati dei messaggi a una tabella DynamoDB.
In questo tutorial potrai creare una regola per l'invio di dati di messaggi da un dispositivo immaginario di sensori meteorologici a una tabella Dynamo DB. La regola formatta i dati da molti sensori meteorologici in modo che possano essere aggiunti a una singola tabella di database.
**Cosa imparerai in questo tutorial**
+ Come creare una tabella Dynamo DB
+ Come inviare i dati dei messaggi a una tabella DynamoDB da una regola AWS IoT
+ Come utilizzare i modelli sostitutivi in una regola AWS IoT
+ Come utilizzare semplici query SQL e funzioni in un'istruzione di query della regola
+ Come usare il client MQTT per testare una regola AWS IoT
Questo tutorial dura circa 30 minuti.
**Topics**
+ [Fase 1: Creazione della tabella Dynamo DB per questo tutorial](#iot-ddb-rule-ddb-table)
+ [Fase 2: Creare una AWS IoT regola per inviare dati alla tabella DynamoDB](#iot-ddb-rule-topic-rule)
+ [Fase 3: Verificare la AWS IoT regola e la tabella DynamoDB](#iot-ddb-rule-test)
+ [Fase 4: Esamina i risultati e i passaggi successivi](#iot-ddb-rule-review)
**Prima di iniziare questo tutorial, assicurati di disporre di:**
+
**[Configurare Account AWS](setting-up.md)**
Avrai bisogno della tua Account AWS AWS IoT console per completare questo tutorial.
+
**Aver rivisto [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md)**
Assicurati di poter usare il client MQTT per sottoscrivere e pubblicare un argomento. Utilizzerai il client MQTT per testare la nuova regola in questa procedura.
+
**Aver rivisto la panoramica di [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html)**
Se non hai già usato Dynamo DB, consulta [Nozioni di base su Dynamo DB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) per acquisire familiarità con i concetti e le operazioni di base di Dynamo DB.
## Fase 1: Creazione della tabella Dynamo DB per questo tutorial
In questo tutorial creerai una tabella Dynamo DB con questi attributi per registrare i dati dai dispositivi immaginari con sensori meteorologici:
+ `sample_time` è una chiave primaria e descrive l'ora in cui il campione è stato registrato.
+ `device_id` è una chiave di ordinamento e descrive il dispositivo che ha fornito l'esempio
+ `device_data` sono i dati ricevuti dal dispositivo e formattati dall'istruzione query della regola
**Per creare la tabella Dynamo DB per questo tutorial**
1. Accedi alla [console Dynamo DB](https://console.aws.amazon.com//dynamodb/home) e scegli **Create table (Crea una tabella)**.
1. In **Create table (Crea tabella)**:
1. In **Table name (Nome tabella)**, inserisci il nome della tabella: **wx\$1data**.
1. In **Partition key (Chiave di partizione)** inserisci **sample\$1time** e, nell'elenco delle opzioni accanto al campo, scegli **Number**.
1. In **Sort key (chiave di ordinamento)**, inserisci **device\$1id** e nell'elenco delle opzioni accanto al campo, scegli **Number**.
1. Nella parte inferiore della pagina, scegli **Create (Crea)**.
Definisci `device_data` in seguito, quando configuri l'operazione della regola Dynamo DB.
## Fase 2: Creare una AWS IoT regola per inviare dati alla tabella DynamoDB
In questo passaggio utilizzerai l'istruzione query della regola per formattare i dati provenienti dai dispositivi sensore meteo immaginari per scrivere nella tabella del database.
Un esempio di payload di messaggio ricevuto da un dispositivo con sensore meteo è simile al seguente:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
Per la voce del database, si utilizzerà l'istruzione query della regola per appiattire la struttura del payload del messaggio in modo che sia simile al seguente:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind_velocity": 22,
"wind_bearing": 255
}
```
In questa regola, utilizzerai anche un paio di [Modelli di sostituzione](iot-substitution-templates.md). I modelli di sostituzione sono espressioni che consentono di inserire valori dinamici dalle funzioni e dai dati dei messaggi.
**Per creare la AWS IoT regola per inviare dati alla tabella DynamoDB**
1. Apri [l’hub Rules (Regole) della console AWS IoT](https://console.aws.amazon.com//iot/home#/rulehub). In alternativa, puoi aprire la AWS IoT home page all'interno di Console di gestione AWS e passare a **Message** Routing>Rules.
1. Per iniziare a creare la nuova regola in **Rules (Regole)**, scegli **Create rule (Crea regola)**.
1. In **Proprietà delle regole**:
1. In **Role name (Nome ruolo)** immettere **wx\$1data\$1ddb**.
Ricorda che il nome di una regola deve essere univoco all'interno della tua regione Account AWS e non può avere spazi. Abbiamo usato un carattere di sottolineatura in questo nome per separare le due parole nel nome della regola.
1. In **Description (Descrizione)**, descrivi la regola.
Una descrizione significativa ti aiuta a ricordare cosa fa questa regola e perché l'hai creata. La descrizione può essere lunga quanto necessario, quindi sii il più dettagliato possibile.
1. Seleziona **Successivo** per continuare.
1. In **Istruzione SQL**:
1. In **Versione SQL**, seleziona **2016-03-23**.
1. Nella casella di modifica **Istruzione SQL**, inserisci l'istruzione:
```
SELECT temperature, humidity, barometer,
wind.velocity as wind_velocity,
wind.bearing as wind_bearing,
FROM 'device/+/data'
```
Questa istruzione:
+ Ascolta i messaggi MQTT con un argomento che corrisponde al filtro dell’argomento `device/+/data`.
+ Formatta gli elementi dell’attributo `wind` come attributi individuali.
+ Consente di passare gli attributi `temperature`, `humidity` e `barometer` invariati.
1. Seleziona **Successivo** per continuare.
1. In **Azioni delle regole**:
1. Per aprire l'elenco delle azioni della regola per questa regola, in **Azione 1**, scegli **DynamoDB**.
**Nota**
Assicurati di scegliere DynamoDB e non DBv2 Dynamo come azione della regola.
1. In **Table name (Nome tabella)** scegli il nome della tabella Dynamo DB creata in un passaggio precedente: **wx\$1data**.
I campi **Partition key type (Tipo di chiave di partizione)** e **Sort key type (Tipo di chiave di ordinamento)** sono compilati con i valori dalla tabella Dynamo DB.
1. In **Chiave di partizione**, immettere **sample\$1time**.
1. In **Partition key value (Valore della chiave di partizione)**, immettere **\$1\$1timestamp()\$1**.
Questo è il primo di [Modelli di sostituzione](iot-substitution-templates.md) che userai in questa regola. Invece di utilizzare un valore dal payload del messaggio, utilizzerà il valore restituito dal metodo della funzione timestamp. Per ulteriori informazioni, consulta [timestamp](iot-sql-functions.md#iot-function-timestamp) nella *Guida per gli sviluppatori di AWS IoT Core *.
1. In **Sort key (chiave di ordinamento)**, immettere **device\$1id**.
1. In **Sort key value (Valore della chiave di ordinamento)**, immettere **\$1\$1cast(topic(2) AS DECIMAL)\$1**.
Questa è la seconda di [Modelli di sostituzione](iot-substitution-templates.md) che userai in questa regola. Inserisce il valore del secondo elemento nel nome dell’argomento, che è l'ID del dispositivo, dopo la sua trasformazione in un valore DECIMALE per corrispondere al formato numerico della chiave. Per ulteriori informazioni sugli argomenti, consulta la sezione [argomenti](iot-sql-functions.md#iot-function-topic) nella *Guida per sviluppatori di AWS IoT Core *. Oppure per saperne di più sul casting, vedi [cast](iot-sql-functions.md#iot-sql-function-cast) nella *Guida per lo Sviluppatore di AWS IoT Core *.
1. In **Write message data to this column (Scrivi i dati del messaggio in questa colonna)**, immettere **device\$1data**.
Questo creerà la colonna `device_data` nella tabella Dynamo DB.
1. Lascia vuoto il campo **Operation (Operazione)**.
1. In **IAM Role** (Ruolo IAM), scegli **Create new role** (Crea nuovo ruolo).
1. Nella finestra di dialogo **Create role** (Crea ruolo), per **Role name** (Nome ruolo), immetti **wx\$1ddb\$1role**. Questo nuovo ruolo conterrà automaticamente una policy con prefisso "aws-iot-rule" che consentirà alla **wx\$1data\$1ddb** regola di inviare dati alla tabella **wx\$1data** DynamoDB che hai creato.
1. In **IAM role (Ruolo IAM)** scegliere **wx\$1ddb\$1role**.
1. Nella parte inferiore della pagina scegli **Next** (Avanti).
1. Nella parte inferiore della pagina **Rivedi e crea**, scegli **Create** per creare la regola.
## Fase 3: Verificare la AWS IoT regola e la tabella DynamoDB
Per testare la nuova regola, utilizza il client MQTT per pubblicare e sottoscrivere i messaggi MQTT utilizzati in questo test.
Apri il [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test) in una nuova finestra. In questo modo è possibile modificare la regola senza perdere la configurazione del client MQTT. Il client MQTT non conserva sottoscrizioni o registri dei messaggi se si lascia per andare a un'altra pagina della console. Ti consigliamo inoltre di aprire una finestra della console separata sull'[hub DynamoDB Tables nella console per visualizzare AWS IoT le](https://console.aws.amazon.com//dynamodb/home#tables:) nuove voci inviate dalla regola.
**Utilizzare il client MQTT per testare la regola**
1. Nel [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test), effettua la sottoscrizione all'argomento di input, `device/+/data`.
1. Nel client MQTT, scegli **Subscribe to a topic (Effettua la sottoscrizione a un argomento)**.
1. Per **Topic filter (Filtro argomenti)**, inserisci l'argomento del filtro dell’argomento di input, **device/\$1/data**.
1. Scegli **Abbonati**.
1. Ora pubblica un messaggio per l'argomento di input con un ID dispositivo specifico, **device/22/data**. Non è possibile pubblicare su argomenti MQTT che contengono caratteri jolly.
1. Nel client MQTT, scegli **Publish to a topic (Pubblica in un argomento)**.
1. Per **Topic name (Nome argomento)**, inserisci un nome per l'argomento di input, **device/22/data**.
1. Per **Message payload (Payload del messaggio)(**, inserisci i seguenti dati di esempio.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Per pubblicare il messaggio MQTT, scegli **Publish (Pubblica)**.
1. Nel client MQTT, scegli **Subscribe to a topic (Effettua la sottoscrizione a un argomento)**. Nella colonna **Subscribe (Effettua sottoscrizione)**, scegli la sottoscrizione **device/\$1/data**. Verifica che vengano visualizzati i dati di esempio del passaggio precedente.
1. Seleziona per visualizzare la riga della tabella Dynamo DB creata dalla regola.
1. **Nell'[hub DynamoDB Tables AWS IoT della](https://console.aws.amazon.com//dynamodb/home#tables:) console, **scegli wx\$1data, quindi scegli** la scheda Items.**
Se sei già sulla scheda **Items (Elementi)**, è possibile che sia necessario aggiornare la visualizzazione selezionando l'icona Aggiorna nell'angolo in alto a destra dell'intestazione della tabella.
1. Nota che i valori **sample\$1time** nella tabella sono collegamenti, quindi aprine uno. Se hai appena inviato il tuo primo messaggio, sarà l'unico nella lista.
Questo collegamento visualizza tutti i dati nella riga della tabella.
1. Espandi la voce **device\$1dati** per visualizzare i dati risultanti dall'istruzione query della regola.
1. Esplora le diverse rappresentazioni dei dati disponibili in questo display. È possibile modificare i dati anche in questo display.
1. Al termine della revisione di questa riga di dati, per salvare le modifiche apportate, scegli **Save (Salva)** o, per uscire senza salvare le modifiche, scegli **Cancel (Annulla)**.
Se il comportamento non viene visualizzato correttamente, controlla i suggerimenti per la risoluzione dei problemi.
### Risoluzione dei problemi relativi alla regola Dynamo DB
Ecco alcune cose da controllare nel caso in cui non vedi i risultati che ti aspetti.
+
**Hai un banner di errore**
Se viene visualizzato un errore quando è stato pubblicato il messaggio di input, correggilo prima. I seguenti passaggi potrebbero aiutarti a correggere l'errore.
+
**Il messaggio di input non viene visualizzato nel client MQTT**
Ogni volta che pubblichi il messaggio di input nell’argomento `device/22/data`, tale messaggio dovrebbe essere visualizzato nel client MQTT se hai effettuato la sottoscrizione al filtro argomento `device/+/data` come descritto nella procedura.
**Controlli**
+
**Controlla il filtro degli argomenti a cui hai effettuato la sottoscrizione**
Se hai effettuato la sottoscrizione all'argomento del messaggio di input come descritto nella procedura, visualizzerai una copia del messaggio di input ogni volta che lo pubblichi.
Se il messaggio non viene visualizzato, controlla il nome dell'argomento sottoscritto e confrontalo con l'argomento in cui è stato pubblicato. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento a cui è stato sottoscritto deve essere identico all'argomento in cui hai pubblicato il payload dei messaggi.
+
**Controlla la funzione di pubblicazione dei messaggi**
Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, scegli **device/\$1/data (dispositivo/\$1/dati)**, controlla l'argomento del messaggio di pubblicazione e quindi scegli **Publish to topic (Pubblica in un argomento)**. Dovresti vedere il payload del messaggio dalla casella di modifica sotto l'argomento visualizzato nell'elenco dei messaggi.
+
**I dati non vengono visualizzati nella tabella Dynamo DB**
Per prima cosa, aggiorna la visualizzazione selezionando l'icona di aggiornamento nell'angolo in alto a destra dell'intestazione della tabella. Se non vengono visualizzati i dati che si sta cercando, controlla quanto segue.
**Controlli**
+
**Controlla il Regione AWS tuo client MQTT e la regola che hai creato**
La console in cui si esegue il client MQTT deve trovarsi nella stessa regione AWS della regola creata.
+
**Controlla l'argomento del messaggio di input nell'istruzione query della regola**
Affinché la regola funzioni, è necessario che venga visualizzato un messaggio con il nome dell'argomento corrispondente al filtro dell’argomento nella clausola FROM dell'istruzione query della regola.
Controlla l'ortografia del filtro argomento nell'istruzione query regola con quella dell'argomento nel client MQTT. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento del messaggio deve corrispondere al filtro argomento nell'istruzione query della regola.
+
**Controllare il contenuto del payload del messaggio di input**
Affinché la regola funzioni, è necessario trovare il campo dati nel payload del messaggio dichiarato nell'istruzione SELECT.
Controlla l'ortografia del campo `temperature` nell'istruzione query della regola con quella del payload del messaggio nel client MQTT. I nomi dei campi fanno distinzione tra maiuscole e minuscole e il campo `temperature`nell'istruzione query della regola deve essere identico a quello del campo `temperature` nel payload del messaggio.
Assicurati che il documento JSON nel payload del messaggio sia formattato correttamente. Se il JSON presenta errori, come una virgola mancante, la regola non sarà in grado di leggerlo.
+
**Controlla i nomi delle chiavi e dei campi utilizzati nell'operazione della regola**
I nomi dei campi utilizzati nella regola dell'argomento devono corrispondere a quelli trovati nel payload del messaggio JSON del messaggio pubblicato.
Apri la regola creata nella console e controlla i nomi dei campi nella configurazione dell'operazione della regola con quelli utilizzati nel client MQTT.
+
**Controlla il ruolo utilizzato dalla regola**
L'operazione della regola deve disporre dell'autorizzazione per ricevere l'argomento originale e pubblicare il nuovo argomento.
Le policy che autorizzano la regola a ricevere i dati dei messaggi e ad aggiornare la tabella Dynamo DB sono specifiche degli argomenti utilizzati. Se si modifica l'argomento o il nome della tabella Dynamo DB utilizzato dalla regola, è necessario aggiornare il ruolo dell'operazione della regola per aggiornare la policy in modo che corrisponda.
Se si sospetta che questo sia il problema, modificare l'operazione della regola e creare un nuovo ruolo. I nuovi ruoli creati dall'operazione della regola ricevono le autorizzazioni necessarie per eseguire queste operazioni.
## Fase 4: Esamina i risultati e i passaggi successivi
Dopo aver inviato alcuni messaggi alla tabella Dynamo DB con questa regola, provare a sperimentarla per verificare come la modifica di alcuni aspetti del tutorial influisca sui dati scritti nella tabella. Ecco alcune idee per iniziare.
+ Modifica l'*device\$1id*argomento del messaggio di input e osserva l'effetto sui dati. È possibile utilizzarlo per simulare la ricezione di dati da più sensori meteorologici.
+ Modifica i campi selezionati nell'istruzione query della regola e osserva l'effetto sui dati. Questo strumento consente di filtrare i dati archiviati nella tabella.
+ Aggiungi un'operazione della regola di ripubblicazione per inviare un messaggio MQTT per ogni riga aggiunta alla tabella. È possibile utilizzarlo per il debug.
Dopo aver completato questo tutorial, consulta [Tutorial: Formattazione di una notifica utilizzando una funzione AWS Lambda](iot-lambda-rule.md).
# Tutorial: Formattazione di una notifica utilizzando una funzione AWS Lambda
Questo tutorial dimostra come inviare i dati dei messaggi MQTT a un' AWS Lambda azione per la formattazione e l'invio a un altro servizio. AWS In questo tutorial, l' AWS Lambda azione utilizza l' AWS SDK per inviare il messaggio formattato all'argomento Amazon SNS che hai creato nel tutorial su come farlo. [Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md)
Nel tutorial su come [Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md), il documento JSON risultante dall'istruzione di query della regola è stato inviato come corpo del messaggio di testo. Il risultato è un messaggio di testo simile a questo esempio:
```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```
In questo tutorial, utilizzerai un'azione di AWS Lambda regola per richiamare una AWS Lambda funzione che formatta i dati dall'istruzione di query della regola in un formato più intuitivo, come questo esempio:
```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```
La AWS Lambda funzione che creerai in questo tutorial formatta la stringa del messaggio utilizzando i dati dell'istruzione rule query e richiama la funzione di [pubblicazione SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish) dell' AWS SDK per creare la notifica.
**Cosa imparerai in questo tutorial**
+ Come creare e testare una funzione AWS Lambda
+ Come utilizzare l' AWS SDK in una AWS Lambda funzione per pubblicare una notifica Amazon SNS
+ Come utilizzare semplici query SQL e funzioni in un'istruzione di query della regola
+ Come utilizzare il client MQTT per testare una regola AWS IoT
Questo tutorial dura circa 45 minuti.
**Topics**
+ [Passaggio 1: creare una AWS Lambda funzione che invii un messaggio di testo](#iot-lambda-rule-create-lambda)
+ [Passaggio 2: creare una AWS IoT regola con un'azione di regola AWS Lambda](#iot-lambda-rule-create-rule)
+ [Fase 3: Verificare la AWS IoT regola e AWS Lambda l'azione della regola](#iot-lambda-rule-test-rule)
+ [Fase 4: Esamina i risultati e i passaggi successivi](#iot-lambda-rule-next-steps)
**Prima di iniziare questo tutorial, assicurati di disporre di:**
+
**[Configurare Account AWS](setting-up.md)**
Avrai bisogno della tua Account AWS AWS IoT console per completare questo tutorial.
+
**Aver rivisto [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md)**
Assicurati di poter usare il client MQTT per sottoscrivere e pubblicare un argomento. Utilizzerai il client MQTT per testare la nuova regola in questa procedura.
+
**Aver completato gli altri tutorial sulle regole in questa sezione**
Questo tutorial richiede l'argomento di notifica SNS creato nel tutorial su come [Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md). Si presuppone inoltre che in questa sezione siano stati completati i tutorial relativi alle regole.
+
**Aver rivisto la panoramica di [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)**
Se non l'hai mai usato AWS Lambda prima, [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)consulta la sezione [Guida introduttiva a Lambda](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) per conoscerne i termini e i concetti.
## Passaggio 1: creare una AWS Lambda funzione che invii un messaggio di testo
La AWS Lambda funzione di questo tutorial riceve il risultato dell'istruzione di query della regola, inserisce gli elementi in una stringa di testo e invia la stringa risultante ad Amazon SNS come messaggio in una notifica.
A differenza del tutorial su come fare[Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md), che utilizzava un'azione di AWS IoT regola per inviare la notifica, questo tutorial invia la notifica dalla funzione Lambda utilizzando una funzione dell' AWS SDK. L'argomento effettivo di notifica Amazon SNS utilizzato in questo tutorial, tuttavia, è lo stesso utilizzato nel tutorial su come [Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md).
**Per creare una AWS Lambda funzione che invii un messaggio di testo**
1. Crea una nuova AWS Lambda funzione.
1. Nella [console AWS Lambda](https://console.aws.amazon.com//lambda/home) scegliere **Create function (Crea funzione)**.
1. In **Create function (Crea funzione)** seleziona **Use a blueprint (Usa un blueprint)**.
Cerca e seleziona il blueprint **hello-world-python**, quindi scegli **Configure (Configura)**.
1. In **Basic information (Informazioni di base)**:
1. In **Function name (Nome funzione)**, inserisci il nome della funzione, **format-high-temp-notification**.
1. In **Ruolo di esecuzione**, scegli **Crea un nuovo ruolo dai modelli di AWS policy**.
1. In Nome ruolo, inserisci il nome del nuovo ruolo, **format-high-temp-notification-role**.
1. In **Policy templates (Modelli di policy) - *facoltativo***, cerca e seleziona **Amazon SNS publish policy (Policy di pubblicazione Amazon SNS)**.
1. Scegli **Crea funzione**.
1. Modifica il codice del blueprint per formattare e inviare una notifica Amazon SNS.
1. Dopo aver creato la funzione, dovresti vedere la pagina dei **format-high-temp-notification**dettagli. In caso contrario, aprilo dalla pagina [Lambda **Funzioni**](https://console.aws.amazon.com//lambda/home#/functions).
1. Nella pagina dei **format-high-temp-notification**dettagli, scegli la scheda **Configurazione** e scorri fino al pannello **Codice funzione**.
1. Nella finestra **Function code (Codice della funzione)**, nel pannello **Environment (Ambiente)**, scegli il file Python, `lambda_function.py`.
1. Nella finestra **Function code (Codice della funzione)**, elimina tutto il codice originale del programma dal blueprint e sostituiscilo con questo codice.
```
import boto3
#
# expects event parameter to contain:
# {
# "device_id": "32",
# "reported_temperature": 38,
# "max_temperature": 30,
# "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
# }
#
# sends a plain text string to be used in a text message
#
# "Device {0} reports a temperature of {1}, which exceeds the limit of {2}."
#
# where:
# {0} is the device_id value
# {1} is the reported_temperature value
# {2} is the max_temperature value
#
def lambda_handler(event, context):
# Create an SNS client to send notification
sns = boto3.client('sns')
# Format text message from data
message_text = "Device {0} reports a temperature of {1}, which exceeds the limit of {2}.".format(
str(event['device_id']),
str(event['reported_temperature']),
str(event['max_temperature'])
)
# Publish the formatted message
response = sns.publish(
TopicArn = event['notify_topic_arn'],
Message = message_text
)
return response
```
1. Seleziona **Implementa**.
1. In una nuova finestra, controlla l'Amazon Resource Name (ARN) dell'argomento Amazon SNS dal turtorial su come [Tutorial: Invio di una notifica Amazon SNS](iot-sns-rule.md).
1. In una nuova finestra, apri la [pagina degli argomenti della console Amazon SNS](https://console.aws.amazon.com//sns/v3/home#/topics).
1. Nella pagina **Topics (Argomenti)**, trova l’argomento della notifica **high\$1temp\$1notice** nell'elenco degli argomenti Amazon SNS.
1. Trova l'**ARN** dell’argomento della notifica **high\$1temp\$1notice** da utilizzare nel passaggio successivo.
1. Crea un test per la tua funzione Lambda.
1. Nella pagina [**Funzioni** Lambda](https://console.aws.amazon.com//lambda/home#/functions) della console, nella pagina dei **format-high-temp-notification**dettagli, scegli **Seleziona un evento di test** nell'angolo in alto a destra della pagina (anche se sembra disabilitato), quindi scegli **Configura eventi di test**.
1. In **Configure test event (Configura eventi di test)**, scegli **Create new test event (Crea un nuovo evento di test)**.
1. In **Event name (Nome evento)**, inserisci **SampleRuleOutput**.
1. Nell'editor JSON riportato di seguito **Event name (Nome evento)**, incolla questo documento JSON di esempio. Questo è un esempio di ciò che la AWS IoT regola invierà alla funzione Lambda.
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30,
"notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```
1. Fai riferimento alla finestra che ha l’**ARN** dell’argomento della notifica **high\$1temp\$1notice** e copia il valore dell'ARN.
1. Sostituisci il valore `notify_topic_arn` nell'editor JSON con l’ARN dall'argomento di notifica.
Tieni aperta questa finestra in modo da poter utilizzare di nuovo questo valore ARN quando crei la regola AWS IoT .
1. Scegli **Create** (Crea).
1. Testare la funzione con i dati di esempio.
1. **Nella pagina dei **format-high-temp-notification**dettagli, nell'angolo in alto a destra della pagina, conferma che **SampleRuleOutput**appare accanto al pulsante Test.** In caso contrario, sceglilo dall'elenco degli eventi di test disponibili.
1. Per inviare il messaggio di output della regola di esempio alla funzione, scegli **Test**.
Se la funzione e la notifica hanno funzionato, riceverai un messaggio di testo sul tuo cellulare che ha sottoscritto la notifica.
Se non hai ricevuto un messaggio di testo sul telefono, controlla il risultato dell’operazione. Nel pannello **Function code (Codice della funzione)**, nella casella **Execution result (Risultato dell'esecuzione)**, rivedi la risposta per trovare eventuali errori che si sono verificati. Non proseguire con il passaggio successivo finché la funzione non è in grado di inviare la notifica al telefono.
## Passaggio 2: creare una AWS IoT regola con un'azione di regola AWS Lambda
In questo passaggio, si utilizzerà l'istruzione query della regola per formattare i dati dal dispositivo sensore meteo immaginario da inviare a una funzione Lambda, che formatta e invia un messaggio di testo.
Un esempio di messaggio payload ricevuto da un dispositivo con sensore meteo è simile al seguente:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
In questa regola, si utilizzerà l'istruzione query della regola per creare un payload dei messaggi per la funzione Lambda simile al seguente:
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30,
"notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```
Contiene tutte le informazioni necessarie alla funzione Lambda per formattare e inviare il messaggio di testo corretto.
**Per creare la AWS IoT regola per chiamare una funzione Lambda**
1. Apri l'[hub **Rules** della AWS IoT console](https://console.aws.amazon.com//iot/home#/rulehub).
1. Per iniziare a creare la nuova regola in **Rules (Regole)**, scegli **Create (Crea)**.
1. Nella parte superiore di **Create a rule (Crea una regola)**:
1. In **Name (Nome)**, inserisci il nome della regola, **wx\$1friendly\$1text**.
Ricorda che il nome di una regola deve essere univoco all'interno della tua regione Account AWS e non può avere spazi. Abbiamo usato un carattere di sottolineatura in questo nome per separare le due parole nel nome della regola.
1. In **Description (Descrizione)**, descrivi la regola.
Una descrizione significativa ti aiuta a ricordare cosa fa questa regola e perché l'hai creata. La descrizione può essere lunga quanto necessario, quindi sii il più dettagliato possibile.
1. In **Rule query statement (Istruzione query regola)** di **Create a rule (Crea una regola)**:
1. In **Using SQL version (Uso della versione SQL)**, seleziona **2016-03-23**.
1. Nella casella di modifica **Rule query statement (Istruzione query regola)**, inserisci l'istruzione:
```
SELECT
cast(topic(2) AS DECIMAL) as device_id,
temperature as reported_temperature,
30 as max_temperature,
'arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice' as notify_topic_arn
FROM 'device/+/data' WHERE temperature > 30
```
Questa istruzione:
+ Ascolta i messaggi MQTT con un argomento che corrisponde al filtro dell’argomento `device/+/data` e che hanno un valore `temperature` maggiore di 30.
+ Seleziona il secondo elemento dalla stringa dell'argomento, lo converte in un numero decimale e quindi lo assegna al campo `device_id`.
+ Seleziona il valore del campo `temperature` dal payload del messaggio e lo assegna al campo `reported_temperature`.
+ Crea un valore costante, `30`, per rappresentare il valore limite e lo assegna al campo `max_temperature`.
+ Crea un valore costante per il campo `notify_topic_arn`.
1. Fai riferimento alla finestra che ha l’**ARN** dell’argomento della notifica **high\$1temp\$1notice** e copia il valore dell'ARN.
1. Sostituisci il valore ARN (*arn:aws:sns:us-east-1:57EXAMPLE833:high\$1temp\$1notice*) nell'editor delle istruzioni di interrogazione delle regole con l'ARN dell'argomento della notifica.
1. In **Set one or more actions (Imposta una o più operazioni)**:
1. Per aprire l'elenco delle operazioni delle regole per questa regola, scegli **Add action (Aggiungi operazione)**.
1. In **Select an action (Seleziona un’operazione)**, scegli **Send a message to a Lambda function (Invia un messaggio a una funzione Lambda)**.
1. Per aprire la pagina di configurazione dell’operazione selezionata, nella parte inferiore dell'elenco delle operazioni, scegli **Configure action (Configura operazione)**.
1. In **Configure action (Configura operazione)**:
1. In **Function name (Nome della funzione)**, scegli **Select (Seleziona)**.
1. Scegli **format-high-temp-notification**.
1. Nella parte inferiore di **Configure action (Configura operazione)**, scegli **Add action (Aggiungi operazione)**.
1. Per creare la regola, nella parte inferiore di **Create a rule (Crea una regola)**, scegli **Create a rule (Crea una regola)**.
## Fase 3: Verificare la AWS IoT regola e AWS Lambda l'azione della regola
Per testare la nuova regola, utilizza il client MQTT per pubblicare e sottoscrivere i messaggi MQTT utilizzati da questa regola.
Apri il [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test) in una nuova finestra. Ora è possibile modificare la regola senza perdere la configurazione del client MQTT. Se abbandoni il client MQTT per andare in un'altra pagina della console, perderai le tue sottoscrizioni o i registri dei messaggi.
**Utilizzare il client MQTT per testare la regola**
1. Nel [Client MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test), effettua la sottoscrizione agli argomenti di input, in questo caso, `device/+/data`.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)** scegli **Subscribe to a topic (Effettua la sottoscrizione a un argomento)**.
1. In **Subscription topic (Argomento sottoscrizione)**, inserisci l'argomento del filtro dell’argomento di input, **device/\$1/data**.
1. Lascia gli altri campi ai valori predefiniti.
1. Scegli **Subscribe to topic (Effettua sottoscrizione all'argomento)**.
Nella colonna **Subscriptions (Sottoscrizioni)**, sotto **Publish to a topic (Pubblica un argomento)**, **device/\$1/data** viene visualizzato.
1. Pubblicazione di un messaggio nell'argomento di input con un ID dispositivo specifico, **device/32/data**. Non è possibile pubblicare su argomenti MQTT che contengono caratteri jolly.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)** scegli **Publish to topic (Pubblica in un argomento)**.
1. Nel campo **Publish (Pubblica)**, inserisci il nome dell'argomento di input, **device/32/data**.
1. Copia i dati di esempio mostrati qui e, nella casella di modifica sotto il nome dell'argomento, incolla i dati di esempio.
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Scegli **Publish to topic (Pubblica in un argomento)** per pubblicare il messaggio MQTT.
1. Conferma che il messaggio di testo è stato inviato.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, accanto all'argomento a cui hai effettuato la sottoscrizione in precedenza è presente un punto verde.
I punti verdi indicano che uno o più nuovi messaggi sono stati ricevuti dall'ultima volta che li hai visualizzati.
1. Sotto **Subscriptions (Sottoscrizioni)**, scegli **device/\$1/data (dispositivo/\$1/dati)** per verificare che il payload del messaggio corrisponda a quello che hai appena pubblicato e assomigli a questo:
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Controlla il telefono che hai usato per effettuare la sottoscrizione all'argomento SNS e conferma che il contenuto del payload del messaggio sia simile al seguente:
```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```
Se si modifica l'elemento ID dell’argomento nell'argomento del messaggio, tenere presente che la trasformazione del valore `topic(2)` in un valore numerico funzionerà solo se tale elemento nell'argomento del messaggio contiene solo caratteri numerici.
1. Prova a inviare un messaggio MQTT in cui la temperatura non supera il limite.
1. Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, scegli **Publish to topic (Pubblica in un argomento)**.
1. Nel campo **Publish (Pubblica)**, inserisci il nome dell'argomento di input, **device/33/data**.
1. Copia i dati di esempio mostrati qui e, nella casella di modifica sotto il nome dell'argomento, incolla i dati di esempio.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Per inviare il messaggio MQTT, scegli **Publish to topic (Pubblica in un argomento)**.
Il messaggio inviato dovrebbe essere visualizzato nella sottoscrizione **device/\$1/data**; tuttavia, poiché il valore della temperatura è inferiore alla temperatura massima nell'istruzione query della regola, non si dovrebbe ricevere un messaggio di testo.
Se il comportamento non viene visualizzato correttamente, controlla i suggerimenti per la risoluzione dei problemi.
### Risoluzione dei problemi relativi alla AWS Lambda regola e alla notifica
Ecco alcune cose da controllare nel caso in cui non stai vedendo i risultati che ti aspetti.
+
**Hai un banner di errore**
Se viene visualizzato un errore quando è stato pubblicato il messaggio di input, correggilo prima. I seguenti passaggi potrebbero aiutarti a correggere l'errore.
+
**Il messaggio di input non viene visualizzato nel client MQTT**
Ogni volta che pubblichi il tuo messaggio di input nell’argomento `device/32/data`, tale messaggio dovrebbe essere visualizzato nel client MQTT, se hai effettuato la sottoscrizione al filtro dell’argomento `device/+/data` come descritto nella procedura.
**Controlli**
+
**Controlla il filtro degli argomenti a cui hai effettuato la sottoscrizione**
Se hai effettuato la sottoscrizione all'argomento del messaggio di input come descritto nella procedura, visualizzerai una copia del messaggio di input ogni volta che lo pubblichi.
Se il messaggio non viene visualizzato, controlla il nome dell'argomento sottoscritto e confrontalo con l'argomento in cui è stato pubblicato. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento a cui è stato sottoscritto deve essere identico all'argomento in cui hai pubblicato il payload dei messaggi.
+
**Controlla la funzione di pubblicazione dei messaggi**
Nel client MQTT, sotto **Subscriptions (Sottoscrizioni)**, scegli **device/\$1/data (dispositivo/\$1/dati)**, controlla l'argomento del messaggio di pubblicazione e quindi scegli **Publish to topic (Pubblica in un argomento)**. Dovresti vedere il payload del messaggio dalla casella di modifica sotto l'argomento visualizzato nell'elenco dei messaggi.
+
**Se non ricevi un messaggio SMS**
Affinché la regola funzioni, deve disporre della policy corretta che la autorizzi a ricevere un messaggio e inviare una notifica SNS e deve ricevere il messaggio.
**Controlli**
+
**Controlla il Regione AWS tuo client MQTT e la regola che hai creato**
La console in cui si esegue il client MQTT deve trovarsi nella stessa regione AWS della regola creata.
+
**Verifica che il valore della temperatura nel payload del messaggio superi la soglia di prova**
Se il valore della temperatura è minore o uguale a 30, come definito nell'istruzione query della regola, la regola non eseguirà alcuna delle operazioni.
+
**Controlla l'argomento del messaggio di input nell'istruzione query della regola**
Affinché la regola funzioni, è necessario che venga visualizzato un messaggio con il nome dell'argomento corrispondente al filtro dell’argomento nella clausola FROM dell'istruzione query della regola.
Controlla l'ortografia del filtro argomento nell'istruzione query regola con quella dell'argomento nel client MQTT. I nomi degli argomenti fanno distinzione tra maiuscole e minuscole e l'argomento del messaggio deve corrispondere al filtro argomento nell'istruzione query della regola.
+
**Controllare il contenuto del payload del messaggio di input**
Affinché la regola funzioni, è necessario trovare il campo dati nel payload del messaggio dichiarato nell'istruzione SELECT.
Controlla l'ortografia del campo `temperature` nell'istruzione query della regola con quella del payload del messaggio nel client MQTT. I nomi dei campi fanno distinzione tra maiuscole e minuscole e il campo `temperature`nell'istruzione query della regola deve essere identico a quello del campo `temperature` nel payload del messaggio.
Assicurati che il documento JSON nel payload del messaggio sia formattato correttamente. Se il JSON presenta errori, come una virgola mancante, la regola non sarà in grado di leggerlo.
+
**Controlla le notifiche Amazon SNS**
In [Fase 1: creare un argomento Amazon SNS che invii un messaggio di testo SMS](iot-sns-rule.md#iot-sns-rule-create-sns-topic), fai riferimento al passaggio 3 che descrive come testare la notifica Amazon SNS e testa la notifica per assicurarti che la notifica funzioni.
+
**Controlla la funzione Lambda**
In [Passaggio 1: creare una AWS Lambda funzione che invii un messaggio di testo](#iot-lambda-rule-create-lambda), fai riferimento al passaggio 5 che descrive come testare la funzione Lambda utilizzando i dati di test e testa la funzione Lambda.
+
**Controlla il ruolo utilizzato dalla regola**
L'operazione della regola deve disporre dell'autorizzazione per ricevere l'argomento originale e pubblicare il nuovo argomento.
Le policy che autorizzano la regola a ricevere i dati dei messaggi e a ripubblicarli sono specifiche degli argomenti utilizzati. Se si modifica l'argomento utilizzato per ripubblicare i dati del messaggio, è necessario aggiornare il ruolo dell'operazione della regola per aggiornare la policy in modo che corrisponda all'argomento corrente.
Se si sospetta che questo sia il problema, modificare l'operazione Ripubblica regola e creare un nuovo ruolo. I nuovi ruoli creati dall'operazione della regola ricevono le autorizzazioni necessarie per eseguire queste operazioni.
## Fase 4: Esamina i risultati e i passaggi successivi
**In questo tutorial:**
+ Hai creato una AWS IoT regola per chiamare una funzione Lambda che ha inviato una notifica Amazon SNS utilizzando il payload di messaggi personalizzato.
+ È stata utilizzata una semplice query SQL e funzioni in un'istruzione di query della regola per creare un nuovo payload dei messaggi per la funzione Lambda.
+ Hai usato il client MQTT per testare la tua regola. AWS IoT
**Fasi successive**
Dopo aver inviato alcuni messaggi di testo con questa regola, prova a sperimentarla per vedere come la modifica di alcuni aspetti del tutorial influisce sul messaggio e quando viene inviato. Ecco alcune idee per iniziare.
+ *device\$1id*Modificate l'argomento del messaggio di input e osservate l'effetto nel contenuto del messaggio di testo.
+ Modifica i campi selezionati nell'istruzione query della regola, aggiorna la funzione Lambda per utilizzarli in un nuovo messaggio e osserva l'effetto nel contenuto del messaggio di testo.
+ Modifica il test nell'istruzione query della regola per verificare una temperatura minima anziché una temperatura massima. Aggiorna la funzione Lambda per formattare un nuovo messaggio e ricordati di cambiare il nome di `max_temperature`.
+ Per ulteriori informazioni su come trovare gli errori che potrebbero verificarsi durante lo sviluppo e l'utilizzo AWS IoT delle regole, consulta[Monitoraggio AWS IoT](monitoring_overview.md).