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à.
# 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.