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 soluzioni con il AWS IoT dispositivo SDKs
I tutorial in questa sezione ti guidano attraverso i passaggi per sviluppare una soluzione IoT che può essere implementata in un ambiente di produzione utilizzando. AWS IoT
Il completamento di questi tutorial può richiedere più tempo rispetto a quelli della sezione precedente, [Creazione di demo con AWS IoT Device Client](iot-tutorials-dc-intro.md) poiché utilizzano il AWS IoT dispositivo SDKs e spiegano i concetti applicati in modo più dettagliato per aiutarti a creare soluzioni sicure e affidabili.
## Inizia a creare soluzioni con il dispositivo AWS IoT SDKs
Questi tutorial ti guidano attraverso diversi AWS IoT scenari. Se del caso, i tutorial utilizzano il dispositivo. AWS IoT SDKs
**Topics**
+ [Inizia a creare soluzioni con il dispositivo AWS IoT SDKs](#iot-sdk-tutorial-overview)
+ [Tutorial: Connessione di un dispositivo AWS IoT Core tramite AWS IoT Device SDK](sdk-tutorials.md)
+ [Creazione di AWS IoT regole per indirizzare i dati del dispositivo ad altri servizi](iot-rules-tutorial.md)
+ [Mantenimento dello stato del dispositivo mentre il dispositivo è disconnesso da Device Shadows](iot-shadows-tutorial.md)
+ [Tutorial: creazione di un autorizzatore personalizzato per AWS IoT Core](custom-auth-tutorial.md)
+ [Tutorial: monitoraggio dell'umidità del suolo con AWS IoT Raspberry Pi](iot-moisture-tutorial.md)
# Tutorial: Connessione di un dispositivo AWS IoT Core tramite AWS IoT Device SDK
Questo tutorial mostra come connettere un dispositivo a AWS IoT Core cui inviare e ricevere dati da e verso. AWS IoT Dopo aver completato questo tutorial, il dispositivo sarà configurato per la connessione AWS IoT Core e capirai come comunicano i AWS IoT dispositivi.
**Topics**
+ [Prerequisiti](#sdk-tutorials-prereq)
+ [Prepara il tuo dispositivo per AWS IoT](#sdk-tutorials-prepare)
+ [Esamina il protocollo MQTT](#sdk-tutorials-mqtt-review)
+ [Revisione dell'app di esempio pubsub.py SDK per dispositivi](#sdk-tutorials-explore-sample)
+ [Connect il dispositivo e comunica con AWS IoT Core](#sdk-tutorials-experiment)
+ [Rivedi i risultati](#sdk-tutorials-conclusion)
+ [Tutorial: Utilizzo del SDK per dispositivi AWS IoT per Embedded C](iot-embedded-c-sdk.md)
## Prerequisiti
Prima di iniziare il tutorial, assicurati di disporre:
+
**Aver completato [Guida introduttiva ai AWS IoT Core tutorial](iot-gs.md)**
Nella sezione di quel tutorial in cui è necessario [Configurazione del dispositivo](configure-device.md), seleziona l’opzione [Connettere un Raspberry Pi o altro dispositivo](connecting-to-existing-device.md) per il tuo dispositivo e usa le opzioni del linguaggio Python per configurare il tuo dispositivo.
**Nota**
Assicurati di tenere aperta la finestra terminale che usi in quel tutorial perché la userai anche in questo.
+
**Un dispositivo in grado di eseguire AWS IoT Device SDK v2 per Python.**
Questo tutorial mostra come connettere un dispositivo AWS IoT Core utilizzando esempi di codice Python, che richiedono un dispositivo relativamente potente. Se lavori con dispositivi con vincoli di risorse, questi esempi di codice potrebbero non funzionare su di essi. In tal caso, potresti avere più successo con il [Tutorial: Utilizzo del SDK per dispositivi AWS IoT per Embedded C](iot-embedded-c-sdk.md) tutorial.
+
**Hai ottenuto le informazioni richieste per la connessione al dispositivo**
Per connettere il dispositivo a AWS IoT, è necessario disporre di informazioni sul nome dell'oggetto, sul nome host e sul numero di porta.
**Nota**
Puoi anche utilizzare l'autenticazione personalizzata a cui connettere i dispositivi AWS IoT Core. I dati di connessione trasmessi alla funzione Lambda dell'autorizzatore dipendono dal protocollo utilizzato.
+ **Nome dell'oggetto**: il nome dell' AWS IoT oggetto a cui vuoi connetterti. Devi prima esserti registrato come AWS IoT dispositivo. Per ulteriori informazioni, consulta [Gestione dei dispositivi con AWS IoT](iot-thing-management.md).
+ **Nome host**: il nome host per l'endpoint IoT specifico dell'account.
+ **Numero di porta: il numero** di porta a cui connettersi.
Puoi usare il `configureEndpoint` metodo in AWS IoT Python SDK per configurare il nome host e il numero di porta.
```
myAWSIoTMQTTClient.configureEndpoint("random.iot.region.amazonaws.com", 8883)
```
## Prepara il tuo dispositivo per AWS IoT
In [Guida introduttiva ai AWS IoT Core tutorial](iot-gs.md), hai preparato il tuo dispositivo e account AWS in modo che potessero comunicare. Questa sezione esamina gli aspetti di tale preparazione che si applicano alla connessione di qualsiasi dispositivo con AWS IoT Core.
Affinché un dispositivo si connetta a AWS IoT Core:
1. È necessario disporre di un **Account AWS**.
La procedura riportata di seguito [Configurare Account AWS](setting-up.md) descrive come crearne uno Account AWS se non ne hai già uno.
1. In quell'account, devi avere le seguenti **AWS IoT risorse** definite per il dispositivo nella tua Account AWS regione.
La procedura in [Crea AWS IoT risorse](create-iot-resources.md) descrive come creare queste risorse per il dispositivo nell’account Account AWS e regione.
+ Un **certificato del dispositivo** registrato con AWS IoT e attivato per autenticare il dispositivo.
Il certificato viene spesso creato con un **oggetto AWS IoT ** e collegato a esso. Sebbene un oggetto non sia necessario per la connessione di un dispositivo AWS IoT, rende disponibili AWS IoT funzionalità aggiuntive per il dispositivo.
+ Una **politica** allegata al certificato del dispositivo che lo autorizza a connettersi AWS IoT Core e a eseguire tutte le azioni desiderate.
1. Una **connessione a Internet** che può accedere all’account Account AWS degli endpoint del dispositivo.
Gli endpoint del dispositivo sono descritti [AWS IoT dati del dispositivo e endpoint di servizio](iot-connect-devices.md#iot-connect-device-endpoints) e possono essere visualizzati nella [pagina delle impostazioni della AWS IoT console](https://console.aws.amazon.com/iot/home#/settings).
1. **Software di comunicazione** SDKs fornito dal AWS IoT dispositivo. Questo tutorial utilizza [AWS IoT Device SDK v2 per Python](https://github.com/aws/aws-iot-device-sdk-python-v2#aws-iot-device-sdk-v2-for-python).
## Esamina il protocollo MQTT
Prima di parlare dell'app di esempio, questo ti aiuta a capire il protocollo MQTT. Il protocollo MQTT offre alcuni vantaggi rispetto ad altri protocolli di comunicazione di rete, come HTTP, così da essere una scelta popolare per i dispositivi IoT. Questa sezione esamina gli aspetti chiave di MQTT applicabili 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).
**MQTT utilizza un modello di publish/subscribe comunicazione**
Il protocollo MQTT utilizza un modello di publish/subscribe comunicazione con il suo host. Questo modello è diverso dal request/response modello utilizzato da HTTP. Con MQTT, i dispositivi stabiliscono una sessione con l'host identificata da un ID client univoco. Per inviare dati, i dispositivi pubblicano i messaggi identificati da argomenti al broker messaggi nell'host. Per ricevere messaggi dal broker di messaggi, i dispositivi sottoscrivono agli argomenti inviando al broker messaggi i filtri argomento nelle richieste di sottoscrizione al broker di messaggi.
**MQTT supporta sessioni persistenti**
Il broker di messaggi riceve i messaggi dai dispositivi e pubblica i messaggi ai dispositivi che hanno effettuato una sottoscrizione. Con le [sessioni persistenti](mqtt.md#mqtt-persistent-sessions) che rimangono attive anche quando il dispositivo di avvio è disconnesso, i dispositivi possono recuperare i messaggi pubblicati mentre erano disconnessi. Sul lato dispositivo, MQTT supporta i livelli di qualità del servizio ([QoS](mqtt.md#mqtt-qos)) che assicurano che l'host riceva i messaggi inviati dal dispositivo.
## Revisione dell'app di esempio pubsub.py SDK per dispositivi
Questa sezione esamina l’app di esempio `pubsub.py` **SDK per dispositivi AWS IoT v2 per Python** utilizzata in questo tutorial. Qui esamineremo come si connette per AWS IoT Core pubblicare e sottoscrivere i messaggi MQTT. La sezione successiva presenta alcuni esercizi per aiutarti a scoprire come un dispositivo si connette e comunica. AWS IoT Core
**L'app `pubsub.py` di esempio illustra questi aspetti di una connessione MQTT con: AWS IoT Core**
+ [Protocolli di comunicazione](#sdk-tutorials-explore-protocols)
+ [Sessioni persistenti](#sdk-tutorials-explore-persistent)
+ [Qualità del servizio](#sdk-tutorials-explore-qos)
+ [Pubblicazione di messaggi](#sdk-tutorials-explore-publish)
+ [Abbonamento messaggi](#sdk-tutorials-explore-subscribe)
+ [Disconnessione e riconnessione del dispositivo](#sdk-tutorials-explore-connect)
### Protocolli di comunicazione
L’esempio `pubsub.py` illustra una connessione MQTT utilizzando i protocolli MQTT e MQTT su WSS. La libreria [AWS Common Runtime (AWS CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) fornisce il supporto del protocollo di comunicazione di basso livello ed è inclusa in AWS IoT Device SDK v2 for Python.
#### MQTT
Le chiamate `pubsub.py` di esempio `mtls_from_path` (mostrate qui) in cui [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py)stabilire una connessione utilizzando il protocollo MQTT AWS IoT Core . `mtls_from_path`utilizza certificati X.509 e TLS v1.2 per autenticare il dispositivo. La libreria AWS CRT gestisce i dettagli di livello inferiore di tale connessione.
```
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=args.endpoint,
cert_filepath=args.cert,
pri_key_filepath=args.key,
ca_filepath=args.ca_file,
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
`endpoint`
L'endpoint Account AWS del tuo dispositivo IoT
Nell'app di esempio, il valore viene passato dalla riga di comando.
`cert_filepath`
Il percorso del certificato del file del dispositivo
Nell'app di esempio, il valore viene passato dalla riga di comando.
`pri_key_filepath`
Il percorso al file della chiave privata del dispositivo creata con il relativo file di certificato
Nell'app di esempio, il valore viene passato dalla riga di comando.
`ca_filepath`
Il percorso del file Root CA. Obbligatorio solo se il server MQTT utilizza un certificato che non è già presente nell'archivio.
Nell'app di esempio, il valore viene passato dalla riga di comando.
`client_bootstrap`
L'oggetto runtime comune che gestisce le attività di comunicazione socket
Nell'app di esempio, questo oggetto viene istanziato appena prima della chiamata a `mqtt_connection_builder.mtls_from_path`.
`on_connection_interrupted``on_connection_resumed`
Le funzioni di richiamata da richiamare quando la connessione del dispositivo viene interrotta e ripresa
`client_id`
L'ID che identifica il dispositivo in modo univoco nella Regione AWS
Nell'app di esempio, il valore viene passato dalla riga di comando.
`clean_session`
Se avviare una nuova sessione persistente o, se presente, riconnettersi a una esistente
`keep_alive_secs`
Il valore keep alive, in secondi, per inviare la richiesta `CONNECT`. Un ping verrà inviato automaticamente a questo intervallo. Se il server non riceve un ping dopo 1,5 volte questo valore, presuppone che la connessione sia stata persa.
#### MQTT su WSS
L'esempio `pubsub.py` chiama `websockets_with_default_aws_signing` (mostrato qui) in [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) per stabilire una connessione con AWS IoT Core utilizzando il protocollo MQTT su WSS. `websockets_with_default_aws_signing` crea una connessione MQTT su WSS usando [Firma V4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) per autenticare il dispositivo.
```
mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
endpoint=args.endpoint,
client_bootstrap=client_bootstrap,
region=args.signing_region,
credentials_provider=credentials_provider,
websocket_proxy_options=proxy_options,
ca_filepath=args.ca_file,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
`endpoint`
L'endpoint Account AWS del tuo dispositivo IoT
Nell'app di esempio, il valore viene passato dalla riga di comando.
`client_bootstrap`
L'oggetto runtime comune che gestisce le attività di comunicazione socket
Nell'app di esempio, questo oggetto viene istanziato appena prima della chiamata a `mqtt_connection_builder.websockets_with_default_aws_signing`.
`region`
La regione di AWS firma utilizzata dall'autenticazione Signature V4. Nello stato `pubsub.py`, passa il parametro inserito nella riga di comando.
Nell'app di esempio, il valore viene passato dalla riga di comando.
`credentials_provider`
Le AWS credenziali fornite da utilizzare per l'autenticazione
Nell'app di esempio, questo oggetto viene istanziato appena prima della chiamata a `mqtt_connection_builder.websockets_with_default_aws_signing`.
`websocket_proxy_options`
Opzioni proxy HTTP, se si utilizza un host proxy
Nell'app di esempio, questo valore viene inizializzato appena prima della chiamata a `mqtt_connection_builder.websockets_with_default_aws_signing`.
`ca_filepath`
Il percorso del file Root CA. Obbligatorio solo se il server MQTT utilizza un certificato che non è già presente nell'archivio.
Nell'app di esempio, il valore viene passato dalla riga di comando.
`on_connection_interrupted``on_connection_resumed`
Le funzioni di richiamata da richiamare quando la connessione del dispositivo viene interrotta e ripresa
`client_id`
L'ID che identifichi il dispositivo in modo univoco nella Regione AWS.
Nell'app di esempio, il valore viene passato dalla riga di comando.
`clean_session`
Se avviare una nuova sessione persistente o, se presente, riconnettersi a una esistente
`keep_alive_secs`
Il valore keep alive, in secondi, per inviare la richiesta `CONNECT`. Un ping verrà inviato automaticamente a questo intervallo. Se il server non riceve un ping dopo 1,5 volte questo valore, presuppone che la connessione venga persa.
#### HTTPS
Che dire di HTTPS? AWS IoT Core supporta dispositivi che pubblicano richieste HTTPS. Dal punto di vista della programmazione, i dispositivi inviano richieste HTTPS a AWS IoT Core come qualsiasi altra applicazione. Per un esempio di un programma Python che invia un messaggio HTTP da un dispositivo, consulta l’[esempio di codice HTTPS](http.md#codeexample) utilizzando la libreria di Python `requests`. Questo esempio invia un messaggio all' AWS IoT Core utilizzo di HTTPS in modo che lo AWS IoT Core interpreti come un messaggio MQTT.
Sebbene AWS IoT Core supporti le richieste HTTPS dai dispositivi, assicuratevi di esaminare le informazioni [Scelta di un protocollo applicativo per la comunicazione del dispositivo](protocols.md#protocol-selection) in merito in modo da poter prendere una decisione informata sul protocollo da utilizzare per le comunicazioni tra i dispositivi.
### Sessioni persistenti
Nell'app di esempio, l’impostazione del parametro `clean_session` di `False` indica che la connessione deve essere persistente. In pratica, ciò significa che la connessione aperta da questa chiamata si riconnette a una sessione persistente esistente, se esiste. In caso contrario, crea e si connette a una nuova sessione persistente.
Con una sessione persistente, i messaggi inviati al dispositivo vengono archiviati dal broker di messaggi mentre il dispositivo non è connesso. Quando un dispositivo si riconnette a una sessione persistente, il broker di messaggi invia al dispositivo tutti i messaggi archiviati a cui è stato sottoscritto.
Senza una sessione persistente, il dispositivo non riceverà messaggi inviati mentre il dispositivo non è connesso. L'opzione da utilizzare dipende dall'applicazione e se i messaggi che si verificano mentre un dispositivo non è connesso devono essere comunicati. Per ulteriori informazioni, consulta [Sessioni persistenti MQTT](mqtt.md#mqtt-persistent-sessions).
### Qualità del servizio
Quando il dispositivo pubblica e sottoscrive messaggi, è possibile impostare la qualità del servizio (QoS) preferita. AWS IoT supporta i livelli QoS 0 e 1 per le operazioni di pubblicazione e sottoscrizione. Per ulteriori informazioni sui livelli QoS in AWS IoT, vedere. [Opzioni di qualità del servizio MQTT (QoS)](mqtt.md#mqtt-qos)
Il runtime AWS CRT per Python definisce queste costanti per i livelli QoS che supporta:
**Livelli della qualità del servizio di Python**
| Livello QoS MQTT | Valore simbolico Python utilizzato da SDK | Description |
| --- | --- | --- |
| QoS livello 0 | mqtt.QoS.AT\$1MOST\$1ONCE | Verrà effettuato un solo tentativo di inviare il messaggio, che sia ricevuto o meno. Il messaggio potrebbe non venire inviato, ad esempio se il dispositivo non è connesso o si verifica un errore di rete. |
| QoS livello 1 | mqtt.QoS.AT\$1LEAST\$1ONCE | Il messaggio viene inviato ripetutamente finché non si riceve un riconoscimento PUBACK. |
Nell'app di esempio, le richieste di pubblicazione e sottoscrizione vengono effettuate con un livello QoS di 1 (`mqtt.QoS.AT_LEAST_ONCE`).
+
**QoS in fase di pubblicazione**
Quando un dispositivo pubblica un messaggio con QoS livello 1, invia il messaggio ripetutamente fino a quando non riceve una risposta `PUBACK` dal broker di messaggi. Se il dispositivo non è connesso, il messaggio viene messo in coda per essere inviato dopo la riconnessione.
+
**QoS in abbonamento**
Quando un dispositivo sottoscrive un messaggio con QoS livello 1, il broker di messaggi salva i messaggi a cui il dispositivo è sottoscritto fino a quando non possono essere inviati al dispositivo. Il broker di messaggi restituisce i messaggi fino a quando non riceve una risposta `PUBACK` dal dispositivo.
### Pubblicazione di messaggi
Dopo aver stabilito con successo una connessione a AWS IoT Core, i dispositivi possono pubblicare messaggi. L’esempio `pubsub.py` fa ciò chiamando l'operazione `publish` dell'oggetto `mqtt_connection`.
```
mqtt_connection.publish(
topic=args.topic,
payload=message,
qos=mqtt.QoS.AT_LEAST_ONCE
)
```
`topic`
Nome dell'argomento del messaggio che identifica il messaggio
Nell'app di esempio, ciò viene passato dalla riga di comando.
`payload`
Il payload del messaggio formattato come stringa (ad esempio, un documento JSON)
Nell'app di esempio, ciò viene passato dalla riga di comando.
Un documento JSON è un formato di payload comune e riconosciuto da altri AWS IoT servizi; tuttavia, il formato dei dati del payload del messaggio può essere qualsiasi cosa concordata tra editori e abbonati. Ttuttavia, altri servizi AWS IoT , riconoscono solo JSON e CBOR in alcuni casi per la maggior parte delle operazioni.
`qos`
Il livello QoS per questo messaggio
### Abbonamento messaggi
Per ricevere messaggi da AWS IoT e altri servizi e dispositivi, i dispositivi si iscrivono a tali messaggi in base al nome dell'argomento. I dispositivi possono sottoscrivere singoli messaggi specificando un [nome argomento](topics.md#topicnames) e a un gruppo di messaggi specificando un [filtro di argomenti](topics.md#topicfilters) che può includere caratteri jolly. L’esempio `pubsub.py` utilizza il codice mostrato qui per iscriversi ai messaggi e registrare le funzioni di callback per elaborare il messaggio dopo che è stato ricevuto.
```
subscribe_future, packet_id = mqtt_connection.subscribe(
topic=args.topic,
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_message_received
)
subscribe_result = subscribe_future.result()
```
`topic`
L'argomento a cui effettuare la sottoscrizione. Può trattarsi di un nome di argomento o di un filtro dell’argomento.
Nell'app di esempio, ciò viene passato dalla riga di comando.
`qos`
Se il broker di messaggi deve archiviare questi messaggi mentre il dispositivo è disconnesso.
Valore di `mqtt.QoS.AT_LEAST_ONCE` (QoS livello 1), richiede una sessione persistente da specificare (`clean_session=False`) quando viene creata la connessione.
`callback`
La funzione da chiamare per elaborare il messaggio sottoscritto.
La funzione `mqtt_connection.subscribe` restituisce un futuro e un ID pacchetto. Se la richiesta di sottoscrizione è stata avviata correttamente, l'ID del pacchetto restituito è maggiore di 0. Per assicurarsi che la sottoscrizione sia stata ricevuta e registrata dal broker di messaggi, è necessario attendere la restituzione del risultato dell'operazione asincrona, come illustrato nell'esempio del codice.
**La funzione di callback**
Il callback nei processi di esempio `pubsub.py` elabora i messaggi sottoscritti quando il dispositivo li riceve.
```
def on_message_received(topic, payload, **kwargs):
print("Received message from topic '{}': {}".format(topic, payload))
global received_count
received_count += 1
if received_count == args.count:
received_all_event.set()
```
`topic`
L'argomento del messaggio
Questo è il nome dell'argomento specifico del messaggio ricevuto, anche se è stato sottoscritto un filtro dell’argomento.
`payload`
Payload del messaggio
Il formato è specifico per l'applicazione.
`kwargs`
Possibili argomenti aggiuntivi come descritto in [https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe](https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe).
Nell’esempio `pubsub.py`, `on_message_received` visualizza solo l'argomento e il relativo payload. Conta inoltre i messaggi ricevuti per terminare il programma dopo il raggiungimento del limite.
La tua app valuterà l'argomento e il payload per determinare quali operazioni eseguire.
### Disconnessione e riconnessione del dispositivo
L’esempio `pubsub.py` include funzioni di callback che vengono chiamate quando il dispositivo viene disconnesso e quando la connessione viene ristabilita. Le operazioni intraprese dal dispositivo su questi eventi sono specifiche dell'applicazione.
Quando un dispositivo si connette per la prima volta, deve sottoscrivere gli argomenti da ricevere. Se la sessione di un dispositivo è presente durante la riconnessione, le relative sottoscrizioni vengono ripristinate e tutti i messaggi memorizzati da tali sottoscrizioni vengono inviati al dispositivo dopo la riconnessione.
Se la sessione di un dispositivo non esiste più quando si riconnette, è necessario sottoscrivere nuovamente alle sottoscrizioni. Le sessioni persistenti hanno una durata limitata e possono scadere quando il dispositivo viene disconnesso per troppo tempo.
## Connect il dispositivo e comunica con AWS IoT Core
Questa sezione presenta alcuni esercizi che consentono di esplorare diversi aspetti della connessione del dispositivo a AWS IoT Core. Per questi esercizi, utilizzerai il [Client di test MQTT](https://console.aws.amazon.com/iot/home#/test) nella console AWS IoT per vedere cosa pubblica il dispositivo e pubblicare messaggi sul dispositivo. Questi esercizi utilizzano il [https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py) di esempio dall'SDK del dispositivo [AWS IoT v2 per Python](https://github.com/aws/aws-iot-device-sdk-python-v2/tree/master/samples#sample-apps-for-the-aws-iot-device-sdk-v2-for-python) e si basano sulla tua esperienza con i tutorial [Guida introduttiva ai AWS IoT Core tutorial](iot-gs.md).
**Topics**
+ [Iscriviti ai filtri per argomenti jolly](#sdk-tutorials-experiment-wild)
+ [Processo sottoscrizioni filtro dell’argomento](#sdk-tutorials-experiment-process)
+ [Pubblica messaggi dal tuo dispositivo](#sdk-tutorials-experiment-publish)
Per questi esercizi, inizierai dal programma di esempio `pubsub.py`.
**Nota**
Questi esercizi presuppongono che tu abbia completato i tutorial [Guida introduttiva ai AWS IoT Core tutorial](iot-gs.md) e abbia utilizzato la finestra del terminale per il dispositivo da quel tutorial.
### Iscriviti ai filtri per argomenti jolly
In questo esercizio, modificherai la riga di comando utilizzata per chiamare `pubsub.py` per sottoscrivere un filtro dell’argomento con caratteri jolly ed elaborare i messaggi ricevuti in base all'argomento del messaggio.
#### Procedura dell’esercizio
Per questo esercizio, immagina che il dispositivo contenga un controllo della temperatura e un controllo della luce. Utilizza questi nomi di argomenti per identificare i messaggi che li riguardano.
1. Prima di iniziare l'esercizio, prova a eseguire questo comando dai tutorial [Guida introduttiva ai AWS IoT Core tutorial](iot-gs.md) sul tuo dispositivo per assicurarti che tutto sia pronto per l'esercizio.
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Dovresti vedere lo stesso output che hai visto nel [Tutorial sulle nozioni di base](connecting-to-existing-device.md#gs-device-node-app-run).
1. Per questo esercizio, modifica questi parametri della riga di comando.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/sdk-tutorials.html)
L'esecuzione di queste modifiche alla riga di comando iniziale si traduce in questa riga di comando. Inserisci questo comando nella finestra del terminale per il tuo dispositivo.
```
python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Il programma dovrebbe mostrare qualcosa del genere:
```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-24d7cdcc-cc01-458c-8488-2d05849691e1'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
```
Se vedi qualcosa di simile sul tuo terminale, il tuo dispositivo è pronto e ascolta i messaggi in cui i nomi degli argomenti iniziano con `device` e terminano con `/detail`. Quindi, è il momento di provare.
1. Di seguito sono riportati un paio di messaggi che il dispositivo potrebbe ricevere.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/sdk-tutorials.html)
1. Utilizzando il client di test MQTT nella AWS IoT console, inviate i messaggi descritti nel passaggio precedente al dispositivo.
1. Apri il [client di test MQTT](https://console.aws.amazon.com/iot/home#/test) nella AWS IoT console.
1. In **Subscribe to a topic (Sottoscrivi un argomento)** nel campo **Subscription topic field (Argomento sottoscrizione)**, inserisci il filtro dell’argomento: **device/\$1/details**, quindi scegli **Subscribe to topic (Sottoscrivi nell’argomento)**.
1. Nella colonna **Subscriptions (Sottoscrizioni)** del client di test MQTT, seleziona **device/\$1/details (dispositivo/\$1/dettagli)**.
1. Per ciascuno degli argomenti della tabella precedente, esegui le operazioni seguenti nel client di test MQTT:
1. In **Publish (Pubblica)**, inserisci il valore dalla colonna **Topic name (Nome argomento)** nella tabella.
1. Nel campo del payload del messaggio sotto il nome dell'argomento, inserisci il valore della colonna **Message payload (Payload del messaggio)** nella tabella.
1. Guarda la finestra del terminale dove `pubsub.py` è in esecuzione e, nel client di test MQTT, scegli **Publish to topic (Pubblicazione nell'argomento)**.
Dovresti vedere che il messaggio è stato ricevuto da `pubsub.py` nella finestra del terminale.
#### Risultato dell'esercizio
Con questo `pubsub.py` sottoscritto ai messaggi utilizzando un filtro argomento jolly, li ha ricevuti e visualizzati nella finestra del terminale. Si noti come si è sottoscritto a un singolo filtro dell’argomento e la funzione di callback è stata chiamata per elaborare i messaggi con due argomenti distinti.
### Processo sottoscrizioni filtro dell’argomento
Basandosi sull'esercizio precedente, modifica l’app di esempio `pubsub.py` per valutare gli argomenti dei messaggi ed elaborare i messaggi sottoscritti in base all'argomento.
#### Procedura dell’esercizio
**Per valutare l'argomento del messaggio**
1. Copia `pubsub.py` su `pubsub2.py`.
1. Apri `pubsub2.py` nell'editor di testo preferito o in IDE.
1. In `pubsub2.py`, trova la funzione `on_message_received`.
1. In `on_message_received`, inserisci il codice seguente dopo la riga che inizia con `print("Received message` e prima della riga che inizia con `global received_count`.
```
topic_parsed = False
if "/" in topic:
parsed_topic = topic.split("/")
if len(parsed_topic) == 3:
# this topic has the correct format
if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'):
# this is a topic we care about, so check the 2nd element
if (parsed_topic[1] == 'temp'):
print("Received temperature request: {}".format(payload))
topic_parsed = True
if (parsed_topic[1] == 'light'):
print("Received light request: {}".format(payload))
topic_parsed = True
if not topic_parsed:
print("Unrecognized message topic.")
```
1. Salva le modifiche ed esegui il programma modificato utilizzando questa riga di comando.
```
python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
1. Nella AWS IoT console, aprite il client di [test MQTT](https://console.aws.amazon.com/iot/home#/test).
1. In **Subscribe to a topic (Sottoscrivi un argomento)** nel campo **Subscription topic field (Argomento sottoscrizione)**, inserisci il filtro dell’argomento: **device/\$1/details**, quindi scegli **Subscribe to topic (Sottoscrivi nell’argomento)**.
1. Nella colonna **Subscriptions (Sottoscrizioni)** del client di test MQTT, seleziona **device/\$1/details (dispositivo/\$1/dettagli)**.
1. Per ciascuno degli argomenti di questa tabella, esegui le operazioni seguenti nel client di test MQTT:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/sdk-tutorials.html)
1. In **Publish (Pubblica)**, inserisci il valore dalla colonna **Topic name (Nome argomento)** nella tabella.
1. Nel campo del payload del messaggio sotto il nome dell'argomento, inserisci il valore della colonna **Message payload (Payload del messaggio)** nella tabella.
1. Guarda la finestra del terminale dove `pubsub.py` è in esecuzione e, nel client di test MQTT, scegli **Publish to topic (Pubblicazione nell'argomento)**.
Dovresti vedere che il messaggio è stato ricevuto da `pubsub.py` nella finestra del terminale.
Dovrebbe essere visualizzato un elemento simile a quello nella finestra del terminale.
```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100, "currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp": 15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!
```
#### Risultato dell'esercizio
In questo esercizio è stato aggiunto il codice in modo che l'app di esempio riconosca ed elabori più messaggi nella funzione di callback. Con questo, il tuo dispositivo potrebbe ricevere messaggi e agire su di essi.
Un altro modo per consentire al tuo dispositivo di ricevere e processare diversi messaggi separatamente e assegnare ogni abbonamento alla propria funzione di callback.
### Pubblica messaggi dal tuo dispositivo
È possibile utilizzare l'app di esempio pubsub.py per pubblicare messaggi dal dispositivo. Mentre pubblicherà i messaggi così com’è, i messaggi non possono essere letti come documenti JSON. Questo esercizio modifica l'app di esempio per poter pubblicare documenti JSON nel payload dei messaggi che possono essere letti da. AWS IoT Core
#### Procedura dell’esercizio
In questo esercizio, il seguente messaggio verrà inviato con l’argomento `device/data`.
```
{
"timestamp": 1601048303,
"sensorId": 28,
"sensorData": [
{
"sensorName": "Wind speed",
"sensorValue": 34.2211224
}
]
}
```
**Per preparare il client di test MQTT per monitorare i messaggi di questo esercizio**
1. In **Subscribe to a topic (Sottoscrivi un argomento)** nel campo **Subscription topic field (Argomento sottoscrizione)**, inserisci il filtro dell’argomento: **device/data**, quindi scegli **Subscribe to topic (Sottoscrivi nell’argomento)**.
1. Nella colonna **Subscriptions (Sottoscrizioni)** del client di test MQTT, seleziona **device/details (dispositivo/dati)**.
1. Tieni aperta la finestra del client di test MQTT per attendere i messaggi dal tuo dispositivo.
**Per inviare documenti JSON con l'app di esempio pubsub.py**
1. Sul dispositivo, copia `pubsub.py` su `pubsub3.py`.
1. Modifica `pubsub3.py` per cambiare il modo in cui formatta i messaggi pubblicati.
1. Aprire `pubsub3.py` in un editor di testo.
1. Individua la riga di codice:
`message = "{} [{}]".format(message_string, publish_count)`
1. Modificalo in:
`message = "{}".format(message_string)`
1. Individua la riga di codice:
`message_json = json.dumps(message)`
1. Modificalo in:
`message = "{}".json.dumps(json.loads(message))`
1. Salvare le modifiche.
1. Sul dispositivo, esegui questo comando per inviare il messaggio due volte.
```
python3 pubsub3.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --topic device/data --count 2 --message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}' --endpoint your-iot-endpoint
```
1. Nel client di test MQTT, verifica che abbia interpretato e formattato il documento JSON nel payload del messaggio, ad esempio:
![\[Immagine che mostra come viene visualizzato il payload di un messaggio JSON nel client MQTT della console. AWS IoT\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/images/mqtt-test-client-output.png)
Per impostazione predefinita, `pubsub3.py` effettua la sottoscrizione anche ai messaggi che invia. Dovresti vedere che ha ricevuto i messaggi nell'output dell'app. La finestra del terminale dovrebbe essere simile a questa.
```
Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!
```
#### Risultato dell’esercizio
In questo modo, il dispositivo può generare messaggi da inviare per AWS IoT Core testare la connettività di base e fornire messaggi da elaborare. AWS IoT Core Ad esempio, puoi utilizzare questa app per inviare dati di test dal tuo dispositivo per testare le azioni delle AWS IoT regole.
## Rivedi i risultati
Gli esempi di questo tutorial ti hanno fornito un'esperienza pratica sulle nozioni di base con cui i dispositivi possono comunicare, AWS IoT Core una parte fondamentale della tua soluzione. AWS IoT Quando i dispositivi sono in grado di comunicare AWS IoT Core, possono trasmettere messaggi ai AWS servizi e ad altri dispositivi su cui possono agire. Allo stesso modo, AWS i servizi e gli altri dispositivi possono elaborare informazioni che generano l'invio di messaggi ai dispositivi dell'utente.
Quando sei pronto per AWS IoT Core approfondire, prova questi tutorial:
+ [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: Utilizzo del SDK per dispositivi AWS IoT per Embedded C
Questa sezione descrive come eseguire SDK per dispositivi AWS IoT per Embedded C.
**Topics**
+ [Passaggio 1: installare il SDK per dispositivi AWS IoT per Embedded C](#install-embedded-c-sdk)
+ [Fase 2: configurare l'app di esempio](#iot-c-sdk-app-config)
+ [Fase 3: Crea ed esegui l'applicazione di esempio](#iot-c-sdk-app-run)
## Passaggio 1: installare il SDK per dispositivi AWS IoT per Embedded C
SDK per dispositivi AWS IoT per Embedded C È generalmente destinato a dispositivi con risorse limitate che richiedono un runtime ottimizzato in linguaggio C. È possibile utilizzare l'SDK su qualsiasi sistema operativo e ospitarlo su qualsiasi tipo di processore (ad esempio, MCUs e). MPUs Se disponi di più risorse di memoria ed elaborazione, ti consigliamo di utilizzare uno dei AWS IoT dispositivi e dispositivi mobili di ordine superiore SDKs (ad esempio, C\$1\$1 JavaScript, Java e Python).
In generale, SDK per dispositivi AWS IoT per Embedded C è destinato a sistemi che utilizzano MCUs o di fascia bassa MPUs che eseguono sistemi operativi integrati. Per l'esempio di programmazione in questa sezione, presumiamo che il tuo dispositivo utilizzi Linux.
**Example**
1. Scaricalo sul SDK per dispositivi AWS IoT per Embedded C tuo dispositivo da [GitHub](https://github.com/aws/aws-iot-device-sdk-embedded-C).
```
git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git --recurse-submodules
```
Questo crea una directory denominata `aws-iot-device-sdk-embedded-c` nella directory corrente.
1. Passa a quella directory ed estrai la versione più recente. Consulta [github. com/aws/aws-iot-device-sdk-embedded-C/tags](https://github.com/aws/aws-iot-device-sdk-embedded-C/tags)per il tag dell'ultima versione.
```
cd aws-iot-device-sdk-embedded-c
git checkout latest-release-tag
```
1. Installa OpenSSL versione 1.1.0 o successiva. Le librerie di sviluppo OpenSSL sono solitamente chiamate “libssl-dev” o “openssl-devel” quando installate tramite un gestore di pacchetti.
```
sudo apt-get install libssl-dev
```
## Fase 2: configurare l'app di esempio
SDK per dispositivi AWS IoT per Embedded C Include applicazioni di esempio da provare. Per semplicità, questo tutorial utilizza l'`mqtt_demo_mutual_auth`applicazione, che illustra come connettersi al broker di AWS IoT Core messaggi e iscriversi e pubblicare su argomenti MQTT.
1. Copia nella directory `build/bin/certificates` il certificato e la chiave privata che hai creato in [Guida introduttiva ai AWS IoT Core tutorial](iot-gs.md).
**Nota**
I certificati emessi da una CA root e dei dispositivi sono soggetti a scadenza o revoca. Se i certificati scadono o vengono revocati, è necessario copiare sul dispositivo un nuovo certificato emesso da una CA o una chiave privata e un certificato del dispositivo.
1. È necessario configurare l'esempio con l' AWS IoT Core endpoint personale, la chiave privata, il certificato e il certificato CA principale. Passa alla directory `aws-iot-device-sdk-embedded-c/demos/mqtt/mqtt_demo_mutual_auth`.
Se lo hai AWS CLI installato, puoi usare questo comando per trovare l'URL dell'endpoint del tuo account.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Se non lo hai AWS CLI installato, apri la [AWS IoT console](https://console.aws.amazon.com/iot/home). Nel pannello di navigazione scegliere **Manage (Gestisci)**, quindi **Things (Oggetti)**. Seleziona l'oggetto IoT per il dispositivo, quindi seleziona **Interact (Interagisci)**. L'endpoint viene visualizzato nella sezione **HTTPS** della pagina dei dettagli degli oggetti.
1. Apri il file `demo_config.h` e aggiorna i valori per gli elementi seguenti:
AWS\$1IOT\$1ENDPOINT
Endpoint personale.
CLIENT\$1CERT\$1PATH
Il percorso del file del certificato, ad esempio `certificates/device.pem.crt"`.
CLIENT\$1PRIVATE\$1KEY\$1PATH
Il nome del file della chiave privata, ad esempio `certificates/private.pem.key`.
Per esempio:
```
// Get from demo_config.h
// =================================================
#define AWS_IOT_ENDPOINT "my-endpoint-ats.iot.us-east-1.amazonaws.com"
#define AWS_MQTT_PORT 8883
#define CLIENT_IDENTIFIER "testclient"
#define ROOT_CA_CERT_PATH "certificates/AmazonRootCA1.crt"
#define CLIENT_CERT_PATH "certificates/my-device-cert.pem.crt"
#define CLIENT_PRIVATE_KEY_PATH "certificates/my-device-private-key.pem.key"
// =================================================
```
1. Controlla se hai CMake installato sul tuo dispositivo usando questo comando.
```
cmake --version
```
Se visualizzi le informazioni sulla versione per il compilatore, puoi passare alla sezione successiva.
Se ricevi un errore o non vedi alcuna informazione, dovrai installare il pacchetto CMake utilizzando questo comando.
```
sudo apt-get install cmake
```
Esegui nuovamente il **cmake --version** comando e conferma che è CMake stato installato e che sei pronto per continuare.
1. Controlla di aver installato gli strumenti di sviluppo sul dispositivo usando questo comando.
```
gcc --version
```
Se visualizzi le informazioni sulla versione per il compilatore, puoi passare alla sezione successiva.
Se ricevi un errore o non vedi alcuna informazione del compilatore, dovrai installare il pacchetto `build-essential` usando questo comando.
```
sudo apt-get install build-essential
```
Esegui nuovamente il comando **gcc --version** e conferma che gli strumenti di compilazione sono stati installati e di essere pronto a continuare.
## Fase 3: Crea ed esegui l'applicazione di esempio
Questa procedura spiega come generare l'`mqtt_demo_mutual_auth`applicazione sul dispositivo e collegarla alla [AWS IoT console](https://console.aws.amazon.com/iot/home) utilizzando il. SDK per dispositivi AWS IoT per Embedded C
**Per eseguire le applicazioni di esempio SDK per dispositivi AWS IoT per Embedded C**
1. Passa a `aws-iot-device-sdk-embedded-c` e crea una directory di compilazione.
```
mkdir build && cd build
```
1. Immettete il seguente CMake comando per generare i Makefile necessari per la compilazione.
```
cmake ..
```
1. Inserisci il comando seguente per creare l’app del file eseguibile.
```
make
```
1. Esegui l'app `mqtt_demo_mutual_auth` con questo comando.
```
cd bin
./mqtt_demo_mutual_auth
```
Verrà visualizzato un output simile al seguente:
![\[Output della riga di comando per l'esecuzione dell'applicazione SDK per dispositivi AWS IoT per Embedded C di esempio.\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/images/successful-run2.png)
Il dispositivo è ora connesso AWS IoT tramite SDK per dispositivi AWS IoT per Embedded C.
È inoltre possibile utilizzare la AWS IoT console per visualizzare i messaggi MQTT pubblicati dall'app di esempio. Per informazioni su come utilizzare il client MQTT nella [console AWS IoT](https://console.aws.amazon.com/iot/home), consulta [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md).
# 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).
# Mantenimento dello stato del dispositivo mentre il dispositivo è disconnesso da Device Shadows
Questi tutorial mostrano come utilizzare il servizio AWS IoT Device Shadow per archiviare e aggiornare le informazioni sullo stato di un dispositivo. Il documento Shadow, che è un documento JSON, mostra la modifica dello stato del dispositivo in base ai messaggi pubblicati da un dispositivo, un'app locale o un servizio. In questo tutorial, il documento Shadow mostra la modifica del colore di una lampadina. Questi tutorial mostrano anche come Shadow archivia queste informazioni anche quando il dispositivo è disconnesso da Internet e trasmette le informazioni più recenti sullo stato al dispositivo quando torna online e richiede queste informazioni.
Ti consigliamo di provare questi tutorial nell'ordine in cui sono mostrati qui, a partire dalle risorse AWS IoT necessarie per creare e la configurazione hardware necessaria, che consente anche di apprendere i concetti in modo incrementale. Questi tutorial mostrano come configurare e connettere un dispositivo Raspberry Pi da utilizzare con. AWS IoT Se non si dispone dell'hardware necessario, è possibile seguire questi tutorial adattandoli a un dispositivo di propria scelta o con la [creazione di un dispositivo virtuale con Amazon EC2](creating-a-virtual-thing.md).
**Panoramica dello scenario tutorial**
Lo scenario di questi tutorial è un'app o un servizio locale che cambia il colore di una lampadina e che pubblica i dati in argomenti shadow riservati. Questi tutorial sono simili alla funzionalità Device Shadow descritta in [Interactive getting started tutorial (Tutorial interattivo sulle nozioni di base)](interactive-demo.md) e sono implementati su un dispositivo Raspberry Pi. I tutorial in questa sezione si concentrano su una singola shadow classica, mostrando il modo in cui è possibile inserire le shadow o più dispositivi.
I seguenti tutorial ti aiuteranno a imparare a usare il servizio AWS IoT Device Shadow.
+
**[Tutorial: Preparazione del Raspberry Pi per eseguire l'applicazione shadow](create-resources-shadow.md)**
Questo tutorial mostra come configurare un dispositivo Raspberry Pi con cui connettersi. AWS IoT Potrai anche creare un documento di AWS IoT policy e una risorsa, scaricare i certificati e quindi allegare la policy a quella risorsa. Questo tutorial dura circa 30 minuti.
+
**[Tutorial: Installare l'SDK di dispositivo ed eseguire l’applicazione di esempio per Device Shadows](lightbulb-shadow-application.md)**
Questo tutorial mostra come installare gli strumenti, il software e il AWS IoT Device SDK for Python necessari, quindi eseguire l'applicazione shadow di esempio. Questo tutorial si basa sui concetti presentati in [Connettere un Raspberry Pi o altro dispositivo](connecting-to-existing-device.md) e il completamento richiede 20 minuti.
+
**[Tutorial: Interagisci con Device Shadow utilizzando l’app di esempio e il client di test MQTT](interact-lights-device-shadows.md)**
Questo tutorial mostra come utilizzare l'app e la **AWS IoT console** di `shadow.py` esempio per osservare l'interazione tra AWS IoT Device Shadows e i cambiamenti di stato della lampadina. Il tutorial mostra anche come inviare messaggi MQTT agli argomenti riservati di Device Shadow. Questo tutorial dura circa 45 minuti.
**AWS IoT Panoramica di Device Shadow**
Un Device Shadow è una rappresentazione virtuale persistente di un dispositivo gestito da una [risorsa oggetto](iot-thing-management.md) creata nel AWS IoT registro. Il documento Shadow è un documento JSON o di JavaScript notazione utilizzato per archiviare e recuperare le informazioni sullo stato corrente di un dispositivo. È possibile utilizzare lo shadow per ottenere e impostare lo stato di un dispositivo tramite argomenti MQTT o HTTP REST APIs, indipendentemente dal fatto che il dispositivo sia connesso a Internet.
Il documento di una copia shadow contiene una proprietà `state` che descrive questi aspetti dello stato del dispositivo.
+ `desired`: le app specificano gli stati desiderati delle proprietà del dispositivo aggiornando l'oggetto `desired`.
+ `reported`: i dispositivi segnalano il loro stato corrente nell'oggetto `reported`.
+ `delta`: AWS IoT riporta le differenze tra lo stato desiderato e quello riportato nell'`delta`oggetto.
Di seguito è illustrato un esempio di documento di uno stato Shadow.
```
{
"state": {
"desired": {
"color": "green"
},
"reported": {
"color": "blue"
},
"delta": {
"color": "green"
}
}
}
```
Per aggiornare il documento Shadow di un dispositivo, è possibile utilizzare gli [argomenti MQTT riservati](reserved-topics.md#reserved-topics-shadow), il [Device Shadow REST APIs](device-shadow-rest-api.md) che supporta `GET``UPDATE`, `DELETE` le operazioni con HTTP e la [AWS IoT CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot-data/index.html).
Nell'esempio precedente, supponiamo che tu voglia modificare il colore `desired` con `yellow`. A tale scopo, invia una richiesta all’API [UpdateThingShadow](device-shadow-rest-api.md#API_UpdateThingShadow) o pubblica un messaggio nell'argomento [Aggiorna](device-shadow-mqtt.md#update-pub-sub-topic), `$aws/things/THING_NAME/shadow/update`.
```
{
"state": {
"desired": {
"color": yellow
}
}
}
```
Gli aggiornamenti interessano solo i campi specificati nella richiesta. Dopo aver aggiornato con successo il Device Shadow, AWS IoT pubblica il nuovo `desired` stato sull'`delta`argomento,`$aws/things/THING_NAME/shadow/delta`. Il documento Shadow in questo caso ha il seguente aspetto:
```
{
"state": {
"desired": {
"color": yellow
},
"reported": {
"color": green
},
"delta": {
"color": yellow
}
}
}
```
Il nuovo stato viene quindi segnalato al AWS IoT Device Shadow utilizzando l'`Update`argomento `$aws/things/THING_NAME/shadow/update` con il seguente messaggio JSON:
```
{
"state": {
"reported": {
"color": yellow
}
}
}
```
Se desideri ottenere le informazioni sullo stato attuale, invia una richiesta all'API [GetThingShadow](device-shadow-rest-api.md#API_GetThingShadow) o pubblica un messaggio MQTT nell’argomento [Ottieni](device-shadow-mqtt.md#get-pub-sub-topic), `$aws/things/THING_NAME/shadow/get`.
Per ulteriori informazioni sul funzionamento del Servizio Device Shadow, consulta [AWS IoT Servizio Device Shadow](iot-device-shadows.md).
Per ulteriori informazioni sull'utilizzo di Device Shadows su dispositivi, app e servizi, consulta [Utilizzo delle copie shadow nei dispositivi](device-shadow-comms-device.md) e [Utilizzo delle copie shadow in app e servizi](device-shadow-comms-app.md).
Per informazioni sull'interazione con le AWS IoT ombre, consulta. [Interazione con le copia shadow](device-shadow-data-flow.md)
Per informazioni sugli argomenti riservati MQTT e HTTP REST APIs, vedere e. [Argomenti MQTT di Device Shadow](device-shadow-mqtt.md) [API REST del servizio Device Shadow](device-shadow-rest-api.md)
# Tutorial: Preparazione del Raspberry Pi per eseguire l'applicazione shadow
Questo tutorial dimostra come impostare e configurare un dispositivo Raspberry Pi e creare le AWS IoT risorse necessarie a un dispositivo per connettersi e scambiare messaggi MQTT.
**Nota**
Se hai intenzione di [Crea un dispositivo virtuale con Amazon EC2](creating-a-virtual-thing.md), è possibile saltare questa pagina e continuare su [Configurazione del dispositivo](configure-device.md). Creerai queste risorse quando creerai l’oggetto virtuale. Se desideri utilizzare un dispositivo diverso invece di Raspberry Pi, puoi provare a seguire questi tutorial adattandoli a un dispositivo di tua scelta.
**In questo tutorial, imparerai come:**
+ Configura un dispositivo Raspberry Pi e configuralo per l'uso con. AWS IoT
+ Crea un documento di AWS IoT policy che autorizzi il tuo dispositivo a interagire con AWS IoT i servizi.
+ Crea una risorsa nei certificati AWS IoT del dispositivo X.509, quindi allega il documento relativo alla policy.
L’oggetto è la rappresentazione virtuale del dispositivo nel registro AWS IoT . Il certificato autentica il dispositivo su AWS IoT Core e il documento di policy autorizza il dispositivo a interagire con. AWS IoT
**Come eseguire questo tutorial**
Per eseguire l’applicazione di esempio `shadow.py` per Device Shadows, avrai bisogno di un dispositivo Raspberry Pi che si connette a AWS IoT. Si consiglia di seguire questo tutorial nell'ordine in cui viene presentato qui, iniziando con la configurazione del Raspberry Pi e dei suoi accessori, e quindi creando una policy e allegando il criterio a una risorsa dell’oggetto che si crea. Puoi quindi seguire questo tutorial utilizzando l'interfaccia utente grafica (GUI) supportata da Raspberry Pi per aprire la AWS IoT console sul browser web del dispositivo, il che semplifica anche il download dei certificati direttamente sul tuo Raspberry Pi per la connessione. AWS IoT
**Prima di iniziare questo tutorial, assicurati di disporre di:**
+ Un. Account AWS Se non disponi dell'account, effettua la procedura descritta in [Configurare Account AWS](setting-up.md), prima di continuare. Avrai bisogno della tua Account AWS AWS IoT console per completare questo tutorial.
+ Il Raspberry Pi e i suoi accessori necessari. Sarà necessario:
+ Un [modello Raspberry Pi 3 B](https://www.raspberrypi.com/products/) o più recente. Questo tutorial potrebbe funzionare su versioni precedenti del Raspberry Pi, ma non sono state testate.
+ [Sistema operativo Raspberry Pi (32 bit)](https://www.raspberrypi.com/software/operating-systems/) o versione successiva. Ti consigliamo di utilizzare sempre la versione più recente del sistema operativo Raspberry Pi. Le versioni precedenti del sistema operativo potrebbero funzionare, ma non le abbiamo testate.
+ Una connessione Ethernet o Wi-Fi.
+ Tastiera, mouse, monitor, cavi e alimentatori.
Questo tutorial dura circa 30 minuti.
## Fase 1: Imposta e configura il dispositivo Raspberry Pi
In questa sezione, configureremo un dispositivo Raspberry Pi da utilizzare con AWS IoT.
**Importante**
Adattare queste istruzioni ad altri dispositivi e sistemi operativi può essere difficile. Dovrai avere una buona capacità di utilizzare il tuo dispositivo in modo da poter interpretare queste istruzioni e applicarle ad esso. In caso di difficoltà, è possibile provare una delle altre opzioni del dispositivo come alternativa, come [Crea un dispositivo virtuale con Amazon EC2](creating-a-virtual-thing.md) o [Usa il tuo PC o Mac Windows o Linux come dispositivo AWS IoT](using-laptop-as-device.md).
Dovrai configurare il tuo Raspberry Pi in modo che possa avviare il sistema operativo (OS), connettersi a Internet e consentirti di interagire con esso tramite un'interfaccia a riga di comando. Puoi anche utilizzare l'interfaccia utente grafica (GUI) supportata con Raspberry Pi per aprire la AWS IoT console ed eseguire il resto di questo tutorial.
**Per impostare Raspberry Pi**
1. Inserire la scheda SD nello slot per schede MicroSD nel Raspberry Pi. Alcune schede SD sono precaricate con un gestore di installazione che richiede tramite un menu di installare il sistema operativo dopo l'avvio del modulo. È inoltre possibile utilizzare l'imager Raspberry Pi per installare il sistema operativo sulla scheda.
1. Connetti un televisore HDMI o un monitor al cavo HDMI che si collega alla porta HDMI del Raspberry Pi.
1. Connetti la tastiera e il mouse alle porte USB del Raspberry Pi, quindi collega l'adattatore di alimentazione per avviare la scheda.
Dopo l'avvio del Raspberry Pi, se la scheda SD è stata precaricata con il gestore di installazione, viene visualizzato un menu per installare il sistema operativo. Se hai problemi nell'installazione del sistema operativo, puoi provare a eseguire la procedura riportata di seguito. Per informazioni sull’impostazione di Raspberry Pi, consulta [Impostazione di Raspberry Pi](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/).
**In caso di problemi nell’impostazione di Raspberry Pi:**
+ Verifica se è stata inserita la scheda SD prima di avviare la scheda. Se si collega la scheda SD dopo l'avvio del modulo, il menu di installazione potrebbe non essere visualizzato.
+ Assicurati che il televisore o il monitor sia acceso e che sia selezionato l'ingresso corretto.
+ Assicurati di utilizzare il software compatibile con Raspberry Pi.
Dopo aver installato e configurato il sistema operativo Raspberry Pi, apri il browser Web di Raspberry Pi e accedi alla AWS IoT Core console per continuare il resto dei passaggi di questo tutorial.
Se riesci ad aprire la AWS IoT Core console, il tuo Raspberry Pi è pronto e puoi continuare a farlo. [Tutorial: Eseguire il provisioning del dispositivo in AWS IoT](shadow-provision-cloud.md)
In caso di problemi o di bisogno di ulteriore assistenza, consulta la sezione [Getting help for your Raspberry Pi (Ottenere assistenza per Raspberry Pi)](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/5).
# Tutorial: Eseguire il provisioning del dispositivo in AWS IoT
Questa sezione crea le AWS IoT Core risorse che verranno utilizzate dal tutorial.
**Topics**
+ [Fase 1: Creare una AWS IoT policy per il Device Shadow](#create-policy-shadow)
+ [Fase 2: creare una risorsa dell’oggetto e connettere la policy all’oggetto](#create-thing-shadow)
+ [Fase 3: Esamina i risultati e i passaggi successivi](#resources-shadow-review)
## Fase 1: Creare una AWS IoT policy per il Device Shadow
I certificati X.509 autenticano il dispositivo con. AWS IoT Core AWS IoT al certificato sono allegate politiche che consentono al dispositivo di eseguire AWS IoT operazioni, come la sottoscrizione o la pubblicazione di argomenti riservati MQTT utilizzati dal servizio Device Shadow. Il dispositivo presenta il certificato quando si connette e invia messaggi a. AWS IoT Core
In questa procedura creerai un policy che consente di eseguire le operazioni AWS IoT necessarie per eseguire il programma di esempio. Ti consigliamo di creare una policy che conceda solo le autorizzazioni richieste per eseguire l'attività. Prima crei la AWS IoT policy e poi la alleghi al certificato del dispositivo che creerai in seguito.
**Per creare una AWS IoT politica**
1. Nel menu di sinistra scegli **Secure (Sicurezza)** e quindi **Policies (Policy)**. Se il tuo account dispone di policy esistenti, scegli **Create (Crea)**; in caso contrario, nella pagina **You don’t have a policy yet (Non hai ancora una policy)** scegli **Create a policy (Crea una policy)**.
1. Nella pagina **Create a policy (Crea una policy)**:
1. Nel campo **Name (Nome)** inserire un nome per la policy (ad esempio **My\$1Device\$1Shadow\$1policy**). Non utilizzare dati personali identificabili nei nomi delle policy.
1. Nel documento di policy vengono descritte le operazioni di connessione, sottoscrizione, ricezione e pubblicazione che consentono al dispositivo l’autorizzazione di pubblicare e sottoscrivere gli argomenti riservati MQTT.
Copia la policy di esempio seguente e incollala nel documento di policy. Sostituiscilo `thingname` con il nome dell'oggetto che creerai (ad esempio,`My_light_bulb`), `region` con la AWS IoT regione in cui utilizzi i servizi e `account` con il tuo Account AWS numero. Per ulteriori informazioni sulle AWS IoT politiche, consulta[AWS IoT Core politiche](iot-policies.md).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/test-*"
}
]
}
```
## Fase 2: creare una risorsa dell’oggetto e connettere la policy all’oggetto
I dispositivi collegati a AWS IoT possono essere rappresentati dalle *risorse* degli oggetti presenti nel AWS IoT registro. Una *risorsa dell’oggetto* rappresenta un dispositivo specifico o un'entità logica, come la lampadina in questo tutorial.
Per imparare a creare un oggetto in AWS IoT, segui i passaggi descritti in[Crea un oggetto](create-iot-resources.md#create-aws-thing). Ecco alcune cose fondamentali da notare mentre segui i passaggi di tale tutorial:
1. Scegli **Create a single thing (Crea un oggetto singolo)**, e nel campo **Name (Nome)** inserisci un nome per l'oggetto che è uguale a quello del `thingname` (ad esempio, `My_light_bulb`) che hai specificato quando hai creato la policy in precedenza.
Non è possibile modificare il nome di un oggetto dopo averlo creato. Se gli hai dato un nome diverso da `thingname`, crea un nuovo oggetto con nome `thingname` ed elimina il vecchio oggetto.
**Nota**
Non utilizzare dati personali identificabili nel nome dell’oggetto. Il nome dell’oggetto può essere visualizzato nelle comunicazioni e nei report non crittografati.
1. Si consiglia di scaricare ciascuno dei file di certificato nella pagina **Certificato creato\$1** in una posizione in cui è possibile trovarli facilmente. È necessario installare questi file per eseguire l'applicazione di esempio.
Ti consigliamo di scaricare i file in una sottodirectory `certs` nella directory `home` sul Raspberry Pi e nominare ciascuno di essi con un nome più semplice come suggerito nella tabella seguente.
**Nomi dei file dei certificati**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/shadow-provision-cloud.html)
1. Dopo aver attivato il certificato a cui abilitare le connessioni AWS IoT, scegli **Allega una politica** e assicurati di allegare la politica che hai creato in precedenza (ad esempio**My\$1Device\$1Shadow\$1policy**) all'oggetto.
Dopo aver creato un oggetto, puoi vedere la risorsa relativa all'oggetto visualizzata nell'elenco degli elementi nella AWS IoT console.
## Fase 3: Esamina i risultati e i passaggi successivi
**In questo tutorial, hai appreso come:**
+ Impostare e configurare il dispositivo Raspberry Pi.
+ Crea un documento di AWS IoT policy che autorizzi il tuo dispositivo a interagire con AWS IoT i servizi.
+ Creare una risorsa dell’oggetto e il certificato del dispositivo X.509 associato e collegare il documento della policy ad esso.
**Fasi successive**
Ora puoi installare l'SDK del AWS IoT dispositivo per Python, eseguire `shadow.py` l'applicazione di esempio e utilizzare Device Shadows per controllare lo stato. Per ulteriori informazioni su come eseguire questo tutorial, consulta [Tutorial: Installare l'SDK di dispositivo ed eseguire l’applicazione di esempio per Device Shadows](lightbulb-shadow-application.md).
# Tutorial: Installare l'SDK di dispositivo ed eseguire l’applicazione di esempio per Device Shadows
Questa sezione mostra come installare il software richiesto e AWS IoT Device SDK for Python ed eseguire `shadow.py` l'applicazione di esempio per modificare il documento Shadow e controllare lo stato dell'ombra.
**In questo tutorial, apprenderai come:**
+ Usa il software installato e AWS IoT Device SDK for Python per eseguire l'app di esempio.
+ Scoprire come l'immissione di un valore utilizzando l'app di esempio pubblichi il valore desiderato nella console AWS IoT .
+ Esaminare l’applicazione di esempio `shadow.py` e come utilizzare il protocollo MQTT per aggiornare lo stato di shadow.
**Prima di eseguire questo tutorial:**
È necessario aver configurato Account AWS, configurato il dispositivo Raspberry Pi e creato una AWS IoT cosa e una politica che consentano al dispositivo le autorizzazioni per pubblicare e sottoscrivere gli argomenti riservati MQTT del servizio Device Shadow. Per ulteriori informazioni, consulta [Tutorial: Preparazione del Raspberry Pi per eseguire l'applicazione shadow](create-resources-shadow.md).
Devi aver installato anche Git, Python e AWS IoT Device SDK for Python. Questo tutorial si basa sui concetti presentati nel tutorial [Connettere un Raspberry Pi o altro dispositivo](connecting-to-existing-device.md). Se non hai provato questo tutorial, ti consigliamo di seguire i passaggi descritti in tale tutorial per installare i file dei certificati e SDK di dispositivo e quindi tornare a questo tutorial per eseguire l’applicazione di esempio `shadow.py`.
**Topics**
+ [Fase 1: eseguire l'app di esempio shadow.py](#run-sample-application-shadows)
+ [Fase 2: Revisione dell'app di esempio shadow.py dell'SDK di dispositivo](#review-shadow-sample-code)
+ [Fase 3: Risolvi i problemi con l’app di esempio `shadow.py`](#shadow-sample-app-troubleshoot)
+ [Fase 4: Esamina i risultati e i passaggi successivi](#sample-app-shadow-review)
Questo tutorial dura circa 20 minuti.
## Fase 1: eseguire l'app di esempio shadow.py
Prima di eseguire il comando l’app di esempio `shadow.py`, oltre ai nomi e alla posizione dei file di certificato installati, sono necessarie le seguenti informazioni.
**Valori dei parametri dell'applicazione**
| Parametro | Dove trovare il valore |
| --- | --- |
| your-iot-thing-name | Nome della AWS IoT cosa che hai creato in precedenza in. [Fase 2: creare una risorsa dell’oggetto e connettere la policy all’oggetto](shadow-provision-cloud.md#create-thing-shadow) Per trovare questo valore, nella [console AWS IoT](https://console.aws.amazon.com/iot/home), scegli **Manage (Gestione)**, quindi scegli **Things (Oggetti)**. |
| your-iot-endpoint | Il *your-iot-endpoint* valore ha un formato di:`endpoint_id-ats.iot.region.amazonaws.com`, ad esempio,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`. Per trovare questo valore: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/lightbulb-shadow-application.html) |
**Installazione ed esecuzione dell'applicazione di esempio**
1. Passare alla directory dell’applicazione di esempio.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
```
1. Nella finestra della riga di comando, sostituisci *your-iot-endpoint* e *your-iot-thing-name* come indicato ed esegui questo comando.
```
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
1. Osserva che l'applicazione di esempio:
1. Si connette al servizio AWS IoT per il tuo account.
1. Effettui la sottoscrizione ad eventi `Delta` e alle risposte `Update` e `Get`.
1. Richieda di inserire un valore desiderato nel terminale.
1. L'output sia simile a quello riportato di seguito:
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow contains reported value 'off'.
Enter desired value:
```
**Nota**
In caso di problemi nell'esecuzione dell’app di esempio `shadow.py`, consulta [Fase 3: Risolvi i problemi con l’app di esempio `shadow.py`](#shadow-sample-app-troubleshoot). Per ottenere ulteriori informazioni che potrebbero essere utili per risolvere il problema, aggiungi il parametro `--verbosity debug` alla riga di comando in modo che l'app di esempio visualizzi messaggi dettagliati su ciò che sta facendo.
**Inserisci i valori e osserva gli aggiornamenti nel documento Shadow**
È possibile inserire i valori nel terminale per specificare il valore `desired`, che aggiorna anche il valore `reported`. Supponiamo di inserire il colore `yellow` nel terminale. Il valore `reported` viene aggiornato anche al colore `yellow`. Di seguito sono riportati i messaggi visualizzati nel terminale:
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Quando pubblichi questa richiesta di aggiornamento, AWS IoT crea un'ombra classica predefinita per la risorsa thing. È possibile osservare la richiesta di aggiornamento pubblicata su `reported` e i `desired` valori nella AWS IoT console esaminando il documento Shadow relativo alla risorsa oggetto che è stata creata (ad esempio,`My_light_bulb`). Per visualizzare l'aggiornamento nel documento Shadow:
1. Nella AWS IoT console, scegli **Gestisci**, quindi scegli **Cose**.
1. Nell'elenco di oggetti visualizzati, seleziona l'oggetto che hai creato, scegli **Shadows**, quindi scegli **Classic Shadow (Shadow classico)**.
Il documento Shadow dovrebbe essere simile a quanto riportato di seguito, mostrando i valori `reported` e `desired` impostati sul colore `yellow`. Questi valori vengono visualizzati nello **Stato shadow** del documento.
```
{
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
}
```
Viene inoltre visualizzato una sezione **Metadata (Metadati)** che contiene le informazioni sul timestamp e il numero di versione della richiesta.
Puoi usare la versione del documento sullo stato per assicurarti di aggiornare la versione più recente di una copia shadow di un dispositivo. Se invii un'altra richiesta di aggiornamento, il numero di versione aumenta di 1. Quando fornisci una versione con una richiesta di aggiornamento, il servizio rifiuta la richiesta con un codice di risposta di conflitto HTTP 409 se la versione corrente del documento sullo stato non corrisponde alla versione fornita.
```
{
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
}
},
"version": 10
}
```
Per saperne di più sul documento Shadow e osservare le modifiche alle informazioni sullo stato, procedi con il tutorial successivo [Tutorial: Interagisci con Device Shadow utilizzando l’app di esempio e il client di test MQTT](interact-lights-device-shadows.md) come descritto nella sezione [Fase 4: Esamina i risultati e i passaggi successivi](#sample-app-shadow-review) di questo tutorial. Eventualmente, si può anche sapere di più sul codice di esempio `shadow.py` e su come utilizza il protocollo MQTT nella sezione seguente.
## Fase 2: Revisione dell'app di esempio shadow.py dell'SDK di dispositivo
Questa sezione esamina l’app di esempio `shadow.py` dal **SDK di dispositivo v2 AWS IoT per Python**, usata in questo tutorial. Qui esamineremo come si connette AWS IoT Core utilizzando il protocollo MQTT e MQTT su WSS. La libreria [AWS Common Runtime (AWS-CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) fornisce il supporto del protocollo di comunicazione di basso livello ed è inclusa in AWS IoT Device SDK v2 for Python.
Sebbene questo tutorial utilizzi MQTT e MQTT su WSS, supporta i dispositivi che pubblicano richieste HTTPS. AWS IoT Per un esempio di un programma Python che invia un messaggio HTTP da un dispositivo, vedi l’[esempio di codice HTTPS](http.md#codeexample) utilizzando la libreria di Python `requests`.
Per informazioni su come prendere una decisione informata sul protocollo da utilizzare per le comunicazioni del dispositivo, consulta [Scelta di un protocollo applicativo per la comunicazione del dispositivo](protocols.md#protocol-selection).
**MQTT**
L'esempio `shadow.py` chiama `mtls_from_path` (mostrato qui) in [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) per stabilire una connessione con AWS IoT Core utilizzando il protocollo MQTT. `mtls_from_path` utilizza i certificati X.509 e TLS v1.2 per autenticare il dispositivo. La libreria AWS-CRT gestisce i dettagli di livello inferiore di quella connessione.
```
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=args.endpoint,
cert_filepath=args.cert,
pri_key_filepath=args.key,
ca_filepath=args.ca_file,
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
+ `endpoint`è l' AWS IoT endpoint che hai passato dalla riga di comando ed `client_id` è l'ID che identifica in modo univoco questo dispositivo in. Regione AWS
+ `cert_filepath`, `pri_key_filepath` e `ca_filepath` sono i percorsi del certificato e dei file di chiave privata del dispositivo e del file root CA.
+ `client_bootstrap` è l'oggetto runtime comune che gestisce le attività di comunicazione socket e viene istanziato prima della chiamata a `mqtt_connection_builder.mtls_from_path`.
+ `on_connection_interrupted` e `on_connection_resumed` sono le funzioni di callback da chiamare quando la connessione del dispositivo viene interrotta e ripresa.
+ `clean_session` consente di avviare una nuova sessione persistente o, se è presente, di riconnettersi a una esistente. `keep_alive_secs` è il valore keep alive, in secondi, per inviare la richiesta `CONNECT`. Un ping verrà inviato automaticamente a questo intervallo. Se il server non riceve un ping dopo 1,5 volte questo valore, presuppone che la connessione sia stata persa.
L’esempio `shadow.py` chiama anche `websockets_with_default_aws_signing` in [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) per stabilire una connessione con AWS IoT Core utilizzando il protocollo MQTT su WSS. MQTT su WSS utilizza anche gli stessi parametri di MQTT e prende questi parametri aggiuntivi:
+ `region`è la regione di AWS firma utilizzata dall'autenticazione Signature V4 e `credentials_provider` sono AWS le credenziali fornite da utilizzare per l'autenticazione. La regione viene passata dalla riga di comando, e l’oggetto `credentials_provider` viene istanziato appena prima della chiamata a `mqtt_connection_builder.websockets_with_default_aws_signing`.
+ `websocket_proxy_options` sono le opzioni proxy HTTP, se si utilizza un host proxy. Nell’app di esempio `shadow.py`, questo valore viene istanziato appena prima della chiamata a `mqtt_connection_builder.websockets_with_default_aws_signing`.
**Iscrizione agli argomenti e agli eventi Shadow**
L’esempio `shadow.py` cerca di stabilire una connessione e attende di essere completamente connesso. Se non è connesso, i comandi vengono messi in coda. Una volta connesso, l'esempio sottoscrive gli eventi delta e aggiorna e riceve i messaggi e pubblica i messaggi con un livello Quality of Service (QoS) pari a 1 (`mqtt.QoS.AT_LEAST_ONCE`).
Quando un dispositivo sottoscrive un messaggio con QoS livello 1, il broker di messaggi salva i messaggi a cui il dispositivo è sottoscritto fino a quando non possono essere inviati al dispositivo. Il broker di messaggi restituisce i messaggi fino a quando non riceve una risposta `PUBACK` dal dispositivo.
Per ulteriori informazioni sul protocollo MQTT, consulta [Esamina il protocollo MQTT](sdk-tutorials.md#sdk-tutorials-mqtt-review) e [MQTT](mqtt.md).
Per ulteriori informazioni su MQTT, MQTT su WSS, sessioni persistenti e i livelli QoS utilizzati in questa esercitazione, consulta [Revisione dell'app di esempio pubsub.py SDK per dispositivi](sdk-tutorials.md#sdk-tutorials-explore-sample).
## Fase 3: Risolvi i problemi con l’app di esempio `shadow.py`
Quando si esegue l’app di esempio `shadow.py`, dovresti vedere alcuni messaggi visualizzati nel terminale e un prompt per inserire un valore `desired`. Se il programma genera un errore, per eseguire il debug dell'errore, puoi iniziare controllando se hai eseguito il comando corretto per il tuo sistema.
In alcuni casi, il messaggio di errore potrebbe indicare problemi di connessione e avere un aspetto simile a: `Host name was invalid for dns resolution` o `Connection was closed unexpectedly`. In questi casi, ecco alcune operazioni disponibili:
+
**Controlla l'indirizzo dell'endpoint nel comando**
Esaminare il parametro `endpoint` nel comando inserito per eseguire l'app di esempio (ad esempio `a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com`) e controllare questo valore nella **console AWS IoT **.
Per verificare se hai utilizzato il valore corretto:
1. Nella **console AWS IoT **, scegli **Manage (Gestione)** e poi **Things (Oggetti)**.
1. Scegli l’oggetto che hai creato per l'app di esempio (ad esempio, **my\$1light\$1lampadina**) e quindi scegli **Interact (Interagisci)**.
L'endpoint viene visualizzato nella sezione ** HTTPS** della pagina dei dettagli degli oggetti. Dovresti visualizzare anche un messaggio in cui viene indicato: `This thing already appears to be connected.`
+
**Verifica l'attivazione del certificato**
I certificati autenticano il dispositivo con. AWS IoT Core
Per verificare se il certificato è attivo:
1. Nella **console AWS IoT **, scegli **Manage (Gestione)** e poi **Things (Oggetti)**.
1. Scegli l’oggetto che hai creato per l'app di esempio (ad esempio, **my\$1light\$1lampadina**) e quindi scegli **Security (Sicurezza)**.
1. Seleziona il certificato e quindi, dalla pagina dei dettagli del certificato, scegli Seleziona il certificato e quindi, dalla pagina dei dettagli del certificato, scegli **Actions (Operazioni)**.
Se nell'elenco a discesa **Activate (Attiva)** non è disponibile e puoi solo scegliere **Deactivate (Disattiva)**, il certificato è attivo. In caso contrario, scegli **Activate (Attiva)** ed esegui di nuovo il programma di esempio.
Se il programma continua a non essere eseguito, controlla i nomi dei file del certificato nel folder `certs`.
+
**Controlla la policy associata alla risorsa dell’oggetto**
Mentre i certificati autenticano il dispositivo, AWS IoT le policy consentono al dispositivo di eseguire AWS IoT operazioni, come la sottoscrizione o la pubblicazione di argomenti riservati MQTT.
Per verificare se la policy corretta è allegata:
1. Individua il certificato come descritto in precedenza, quindi scegli **Policies (Policy)**.
1. Scegli la policy visualizzata e verifica se descrive le operazioni `connect`, `subscribe`, `receive` e `publish` che consentono al dispositivo l’autorizzazione di pubblicare e sottoscrivere gli argomenti riservati MQTT.
Consulta [Fase 1: Creare una AWS IoT policy per il Device Shadow](shadow-provision-cloud.md#create-policy-shadow) per una policy di esempio.
Se visualizzi messaggi di errore che indicano problemi di connessione AWS IoT, ciò potrebbe essere dovuto alle autorizzazioni che stai utilizzando per la politica. In tal caso, ti consigliamo di iniziare con una politica che fornisca l'accesso completo alle AWS IoT risorse e quindi di eseguire nuovamente il programma di esempio. È possibile modificare la policy corrente oppure scegliere la policy corrente. Scegli **Detach (Distacca)** e quindi crea un altra policy che fornisca accesso completo e collegala alla risorsa dell’oggetto. In seguito è possibile limitare la policy solo alle operazioni e alle policy necessarie per eseguire il programma.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:*"
],
"Resource": "*"
}
]
}
```
+
**Verifica dell'installazione di SDK di dispositivo**
Se il programma non viene ancora eseguito, è possibile reinstallare SDK di dispositivo per assicurarsi che l'installazione dell'SDK sia completa e corretta.
## Fase 4: Esamina i risultati e i passaggi successivi
**In questo tutorial, hai appreso come:**
+ Installa il software, gli strumenti e il AWS IoT Device SDK for Python necessari.
+ Capire come l'applicazione di esempio ,`shadow.py`, che utilizza il protocollo MQTT per recuperare e aggiornare lo stato corrente di shadow.
+ Esegui l'app di esempio per Device Shadows e osserva l'aggiornamento del documento Shadow nella console. AWS IoT Hai anche imparato a risolvere eventuali problemi e correggere gli errori durante l'esecuzione del programma.
**Fasi successive**
A questo punto è possibile eseguire il l’applicazione di esempio `shadow.py` e utilizzare Device Shadows per controllare lo stato. È possibile osservare gli aggiornamenti del documento Shadow nella console AWS IoT e gli eventi delta a cui risponde l'app di esempio. Utilizzando il client di test MQTT, è possibile iscriversi agli argomenti shadow riservati e osservare i messaggi ricevuti dagli argomenti durante l'esecuzione del programma di esempio. Per ulteriori informazioni su come eseguire questo tutorial, consulta [Tutorial: Interagisci con Device Shadow utilizzando l’app di esempio e il client di test MQTT](interact-lights-device-shadows.md).
# Tutorial: Interagisci con Device Shadow utilizzando l’app di esempio e il client di test MQTT
Per interagire con l’applicazione di esempio `shadow.py`, inserisci un valore nel terminale per il valore `desired`. Ad esempio, potete specificare colori simili ai semafori, AWS IoT rispondere alla richiesta e aggiornare i valori riportati.
**In questo tutorial, apprenderai come:**
+ Utilizzare l'app di esempio `shadow.py` per specificare gli stati desiderati e aggiornare lo stato corrente di shadow.
+ Modificare il documento Shadow per osservare gli eventi delta e come l'app di esempio `shadow.py` risponde ad essi.
+ Utilizzare il client di test MQTT per effettuare la sottoscrizione ad argomenti shadow e osservare gli aggiornamenti quando si esegue il programma di esempio.
**Prima di eseguire questo tutorial, è necessario:**
Configura il tuo Account AWS, configurato il tuo dispositivo Raspberry Pi e creato AWS IoT qualcosa e una politica. È inoltre necessario aver installato il software richiesto, SDK per dispositivo, i file di certificato ed eseguire il programma di esempio nel terminale. Per ulteriori informazioni, consulta i tutorial precedenti [Tutorial: Preparazione del Raspberry Pi per eseguire l'applicazione shadow](create-resources-shadow.md) e [Fase 1: eseguire l'app di esempio shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows). Se non lo hai già fatto, devi completare questi tutorial.
**Topics**
+ [Fase 1: Aggiornare i valori desiderati e segnalati utilizzando l’app di esempio `shadow.py`](#update-desired-shadow-sample)
+ [Fase 2: Visualizzare i messaggi dall’app di esempio `shadow.py` nel client di test MQTT](#shadow-sample-view-msg)
+ [Fase 3: Risoluzione degli errori con le interazioni Device Shadow](#shadow-observe-messages-troubleshoot)
+ [Fase 4: Esamina i risultati e i passaggi successivi](#sample-shadow-review)
Questo tutorial dura circa 45 minuti.
## Fase 1: Aggiornare i valori desiderati e segnalati utilizzando l’app di esempio `shadow.py`
Nel tutorial precedente[Fase 1: eseguire l'app di esempio shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows), hai imparato a osservare un messaggio pubblicato nel documento Shadow nella AWS IoT console quando inserisci un valore desiderato, come descritto nella sezione[Tutorial: Installare l'SDK di dispositivo ed eseguire l’applicazione di esempio per Device Shadows](lightbulb-shadow-application.md).
Nell'esempio precedente, abbiamo impostato il colore desiderato su `yellow`. Dopo aver inserito ogni valore, il terminale richiede di immettere un altro valore `desired`. Se si inserisce di nuovo lo stesso valore (`yellow`), l'app lo riconosce e ti chiede di inserire un nuovo valore `desired`.
```
Enter desired value:
yellow
Local value is already 'yellow'.
Enter desired value:
```
Ora, supponiamo che tu inserisca il colore`green`. AWS IoT risponde alla richiesta e aggiorna il `reported` valore a`green`. Questo è il modo in cui si verifica l'aggiornamento quando lo stato `desired` è diverso dal `reported`, causando un delta.
**In che modo l’app di esempio `shadow.py` simula le interazioni Device Shadow:**
1. Inserisci un valore `desired` (ad esempio `yellow`) nel terminale per pubblicare lo stato desiderato.
1. Dato che lo stato `desired` è diverso dallo stato `reported` (ad esempio il colore `green`), si verifica un delta e l'app sottoscritta al delta riceve questo messaggio.
1. L'app risponde al messaggio e aggiorna il suo stato al valore `desired`, `yellow`.
1. L'app pubblica quindi un messaggio di aggiornamento con il nuovo valore dello stato del dispositivo, `yellow`.
Di seguito vengono illustrati i messaggi visualizzati nel terminale che mostrano come viene pubblicata la richiesta di aggiornamento.
```
Enter desired value:
green
Changed local shadow value to 'green'.
Updating reported shadow value to 'green'...
Update request published.
Finished updating reported shadow value to 'green'.
```
Nella AWS IoT console, il documento Shadow riflette il valore aggiornato a `green` per entrambi i `desired` campi `reported` e e il numero di versione viene incrementato di 1. Ad esempio, se il numero della versione precedente è stato visualizzato come 10, il numero della versione corrente verrà visualizzato come 11.
**Nota**
L'eliminazione di una shadow non reimposta il numero di versione su 0. Si vedrà che la versione shadow viene incrementata di 1 quando si pubblica una richiesta di aggiornamento o si crea un'altra shadow con lo stesso nome.
**Modifica del documento Shadow per osservare gli eventi delta**
L'app di esempio `shadow.py` è anche sottoscritta agli eventi `delta` e risponde quando c'è una modifica a un valore `desired`. Ad esempio, è possibile modificare il valore `desired` per il colore `red`. Per fare ciò, nella AWS IoT console, modifica il documento Shadow facendo clic su **Modifica**, quindi imposta il `desired` valore su `red` in JSON, mantenendo il `reported` valore su. `green` Prima di salvare le modifiche, tieni aperto il terminale sul Raspberry Pi mentre vedrai i messaggi visualizzati nel terminale quando si verifica la modifica.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
Dopo aver salvato il nuovo valore, l’app di esempio `shadow.py` risponde a questa modifica e visualizza i messaggi nel terminale che indicano il delta. Si dovrebbero quindi vedere i seguenti messaggi visualizzati sotto il prompt per l'immissione del valore `desired`.
```
Enter desired value:
Received shadow delta event.
Delta reports that desired value is 'red'. Changing local value...
Changed local shadow value to 'red'.
Updating reported shadow value to 'red'...
Finished updating reported shadow value to 'red'.
Enter desired value:
Update request published.
Finished updating reported shadow value to 'red'.
```
## Fase 2: Visualizzare i messaggi dall’app di esempio `shadow.py` nel client di test MQTT
Puoi utilizzare il **client di test MQTT** nella **console AWS IoT ** per monitorare i messaggi MQTT che vengono passati in Account AWS. Utilizzando gli argomenti MQTT riservati utilizzati dal servizio Device Shadow, è possibile osservare i messaggi ricevuti dagli argomenti durante l'esecuzione dell'applicazione di esempio.
Se il client di test MQTT non è ancora stato utilizzato, è possibile consultare [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md). In questo modo si impara come utilizzare il **client di test MQTT** nella **console AWS IoT ** per visualizzare i messaggi MQTT durante il passaggio attraverso il broker di messaggi.
1.
**Apertura del client di test MQTT**
Apri il [client di test MQTT nella console AWS IoT](https://console.aws.amazon.com//iot/home#/test) in una nuova finestra in modo da poter osservare i messaggi ricevuti dagli argomenti MQTT senza perdere la configurazione del client di test MQTT. Il client di test MQTT non conserva sottoscrizioni o registri di messaggi se si lascia andare a un'altra pagina della console. In questa sezione del tutorial, potete aprire il documento Shadow corrispondente e il AWS IoT client di test MQTT in finestre separate per osservare più facilmente l'interazione con Device Shadows.
1.
**Iscrizione agli argomenti Shadow riservati MQTT**
È possibile utilizzare il client di test MQTT per inserire i nomi degli argomenti riservati MQTT di Device Shadow e sottoscriverli per ricevere gli aggiornamenti durante l'esecuzione dell’app di esempio `shadow.py`. Per effettuare la sottoscrizione agli argomenti:
1. Nel **client di test MQTT** nella **console AWS IoT **, scegli **Subscribe to a topic (Sottoscrizione a un argomento)**.
1. Nella sezione **Filtro argomento**, inserisci: ***thingname*\$1aws/things/** /shadow/update/ \$1. Qui, `thingname` è il nome della risorsa dell’oggetto creata in precedenza (ad esempio, `My_light_bulb`).
1. Mantieni i valori predefiniti per le impostazioni di configurazione aggiuntive, quindi scegli **Subscribe (Effettua sottoscrizione)**.
Utilizzando il carattere jolly **\$1** nella sottoscrizione dell'argomento, è possibile sottoscrivere più argomenti MQTT contemporaneamente e osservare tutti i messaggi che vengono scambiati tra il dispositivo e il suo Shadow in un'unica finestra. Per ulteriori informazioni sui caratteri jolly e sul loro utilizzo, consulta [Argomenti MQTT](topics.md).
1.
**Esegui il programma di esempio `shadow.py` e osserva i messaggi**
Nella finestra della riga di comando di Raspberry Pi, se hai disconnesso il programma, esegui di nuovo l'app di esempio e guarda i messaggi nel **client di test MQTT** nella **console AWS IoT **.
1. Esegui il seguente comando per riavviare il programma di esempio. Sostituisci *your-iot-thing-name* e *your-iot-endpoint* con i nomi dell' AWS IoT oggetto che hai creato in precedenza (ad esempio,`My_light_bulb`) e l'endpoint per interagire con il dispositivo.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
L’app di esempio `shadow.py` viene eseguita e recupera lo stato shadow corrente. Se hai eliminato lo shadow o cancellato gli stati correnti, il programma imposta il valore corrente su `off` e richiede di inserire un valore `desired`.
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow document lacks 'color' property. Setting defaults...
Changed local shadow value to 'off'.
Updating reported shadow value to 'off'...
Update request published.
Finished updating reported shadow value to 'off'...
Enter desired value:
```
D'altra parte, se il programma era in esecuzione e lo hai riavviato, vedrai il valore di colore più recente riportato nel terminale. **Nel client di test MQTT, vedrai un aggiornamento agli argomenti **\$1aws/things/ /shadow/get e *thingname* \$1aws/things/**/. *thingname* shadow/get/accepted**
Supponiamo che l'ultimo colore riportato sia `green`. Di seguito viene **mostrato *thingname*** il contenuto del file JSON \$1aws/things/. shadow/get/accepted
```
{
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
}
},
"version": 10,
"timestamp": 1620173908
}
```
1. Inserisci un valore `desired` nel terminale, come `yellow`. L’app di esempio `shadow.py` risponde e visualizza i seguenti messaggi nel terminale che mostrano la modifica nel valore `reported` a `yellow`.
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
In **MQTT test client** (Client MQTT di test) nella **console AWS IoT **, in **Subscriptions** (Sottoscrizioni), viene visualizzato che i seguenti argomenti hanno ricevuto un messaggio:
+ **\$1aws/things/ /shadow/update: mostra che entrambi i valori cambiano in base al *thingname* colore**. `desired` `updated` `yellow`
+ ***thingname*\$1aws/things/ shadow/update/accepted**: mostra i valori correnti degli stati and e e i relativi metadati e informazioni sulla versione. `desired` `reported`
+ ***thingname*\$1aws/things/ shadow/update/documents**: mostra i valori precedenti e correnti degli stati and e e i relativi metadati e informazioni sulla versione. `desired` `reported`
Poiché il documento **\$1aws/things/*thingname*/**contiene shadow/update/documents anche informazioni contenute negli altri due argomenti, possiamo esaminarlo per vedere le informazioni sullo stato. Lo stato precedente mostra il valore riportato impostato su `green`, i metadati e le informazioni sulla versione e lo stato corrente che mostra il valore riportato aggiornato a `yellow`.
```
{
"previous": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
}
},
"version": 10
},
"current": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
}
},
"version": 11
},
"timestamp": 1617297904
}
```
1. Ora, se si inserisce un altro valore `desired`, vengono visualizzate ulteriori modifiche ai valori `reported` e agli aggiornamenti dei messaggi ricevuti da questi argomenti. Anche il numero di versione aumenta di 1. Ad esempio, se si inserisce il valore `green`, lo stato precedente riporta il valore `yellow` e lo stato corrente riporta il valore `green`.
1.
**Modifica del documento Shadow per osservare gli eventi delta**
Per osservare le modifiche apportate all'argomento delta, modifica il documento Shadow nella console AWS IoT . Ad esempio, è possibile modificare il valore `desired` per il colore `red`. Per fare ciò, nella AWS IoT console, scegli **Modifica**, quindi imposta il `desired` valore su rosso nel file JSON, mantenendo il valore impostato su. `reported` `green` Prima di salvare la modifica, tieni il terminale aperto poiché vedrai il messaggio delta riportato nel terminale.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
L’app di esempio `shadow.py` risponde a questa modifica e visualizza i messaggi nel terminale che indica il delta. Nel client di test MQTT, gli argomenti `update` avranno ricevuto un messaggio che mostra le modifiche apportate ai valori `desired` e `reported`.
Vedi anche che l'argomento ***thingname*\$1aws/things/**/ha ricevuto un messaggio. shadow/update/delta Per visualizzare il messaggio, scegli questo argomento, elencato in **Subscriptions (Sottoscrizioni)**.
```
{
"version": 13,
"timestamp": 1617318480,
"state": {
"color": "red"
},
"metadata": {
"color": {
"timestamp": 1617318480
}
}
}
```
## Fase 3: Risoluzione degli errori con le interazioni Device Shadow
Quando esegui l'app di esempio Shadow, potresti riscontrare problemi con l'osservazione delle interazioni con il servizio Device Shadow.
Se il programma viene eseguito correttamente e richiede di inserire un valore `desired`, si dovrebbe essere in grado di osservare le interazioni Device Shadow utilizzando il documento Shadow e il client di test MQTT come descritto in precedenza. Tuttavia, se non riesci a visualizzare le interazioni, ecco alcune cose da controllare:
+
**Controlla il nome dell'oggetto e la sua ombra nella console AWS IoT**
Se i messaggi non vengono visualizzati nel documento Shadow, controlla il comando e assicurati che corrisponda al nome dell’oggetto nella **console AWS IoT **. Puoi anche verificare se hai una shadow classica scegliendo la tua risorsa dell’oggetto e quindi scegliendo **Shadows**. Questo tutorial si concentra principalmente sulle interazioni con la shadow classica.
È inoltre possibile confermare che il dispositivo utilizzato è connesso a Internet. Nella **console AWS IoT **, scegli l'oggetto che hai creato in precedenza, quindi scegli **Interact (Interagisci)**. Nella pagina dei dettagli dell’oggetto, dovresti visualizzare un messaggio con scritto: `This thing already appears to be connected.`
+
**Controlla gli argomenti riservati MQTT che hai sottoscritto**
Se i messaggi non vengono visualizzati nel client di test MQTT, verifica se gli argomenti sottoscritti sono formattati correttamente. Gli argomenti MQTT Device Shadow hanno il formato **\$1aws/things/ *thingname* /shadow/** e possono averlo `update` o `delete` seguirlo a seconda delle azioni che si desidera eseguire sull'shadow. `get` **Questo tutorial utilizza l'argomento **\$1aws/things/ *thingname* /shadow/ \$1**, quindi assicurati di averlo inserito correttamente quando ti iscrivi all'argomento nella sezione Filtro argomento del client di test.**
Mentre inserisci il nome dell'argomento, assicurati che sia lo stesso del nome dell'*thingname*oggetto che hai creato in precedenza. AWS IoT È inoltre possibile sottoscrivere altri argomenti MQTT per verificare se un aggiornamento è stato eseguito correttamente. Ad esempio, puoi iscriverti all'argomento ***thingname*\$1aws/things/** per ricevere un messaggio ogni volta che una richiesta shadow/update/rejected di aggiornamento fallisce, in modo da poter risolvere i problemi di connessione. Per ulteriori informazioni sugli argomenti riservati, consulta [Argomenti copie shadow](reserved-topics.md#reserved-topics-shadow) e [Argomenti MQTT di Device Shadow](device-shadow-mqtt.md).
## Fase 4: Esamina i risultati e i passaggi successivi
**In questo tutorial, hai appreso come:**
+ Utilizzare l'app di esempio `shadow.py` per specificare gli stati desiderati e aggiornare lo stato corrente di shadow.
+ Modificare il documento Shadow per osservare gli eventi delta e come l'app di esempio `shadow.py` risponde ad essi.
+ Utilizzare il client di test MQTT per effettuare la sottoscrizione ad argomenti shadow e osservare gli aggiornamenti quando si esegue il programma di esempio.
**Fasi successive**
Puoi iscriverti ad altri argomenti riservati MQTT per osservare gli aggiornamenti dell'applicazione shadow. Ad esempio, se ti iscrivi solo all'argomento ***thingname*\$1aws/things/ shadow/update/accepted**, quando un aggiornamento viene eseguito correttamente, vedrai solo le informazioni sullo stato corrente.
È inoltre possibile sottoscrivere altri argomenti shadow per eseguire il debug dei problemi o per ottenere ulteriori informazioni sulle interazioni Device Shadow e anche eseguire il debug di eventuali problemi con le interazioni Device Shadow. Per ulteriori informazioni, consultare [Argomenti copie shadow](reserved-topics.md#reserved-topics-shadow) e [Argomenti MQTT di Device Shadow](device-shadow-mqtt.md).
Puoi anche scegliere di estendere la tua applicazione utilizzando shadow denominati o utilizzando hardware aggiuntivo collegato al Raspberry Pi LEDs e osservare le modifiche al loro stato utilizzando i messaggi inviati dal terminale.
Per ulteriori informazioni sul servizio Device Shadow e sull'utilizzo del servizio in dispositivi, app e servizi, consulta [AWS IoT Servizio Device Shadow](iot-device-shadows.md), [Utilizzo delle copie shadow nei dispositivi](device-shadow-comms-device.md) e [Utilizzo delle copie shadow in app e servizi](device-shadow-comms-app.md).
# Tutorial: creazione di un autorizzatore personalizzato per AWS IoT Core
Questo tutorial illustra i passaggi per creare, convalidare e utilizzare l'autenticazione ad hoc utilizzando il AWS CLI. Facoltativamente, utilizzando questo tutorial, è possibile utilizzare Postman per inviare dati ad AWS IoT Core utilizzando l'API HTTP Publish.
In questo tutorial viene illustrato come creare una funzione Lambda di esempio che implementa la logica di autorizzazione e autenticazione e un'autorizzazione personalizzata utilizzando la chiamata **create-authorizer** con la firma dei token abilitata. L'autorizzatore viene quindi convalidato utilizzando e infine è possibile inviare dati utilizzando l'**test-invoke-authorizer**API HTTP Publish a AWS IoT Core un argomento MQTT di test. La richiesta di esempio specificherà l'autorizzatore da richiamare utilizzando l'`x-amz-customauthorizer-name`intestazione e passerà le intestazioni e nella richiesta. token-key-name `x-amz-customauthorizer-signature`
**Cosa imparerai in questo tutorial:**
+ Come creare una funzione Lambda per essere un gestore di autorizzazioni ad hoc
+ Come creare un autorizzatore personalizzato utilizzando l'opzione con firma con token abilitata AWS CLI
+ Come testare la tua autorizzazione ad hoc utilizzando il comando **test-invoke-authorizer**
+ Come pubblicare un argomento MQTT utilizzando lo strumento [Postman](https://www.postman.com/) e convalidare la richiesta con la tua autorizzazione ad hoc
Questo tutorial dura circa 60 minuti.
**Topics**
+ [Fase 1: Creazione di una funzione Lambda per la propria autorizzazione ad hoc](#custom-auth-tutorial-define)
+ [Fase 2: Creazione di una coppia di chiavi pubblica e privata per le tue autorizzazioni ad hoc](#custom-auth-tutorial-keys)
+ [Passaggio 3: Crea una risorsa di autorizzazione personalizzata e la relativa autorizzazione](#custom-auth-tutorial-authorizer)
+ [Fase 4: Verifica l'autorizzatore chiamando test-invoke-authorizer](#custom-auth-tutorial-test)
+ [Fase 5: Test della pubblicazione del messaggio MQTT tramite Postman](#custom-auth-tutorial-postman)
+ [Fase 6: Visualizzazione dei messaggi nel client di test MQTT](#custom-auth-tutorial-testclient)
+ [Fase 7: Esamina i risultati e i passaggi successivi](#custom-auth-tutorial-review)
+ [Fase 8: Pulizia](#custom-auth-tutorial-cleanup)
**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.
L'account che utilizzi per questo tutorial funziona meglio quando include almeno queste policy gestite da AWS :
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor)
**Importante**
Le policy IAM utilizzate in questo tutorial sono più permissive di quelle che si dovrebbero seguire in un'implementazione di produzione. In un ambiente di produzione, assicurati che le policy dell'account e delle risorse concedano solo le autorizzazioni necessarie.
Quando si creano policy IAM per la produzione, determinare l'accesso necessario agli utenti e ai ruoli e quindi progettare le policy che consentono loro di eseguire solo tali attività.
Per ulteriori informazioni, consulta la sezione [Best practice per la sicurezza in IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/best-practices.html)
+
**Hai installato il AWS CLI**
Per informazioni su come installare AWS CLI, consulta [Installazione della AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-install.html). Questo tutorial richiede una AWS CLI versione `aws-cli/2.1.3 Python/3.7.4 Darwin/18.7.0 exe/x86_64` o successiva.
+
**Strumenti OpenSSL**
Gli esempi di questo tutorial utilizzano [LibreSSL 2.6.5](https://www.libressl.org/). È possibile utilizzare anche gli strumenti [OpenSSL v1.1.1i](https://www.openssl.org/) per questo tutorial.
+
**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.
+
**Esaminato come creare richieste con lo strumento Postman**
Per ulteriori informazioni, consulta la sezione [Building requests (Richieste di compilazione)](https://learning.postman.com/docs/sending-requests/requests/).
+
**Autorizzazioni ad hoc rimosse dal tutorial precedente**
Account AWS È possibile configurare solo un numero limitato di autorizzatori personalizzati alla volta. Per informazioni su come rimuovere un'autorizzazione ad hoc, consulta [Fase 8: Pulizia](#custom-auth-tutorial-cleanup).
## Fase 1: Creazione di una funzione Lambda per la propria autorizzazione ad hoc
L'autenticazione personalizzata AWS IoT Core utilizza [le risorse di autorizzazione create](https://docs.aws.amazon.com//iot/latest/apireference/API_AuthorizerDescription.html) dall'utente per autenticare e autorizzare i client. La funzione che creerai in questa sezione autentica e autorizza i client durante la connessione e l'accesso alle risorse. AWS IoT Core AWS IoT
La funzione Lambda; svolge le operazioni seguenti:
+ Se proviene una richiesta da **test-invoke-authorizer**, restituisce una policy IAM con un'azione `Deny`.
+ Se una richiesta proviene da Postman tramite HTTP e il `actionToken` parametro ha un valore di`allow`, restituisce una policy IAM con un'azione. `Allow` In alternativa, restituisce una policy IAM con un'azione `Deny`.
**Creazione di una funzione Lambda per la propria autorizzazione ad hoc**
1. Nella console [Lambda](https://console.aws.amazon.com//lambda/home#), apri [Functions (Funzioni)](https://console.aws.amazon.com//lambda/home#/functions).
1. Scegli **Crea funzione**.
1. Conferma che l'opzione **Author from scratch (Crea da zero)** sia selezionata.
1. In **Basic information** (Informazioni di base):
1. In **Function name (Nome funzione)** immettere **custom-auth-function**.
1. In **Runtime**, conferma **Node.js 18.x**
1. Scegli **Crea funzione**.
Lambda crea una funzione in Node.js e un [ruolo di esecuzione](https://docs.aws.amazon.com//lambda/latest/dg/lambda-intro-execution-role.html) che concede alla funzione l'autorizzazione di caricare i log. La funzione Lambda assume il ruolo di esecuzione quando si richiama la funzione e utilizza il ruolo di esecuzione per creare credenziali per l' AWS SDK e leggere i dati dalle fonti degli eventi.
1. Per visualizzare il codice e la configurazione della funzione nell'[AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html)editor, scegliete **custom-auth-function**nella finestra di progettazione, quindi scegliete **index.js** nel pannello di navigazione dell'editor.
Per i linguaggi di script come Node.js, Lambda include una funzione di base che restituisce una risposta positiva. Puoi utilizzare l'editor di [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html) per modificare le funzioni purché il codice sorgente superi i 3 MB.
1. Sostituisci il codice **index.js** nell'editor con il seguente codice:
```
// A simple Lambda function for an authorizer. It demonstrates
// How to parse a CLI and Http password to generate a response.
export const handler = async (event, context, callback) => {
//Http parameter to initiate allow/deny request
const HTTP_PARAM_NAME='actionToken';
const ALLOW_ACTION = 'Allow';
const DENY_ACTION = 'Deny';
//Event data passed to Lambda function
var event_str = JSON.stringify(event);
console.log('Complete event :'+ event_str);
//Read protocolData from the event json passed to Lambda function
var protocolData = event.protocolData;
console.log('protocolData value---> ' + protocolData);
//Get the dynamic account ID from function's ARN to be used
// as full resource for IAM policy
var ACCOUNT_ID = context.invokedFunctionArn.split(":")[4];
console.log("ACCOUNT_ID---"+ACCOUNT_ID);
//Get the dynamic region from function's ARN to be used
// as full resource for IAM policy
var REGION = context.invokedFunctionArn.split(":")[3];
console.log("REGION---"+REGION);
//protocolData data will be undefined if testing is done via CLI.
// This will help to test the set up.
if (protocolData === undefined) {
//If CLI testing, pass deny action as this is for testing purpose only.
console.log('Using the test-invoke-authorizer cli for testing only');
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
} else{
//Http Testing from Postman
//Get the query string from the request
var queryString = event.protocolData.http.queryString;
console.log('queryString values -- ' + queryString);
/* global URLSearchParams */
const params = new URLSearchParams(queryString);
var action = params.get(HTTP_PARAM_NAME);
if(action!=null && action.toLowerCase() === 'allow'){
callback(null, generateAuthResponse(ALLOW_ACTION,ACCOUNT_ID,REGION));
}else{
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
}
}
};
// Helper function to generate the authorization IAM response.
var generateAuthResponse = function(effect,ACCOUNT_ID,REGION) {
var full_resource = "arn:aws:iot:"+ REGION + ":" + ACCOUNT_ID + ":*";
console.log("full_resource---"+full_resource);
var authResponse = {};
authResponse.isAuthenticated = true;
authResponse.principalId = 'principalId';
var policyDocument = {};
policyDocument.Version = '2012-10-17';
policyDocument.Statement = [];
var statement = {};
statement.Action = 'iot:*';
statement.Effect = effect;
statement.Resource = full_resource;
policyDocument.Statement[0] = statement;
authResponse.policyDocuments = [policyDocument];
authResponse.disconnectAfterInSeconds = 3600;
authResponse.refreshAfterInSeconds = 600;
console.log('custom auth policy function called from http');
console.log('authResponse --> ' + JSON.stringify(authResponse));
console.log(authResponse.policyDocuments[0]);
return authResponse;
}
```
1. Seleziona **Implementa**.
1. Dopo aver visualizzato **Changes deployed (Modifiche implementate)** in alto nell'editor:
1. Scorri fino alla sezione **Function overview (Panoramica delle funzioni)** in alto nell'editor.
1. Copia la **Function ARN (Funzione ARN)** e salvala per utilizzarla più avanti in questo tutorial.
1. Prova la tua funzione .
1. Seleziona la scheda **Test**.
1. Utilizzando le impostazioni di test di default, fai clic su **Invoke (Richiama)**.
1. Se il test ha avuto esito positivo, in **Execution results (Risultati dell'esecuzione)**, apri la visualizzazione **Details (Dettagli)**. Dovresti vedere il documento di policy restituito dalla funzione.
Se il test non è riuscito o non viene visualizzato un documento di policy, esaminare il codice per trovare e correggere gli errori.
## Fase 2: Creazione di una coppia di chiavi pubblica e privata per le tue autorizzazioni ad hoc
La tua autorizzazioni ad hoc richiede una chiave pubblica e privata per autenticarla. I comandi di questa sezione utilizzano gli strumenti OpenSSL per creare questa coppia di chiavi.
**Creazione di una coppia di chiavi pubblica e privata per le tue autorizzazioni ad hoc**
1. Creazione del file della chiave privata.
```
openssl genrsa -out private-key.pem 4096
```
1. Verificare il file della chiave privata appena creato.
```
openssl rsa -check -in private-key.pem -noout
```
Se il comando non mostra errori, il file della chiave privata è valido.
1. Creazione del file della chiave pubblica.
```
openssl rsa -in private-key.pem -pubout -out public-key.pem
```
1. Verificare il file della chiave pubblica.
```
openssl pkey -inform PEM -pubin -in public-key.pem -noout
```
Se il comando non mostra errori, il file della chiave pubblica è valido.
## Passaggio 3: Crea una risorsa di autorizzazione personalizzata e la relativa autorizzazione
L'autorizzatore AWS IoT personalizzato è la risorsa che unisce tutti gli elementi creati nei passaggi precedenti. In questa sezione, creerai una risorsa di autorizzazione ad hoc e la autorizzerai ad eseguire la funzione Lambda creata in precedenza. È possibile creare una risorsa di autorizzazione personalizzata utilizzando la AWS IoT console AWS CLI, l'o l' AWS API.
Per questo tutorial, è sufficiente creare una sola autorizzazione ad hoc. Questa sezione descrive come creare utilizzando la AWS IoT console e il AWS CLI, in modo da poter utilizzare il metodo più conveniente per te. Non c'è differenza tra le risorse delle autorizzazioni ad hoc create da entrambi i metodi.
### Crea una risorsa di autorizzazione personalizzata
**Scegli una di queste opzioni per creare la risorsa dell'autorizzazione ad hoc**
+ [Crea un autorizzatore personalizzato utilizzando la console AWS IoT](#create-custom-auth-in-console)
+ [Creazione di un'autorizzazione ad hoc tramite AWS CLI](#create-custom-auth-in-cli)
**Per creare un'autorizzazione ad hoc (console)**
1. Apri la [pagina dell'autorizzazione personalizzata della AWS IoT console](https://console.aws.amazon.com//iot/home#/authorizerhub) e scegli **Crea** autorizzazione.
1. In **Crea autorizzazioni**:
1. In **Nome dell'autorizzatore**, immetti **my-new-authorizer**.
1. In **Stato autorizzazione**, seleziona **Attiva**.
1. In **Authorizer function (Funzione autorizzazione)**, seleziona la funzione Lambda creata in precedenza.
1. In **Token validation - optional (Convalida token - facoltativa )**:
1. Attiva **Convalida token**.
1. In **Nome della chiave dei token**, immetti **tokenKeyName**.
1. Scegliere **Add key (Aggiungi chiave)**.
1. In **Nome chiave**, immetti **FirstKey**.
1. In **Chiave pubblica**, immetti il contenuto del file `public-key.pem`. Assicurati di includere le righe del file con `-----BEGIN PUBLIC KEY-----` e `-----END PUBLIC KEY-----` e non aggiungere o rimuovere alcun feed di riga, ritorni a capo o altri caratteri dal contenuto del file. La stringa inserita dovrebbe essere simile a quanto segue.
```
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----
```
1. Scegli **Create Authorizer (Crea autorizzazioni)**.
1. Se la risorsa di autorizzazione ad hoc è stata creata, vedrai l'elenco delle autorizzazioni ad hoc e la tua nuova autorizzazione ad hoc dovrebbe apparire nell'elenco e puoi continuare alla sezione successiva per testarla.
Se viene visualizzato un errore, rivedere l'errore e provare a creare nuovamente l'autorizzazione ad hoc e ricontrollare le voci. Attenzione: ciascuna risorsa dell'autorizzazione ad hoc deve avere un nome univoco.
**Per creare un'autorizzazione ad hoc (AWS CLI)**
1. Sostituisci i tuoi valori con `authorizer-function-arn` e `token-signing-public-keys` e quindi esegui il seguente comando:
```
aws iot create-authorizer \
--authorizer-name "my-new-authorizer" \
--token-key-name "tokenKeyName" \
--status ACTIVE \
--no-signing-disabled \
--authorizer-function-arn "arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function" \
--token-signing-public-keys FirstKey="-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----"
```
**Dove:**
+ Il valore `authorizer-function-arn` è l'Amazon Resource Name (ARN) della funzione Lambda creata per l'autorizzazione ad hoc.
+ Il valore `token-signing-public-keys` include il nome della chiave, **FirstKey** e i contenuti del file `public-key.pem`. Assicurati di includere le righe del file con `-----BEGIN PUBLIC KEY-----` e `-----END PUBLIC KEY-----` e non aggiungere o rimuovere alcun feed di riga, ritorni a capo o altri caratteri dal contenuto del file.
Nota: fai attenzione a inserire la chiave pubblica poiché qualsiasi modifica al valore della chiave pubblica la rende inutilizzabile.
1. Creando l'autorizzazione ad hoc, il comando restituisce il nome e l'ARN della nuova risorsa, come qui di seguito.
```
{
"authorizerName": "my-new-authorizer",
"authorizerArn": "arn:aws:iot:Region:57EXAMPLE833:authorizer/my-new-authorizer"
}
```
Salva il valore `authorizerArn` da utilizzare nella fase successiva.
Ricorda che ciascuna risorsa dell'autorizzazione ad hoc deve avere un nome univoco.
### Autorizza le risorse delle autorizzazioni ad hoc
In questa sezione, verrà descritto come concedere alla risorsa dell'autorizzazione ad hoc appena creata l'autorizzazione per eseguire la funzione Lambda. Per concedere l'autorizzazione, è possibile utilizzare il comando dell'interfaccia a riga di comando [add-permission](https://docs.aws.amazon.com//cli/latest/reference/lambda/add-permission.html).
**Concedi l'autorizzazione alla tua funzione Lambda utilizzando il AWS CLI**
1. Una volta inseriti i valori, inserisci il comando seguente. Attenzione: il valore `statement-id` deve essere univoco. Sostituisci `Id-1234` con un altro valore se hai eseguito questo tutorial prima o in occasione di un errore `ResourceConflictException`.
```
aws lambda add-permission \
--function-name "custom-auth-function" \
--principal "iot.amazonaws.com" \
--action "lambda:InvokeFunction" \
--statement-id "Id-1234" \
--source-arn authorizerArn
```
1. Se il comando viene completato correttamente, restituisce un'istruzione di autorizzazione come questa. È possibile passare alla sezione successiva per testare l'autorizzazione ad hoc.
```
{
"Statement": "{\"Sid\":\"Id-1234\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"iot.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\"}}}"
}
```
Se il comando non ha esito positivo, restituisce un errore come questo. Dovrai esaminare e correggere l'errore prima di continuare.
```
An error occurred (AccessDeniedException) when calling the AddPermission operation: User: arn:aws:iam::57EXAMPLE833:user/EXAMPLE-1 is not authorized to perform: lambda:AddPer
mission on resource: arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function
```
## Fase 4: Verifica l'autorizzatore chiamando test-invoke-authorizer
Con tutte le risorse definite, in questa sezione, chiamerai test-invoke-authorizer dalla riga di comando per testare il passaggio di autorizzazione.
Si noti che quando si richiama l'autorizzazione dalla riga di comando, `protocolData` non è definito, quindi l'autore restituirà sempre un documento DENY. Tuttavia, questo test conferma che l'autorizzazione ad hoc e la funzione Lambda siano configurate correttamente, anche se non esegue il test completo della funzione Lambda.
**Per testare l'autorizzatore personalizzato e la relativa funzione Lambda utilizzando il AWS CLI**
1. Nella directory che contiene il file `private-key.pem` creato in un passaggio precedente, eseguire il comando seguente.
```
echo -n "tokenKeyValue" | openssl dgst -sha256 -sign private-key.pem | openssl base64 -A
```
Questo comando crea una stringa di firma da utilizzare nel passaggio successivo. La stringa della firma ha un aspetto simile a questo:
```
dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mn
VB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeeh
bQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjj
szEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29V
QJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuX
f3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+K
EWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFH
xRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Copia la stringa della firma da utilizzare nel passaggio successivo. Fai attenzione a non includere caratteri aggiuntivi o a non lasciarli fuori.
1. In questo comando, sostituire il valore `token-signature` con la stringa di firma del passaggio precedente ed esegui questo comando per testare l'autorizzazione.
```
aws iot test-invoke-authorizer \
--authorizer-name my-new-authorizer \
--token tokenKeyValue \
--token-signature dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mnVB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeehbQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjjszEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29VQJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuXf3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+KEWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFHxRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Se il comando ha esito positivo, restituisce le informazioni generate dalla funzione di autorizzazione personalizzata, come questo esempio.
```
{
"isAuthenticated": true,
"principalId": "principalId",
"policyDocuments": [
"{\"Version\":\"2012-10-17\", \"Statement\":[{\"Action\":\"iot:*\",\"Effect\":\"Deny\",\"Resource\":\"arn:aws:iot:Region:57EXAMPLE833:*\"}]}"
],
"refreshAfterInSeconds": 600,
"disconnectAfterInSeconds": 3600
}
```
Se il comando restituisce un errore, esamina l'errore e ricontrolla i comandi utilizzati in questa sezione.
## Fase 5: Test della pubblicazione del messaggio MQTT tramite Postman
1. Per ottenere l'endpoint dati del dispositivo dalla riga di comando, chiama [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) come mostrato qui
```
aws iot describe-endpoint --output text --endpoint-type iot:Data-ATS
```
Salva questo indirizzo per utilizzarlo come *device\$1data\$1endpoint\$1address* in un passaggio successivo.
1. Apri una nuova finestra Postman e crea una nuova richiesta HTTP POST.
1. Dal computer, apri l'app Postman.
1. In Postman, dal menu **File**, seleziona **New... (Nuovo...)**.
1. Nella finestra di dialogo **New (Nuovo)** seleziona **Request (Richiesta)**.
1. In Salva richiesta,
1. In **Request name (Nome della richiesta)** inserisci **Custom authorizer test request**.
1. In **Select a collection or folder to save to: (Seleziona una raccolta o una cartella in cui salvare:)** scegli o crea una raccolta in cui salvare questa richiesta.
1. Scegli **Salva in *collection\$1name***.
1. Crea la richiesta POST per testare la tua autorizzazione ad hoc.
1. Nel selettore del metodo di richiesta accanto al campo URL, seleziona **POST**.
1. Nel campo URL, crea l'URL per la tua richiesta utilizzando il seguente URL con il comando *device\$1data\$1endpoint\$1address* from the [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) del passaggio precedente.
```
https://device_data_endpoint_address:443/topics/test/cust-auth/topic?qos=0&actionToken=allow
```
Attenzione: questo URL include il parametro query `actionToken=allow` che dirà alla funzione Lambda di restituire un documento policy che consenta l'accesso a AWS IoT. Dopo aver inserito l'URL, i parametri della query vengono visualizzati anche nella scheda **Params (Parametri)** di Postman.
1. Nella scheda **Auth (Autenticazione)**, nel campo **Type (Tipo)**, seleziona **No Auth (Nessuna autenticazione)**.
1. Nella scheda Intestazioni:
1. Se c'è un tasto **host** selezionato, deselezionalo.
1. Nella parte inferiore dell'elenco delle intestazioni aggiungete queste nuove intestazioni e confermate che siano state selezionate. Sostituisci il **Host** valore con il tuo *device\$1data\$1endpoint\$1address* e il **x-amz-customauthorizer-signature** valore con la stringa della firma che hai usato con il **test-invoke-authorize** comando nella sezione precedente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/custom-auth-tutorial.html)
1. Nella scheda Body (Corpo):
1. Nella casella di opzione formato dati, scegli **Raw (Non elaborati)**.
1. Nell'elenco dei tipi di dati, scegli **JavaScript**.
1. Nel campo di testo, inserisci questo payload del messaggio JSON per il messaggio di prova:
```
{
"data_mode": "test",
"vibration": 200,
"temperature": 40
}
```
1. Scegli **Send (Invia)** per inviare la richiesta.
Se la richiesta è stata completata correttamente, verrà visualizzato:
```
{
"message": "OK",
"traceId": "ff35c33f-409a-ea90-b06f-fbEXAMPLE25c"
}
```
La risposta corretta indica che l'autorizzazione personalizzata ha consentito la connessione a AWS IoT e che il messaggio di prova è stato recapitato al broker in AWS IoT Core.
Se restituisce un errore, esamina il messaggio di errore, la*device\$1data\$1endpoint\$1address*, la stringa della firma e gli altri valori di intestazione.
Conserva questa richiesta in Postman per utilizzarla nella sezione successiva.
## Fase 6: Visualizzazione dei messaggi nel client di test MQTT
Nel passaggio precedente, hai inviato messaggi simulati al dispositivo AWS IoT utilizzando Postman. La risposta riuscita ha indicato che l'autorizzazione ad hoc ha consentito la connessione a AWS IoT e che il messaggio di prova è stato consegnato al broker AWS IoT Core. In questa sezione, utilizzerai il client di test MQTT nella AWS IoT console per visualizzare il contenuto dei messaggi di quel messaggio come potrebbero fare altri dispositivi e servizi.
**Per visualizzare i messaggi di prova autorizzati dalla tua autorizzazione ad hoc**
1. Nella AWS IoT console, aprite il client di [test MQTT](https://console.aws.amazon.com//iot/home#/test).
1. Nella scheda **Subscribe to a topic (Sottoscrivi un argomento)**, in **Topic filter (Filtro argomenti)**, inserisci **test/cust-auth/topic**, ovvero l'argomento del messaggio utilizzato nell'esempio Postman della sezione precedente.
1. Scegli **Abbonati**.
Tieni questa finestra visibile per la fase successiva.
1. In Postman, nella richiesta creata per la sezione precedente, seleziona **Send (Invia)**.
Controlla la risposta per assicurarti che sia stata elaborata correttamente. In caso contrario, risolvi l'errore come descritto nella sezione precedente.
1. Nel **Client MQTT di test**, dovresti vedere una nuova voce che mostra l'argomento del messaggio e, se espanso, il payload del messaggio dalla richiesta inviata da Postman.
Se non si visualizzano i messaggi nel **client MQTT di test**, ecco alcune cose da controllare:
+ Assicurati che la tua richiesta Postman sia stata restituita correttamente. Se AWS IoT rifiuta la connessione e restituisce un errore, il messaggio contenuto nella richiesta non viene passato al broker di messaggi.
+ Assicurati che la Account AWS e Regione AWS usata per aprire la AWS IoT console sia la stessa che usi nell'URL di Postman.
+ Assicurati di utilizzare l'endpoint appropriato per l'autorizzatore personalizzato. L'endpoint IoT predefinito potrebbe non supportare l'utilizzo di autorizzazioni personalizzate con funzioni Lambda. Puoi invece utilizzare le configurazioni di dominio per definire un nuovo endpoint e quindi specificare quell'endpoint per l'autorizzatore personalizzato.
+ Assicurati di aver inserito correttamente l'argomento nel **client MQTT di test**. Il filtro non fa distinzione tra maiuscole e minuscole. In caso di dubbio, puoi anche iscriverti all'**\$1**argomento, che sottoscrive tutti i messaggi MQTT che passano attraverso il broker di messaggi Account AWS e Regione AWS utilizzati per aprire la console. AWS IoT
## Fase 7: Esamina i risultati e i passaggi successivi
**In questo tutorial:**
+ Hai creato una funzione Lambda come gestore di autorizzazioni ad hoc
+ Hai creato un'autorizzazione ad hoc con la firma dei token abilitata
+ Hai testato la tua autorizzazione ad hoc utilizzando il comando **test-invoke-authorizer**
+ Hai pubblicato un argomento MQTT utilizzando [Postman](https://www.postman.com/) e convalidato la richiesta con la tua autorizzazione ad hoc
+ Hai usato il **client MQTT di test** per visualizzare i messaggi inviati dal test Postman
**Fasi successive**
Dopo aver inviato alcuni messaggi da Postman per verificare che l'autorizzazione ad hoc funzioni, prova a sperimentare vedendo come i diversi aspetti di questo tutorial influiscono sui risultati. Ecco alcuni esempi per cominciare.
+ Modificare la stringa di firma in modo che non sia più valida, in modo tale da poter vedere come vengono gestiti i tentativi di connessione non autorizzati. Dovresti ricevere una risposta di errore, come questa, e il messaggio non dovrebbe apparire nel **client MQTT di test**.
```
{
"message": "Forbidden",
"traceId": "15969756-a4a4-917c-b47a-5433e25b1356"
}
```
+ Per ulteriori informazioni su come individuare gli errori che potrebbero verificarsi durante lo sviluppo e l'utilizzo AWS IoT delle regole, consulta. [Monitoraggio AWS IoT](monitoring_overview.md)
## Fase 8: Pulizia
Se desideri ripetere questo tutorial, potresti dover rimuovere alcune delle tue autorizzazioni ad hoc. Account AWS Puoi avere solo un numero limitato di autorizzatori personalizzati configurati contemporaneamente e puoi ottenerne uno `LimitExceededException` quando provi ad aggiungerne uno nuovo senza rimuovere un autorizzatore personalizzato esistente.
**Per rimuovere un'autorizzazione ad hoc (console)**
1. Apri la [pagina Autorizzatore personalizzato della AWS IoT console](https://console.aws.amazon.com//iot/home#/authorizerhub) e, nell'elenco degli autorizzatori personalizzati, trova l'autorizzatore personalizzato da rimuovere.
1. Apri la pagina dei dettagli delle autorizzazioni ad hoc e, dal menu **Actions (Azioni)**, seleziona **Edit (Modifica)**.
1. Deseleziona l'opzione **Activate authorizer (Attiva autorizzazione)** e quindi seleziona **Update (Aggiorna)**.
Non puoi eliminare un'autorizzazione ad hoc mentre è attiva.
1. Apri la pagina dei dettagli delle autorizzazioni ad hoc, apri il menu **Actions (Azioni)**, seleziona **Delete (Elimina)**.
**Per rimuovere un'autorizzazione ad hoc (AWS CLI)**
1. Elenca le autorizzazioni ad hoc installate e trova il nome dell'autorizzazione ad hoc da eliminare.
```
aws iot list-authorizers
```
1. Imposta l'autorizzazione ad hoc in stato `inactive` eseguendo questo comando dopo la sostituzione di `Custom_Auth_Name` con il `authorizerName` dell'autorizzazione ad hoc da eliminare.
```
aws iot update-authorizer --status INACTIVE --authorizer-name Custom_Auth_Name
```
1. Elimina l'autorizzazione ad hoc eseguendo questo comando dopo la sostituzione di `Custom_Auth_Name` con il `authorizerName` dell'autorizzazione ad hoc da eliminare.
```
aws iot delete-authorizer --authorizer-name Custom_Auth_Name
```
# Tutorial: monitoraggio dell'umidità del suolo con AWS IoT Raspberry Pi
Questo tutorial mostra come utilizzare un [Raspberry Pi](https://www.raspberrypi.org/), un sensore di umidità e come AWS IoT monitorare il livello di umidità del suolo per una pianta da appartamento o un giardino. Il Raspberry Pi esegue un codice che legge il livello di umidità e la temperatura dal sensore e quindi invia i dati a. AWS IoT Crei una regola AWS IoT che invia un'e-mail a un indirizzo abbonato a un argomento di Amazon SNS quando il livello di umidità scende al di sotto di una soglia.
**Nota**
Questo tutorial potrebbe non essere aggiornato. Alcuni riferimenti potrebbero essere stati sostituiti dalla pubblicazione di questo argomento.
**Contents**
+ [Prerequisiti](#iot-moisture-prereqs)
+ [Configurazione AWS IoT](iot-moisture-setup.md)
+ [Fase 1: Creare la AWS IoT politica](iot-moisture-policy.md)
+ [Fase 2: Creare l' AWS IoT oggetto, il certificato e la chiave privata](iot-moisture-create-thing.md)
+ [Fase 3: Creazione e sottoscrizione a un argomento Amazon SNS](iot-moisture-create-sns-topic.md)
+ [Passaggio 4: Crea una AWS IoT regola per inviare un'email](iot-moisture-create-rule.md)
+ [Configurazione del Raspberry Pi e del sensore di umidità](iot-moisture-raspi-setup.md)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un. Account AWS
+ Un utente IAM con autorizzazioni da amministratore.
+ Un computer di sviluppo che esegue Windows, macOS, Linux o Unix per accedere alla [console AWS IoT](https://console.aws.amazon.com/iot/home).
+ Un [Raspberry Pi 3B o 4B](https://www.raspberrypi.com/products/) con l'ultimo sistema operativo [Raspberry Pi](https://www.raspberrypi.com/software/operating-systems/). Per le istruzioni di installazione, consulta [Installazione di un sistema operativo](https://www.raspberrypi.com/documentation/computers/getting-started.html#installing-the-operating-system) sul sito Web di Raspberry Pi.
+ Un monitor, una tastiera, un mouse e una rete Wi-Fi o una connessione Ethernet per il Raspberry Pi.
+ Un sensore di umidità compatibile con Raspberry Pi. Il sensore utilizzato in questo tutorial è un [sensore di umidità capacitivo Adafruit STEMMA I2C](https://www.adafruit.com/product/4026) con [connettore femmina su un'estremità e JST a 4 pin all'estremità opposta](https://www.adafruit.com/product/3950).
# Configurazione AWS IoT
Per completare questo tutorial, è necessario creare le seguenti risorse. Per connettere un dispositivo AWS IoT, crei un oggetto IoT, un certificato del dispositivo e una AWS IoT policy.
+ Qualsiasi AWS IoT cosa.
Un oggetto rappresenta un dispositivo fisico (in questo caso, il Raspberry Pi) e contiene metadati statici relativi al dispositivo.
+ Un certificato del dispositivo.
Tutti i dispositivi devono disporre di un certificato del dispositivo per connettersi a AWS IoT ed eseguire l'autenticazione.
+ Una AWS IoT politica.
A ogni certificato del dispositivo sono associate una o più AWS IoT politiche. Queste politiche determinano a quali AWS IoT risorse può accedere il dispositivo.
+ Un certificato CA AWS IoT principale.
I dispositivi e gli altri client utilizzano un certificato CA AWS IoT principale per autenticare il AWS IoT server con cui comunicano. Per ulteriori informazioni, consulta [Autenticazione del server](server-authentication.md).
+ Una AWS IoT regola.
Una regola contiene una query e una o più operazioni di regola. La query estrae i dati dai messaggi del dispositivo per determinare se i dati del messaggio devono essere elaborati. L'operazione della regola specifica cosa fare se i dati corrispondono alla query.
+ Un argomento Amazon SNS e una sottoscrizione di un argomento.
La regola ascolta i dati di umidità dal Raspberry Pi. Se il valore è inferiore a una soglia, invia un messaggio all'argomento Amazon SNS. Amazon SNS invia tale messaggio a tutti gli indirizzi e-mail che hanno effettuato la sottoscrizione all'argomento.
# Fase 1: Creare la AWS IoT politica
Crea una AWS IoT policy che consenta al tuo Raspberry Pi di connettersi e inviare messaggi a AWS IoT.
1. Se nella [console AWS IoT](https://console.aws.amazon.com/iot) è presente un pulsante **Get started (Inizia)**, selezionarlo. In caso contrario, nel riquadro di navigazione del servizio espandere **Security** (Sicurezza), quindi selezionare **Policies** (Policy).
1. Se viene visualizzata la finestra di dialogo**You don’t have any policies yet (Non hai ancora policy)**, selezionare **Create a policy (Crea una policy)**. In caso contrario, scegliere **Create** (Crea).
1. Inserisci un nome per la AWS IoT politica (ad esempio,**MoistureSensorPolicy**).
1. Nella sezione **Add statements (Aggiungi istruzioni)**, sostituire la policy esistente con il seguente JSON. Sostituisci «*region*e» *account* con il tuo Account AWS numero Regione AWS e.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/RaspberryPi"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:us-east-1:123456789012:thing/RaspberryPi"
}
]
}
```
1. Scegli **Create** (Crea).
# Fase 2: Creare l' AWS IoT oggetto, il certificato e la chiave privata
Crea un elemento nel AWS IoT registro per rappresentare il tuo Raspberry Pi.
1. Nel riquadro di navigazione della [console AWS IoT](https://console.aws.amazon.com/iot/home) scegliere **Manage (Gestisci)**, quindi scegliere **Things (Oggetti)**.
1. Se è visibile la finestra di dialogo **You don’t have any things yet (Non hai ancora oggetti)**, selezionare **Register a thing (Registra un oggetto)**. In caso contrario, scegliere **Create** (Crea).
1. Nella pagina **Creazione di AWS IoT oggetti**, scegli **Crea una singola cosa**.
1. Nella pagina **Add your device to the device registry (Aggiungi il tuo dispositivo al registro dei dispositivi)**, immettere un nome per l'oggetto IoT, ad esempio **RaspberryPi**, quindi scegliere **Next (Avanti)**. Non puoi modificare il nome di un oggetto dopo averlo creato. Per cambiare il nome di un oggetto, devi creare un nuovo oggetto, dargli il nuovo nome e quindi eliminare il vecchio oggetto.
1. Nella pagina **Add a certificate for your thing (Aggiungi un certificato per l'oggetto)**, scegli **Create certificate (Crea certificato)**.
1. Scegliere i collegamenti **Download (Scarica)** per scaricare il certificato, la chiave privata e il certificato CA root.
**Importante**
Questa è l'unico momento in cui è possibile scaricare il certificato e la chiave privata.
1. Scegli **Activate (Attiva)** per attivare il certificato. Il certificato deve essere attivo affinché un dispositivo possa connettersi a AWS IoT.
1. Scegliere **Attach a policy (Collega policy)**.
1. Per **Aggiungi una politica per il tuo oggetto**, scegli **MoistureSensorPolicy**, quindi scegli **Registra oggetto**.
# Fase 3: Creazione e sottoscrizione a un argomento Amazon SNS
Creazione e sottoscrizione di un argomento Amazon SNS.
1. Dalla [console AWS SNS](https://console.aws.amazon.com/sns/home), nel riquadro di navigazione, scegli **Topics (Argomenti)** e quindi scegli **Create topic (Crea argomento)**.
1. Scegli Tipo come **Standard** e inserisci un nome per l'argomento (ad esempio,**MoistureSensorTopic**).
1. Immettere un nome visualizzato per l'argomento, ad esempio **Moisture Sensor Topic**. Questo è il nome visualizzato per l'argomento nella console Amazon SNS.
1. Scegli **Create topic** (Crea argomento).
1. Nella pagina dei dettagli dell'argomento Amazon SNS, scegli **Create Subscription (Crea sottoscrizione)**.
1. Per **Protocollo**, scegli **E-mail**.
1. Per **Endpoint**, immettere il proprio indirizzo e-mail.
1. Scegli **Create Subscription** (Crea sottoscrizione).
1. Aprire il client e-mail e cercare un messaggio con l'oggetto **MoistureSensorTopic**. Aprire l'e-mail e selezionare il collegamento **Confirm subscription (Conferma sottoscrizione)**.
**Importante**
Non riceverai avvisi e-mail da questo argomento Amazon SNS finché non confermi la sottoscrizione.
Dovresti ricevere un messaggio di posta elettronica con il testo che hai digitato.
# Passaggio 4: Crea una AWS IoT regola per inviare un'email
Una AWS IoT regola definisce una query e una o più azioni da eseguire quando si riceve un messaggio da un dispositivo. Il motore AWS IoT delle regole ascolta i messaggi inviati dai dispositivi e utilizza i dati contenuti nei messaggi per determinare se è necessario intraprendere un'azione. Per ulteriori informazioni, consulta [Regole per AWS IoT](iot-rules.md).
In questo tutorial, il Raspberry Pi pubblica messaggi su `aws/things/RaspberryPi/shadow/update`. Si tratta di un argomento MQTT interno utilizzato dai dispositivi e dal servizio Thing Shadow. Il Raspberry Pi pubblica messaggi nel formato seguente:
```
{
"reported": {
"moisture" : moisture-reading,
"temp" : temperature-reading
}
}
```
È necessario creare una query che estrae i dati relativi a umidità e temperatura dal messaggio in entrata. È necessario inoltre creare un'azione Amazon SNS che acquisisce i dati e li invia agli iscritti dell'argomento se la lettura dell'umidità è inferiore a un valore di soglia.
**Creazione di una regola Amazon SNS.**
1. **Nella [AWS IoT console](https://console.aws.amazon.com/iot/home), scegli **Routing dei messaggi**, quindi scegli Regole.** Se viene visualizzata la finestra di dialogo**You don’t have any rules yet (Non hai ancora regole)**, selezionare **Create a rule (Crea una regola)**. Altrimenti, scegli **Crea regola**.
1. Nella pagina delle **proprietà della regola**, inserisci un **nome per la regola**, ad esempio**MoistureSensorRule**, e fornisci una breve **descrizione della regola**, ad esempio**Sends an alert when soil moisture level readings are too low**.
1. Scegliete **Avanti** e configurate l'istruzione SQL. Scegli la **versione SQL** come **23/03/2016** e inserisci la seguente AWS IoT istruzione di query SQL:
```
SELECT * FROM '$aws/things/RaspberryPi/shadow/update/accepted' WHERE state.reported.moisture < 400
```
Questa istruzione attiva l'operazione della regola quando la lettura `moisture` è inferiore a `400`.
**Nota**
Potrebbe essere necessario utilizzare un valore diverso. Quando il codice è in esecuzione sul Raspberry Pi, è possibile visualizzare i valori ottenuti dal sensore toccando il sensore, immergendolo in acqua o posizionandolo in una fioriera.
1. Scegli **Avanti** e allega le azioni delle regole. Per **l'azione 1**, scegli **Simple Notification Service**. La descrizione di questa azione della regola è **Invia un messaggio come notifica push SNS**.
1. **Per l'**argomento SNS**, scegli l'argomento in [Fase 3: Creazione e sottoscrizione a un argomento Amazon SNS](iot-moisture-create-sns-topic.md) cui hai creato e lascia il **formato del messaggio** come RAW. **MoistureSensorTopic**** Per **Ruolo IAM**, scegli **Crea un nuovo ruolo**. Inserisci un nome per il ruolo, ad esempio**LowMoistureTopicRole**, e quindi scegli **Crea ruolo**.
1. Scegli **Avanti** per rivedere, quindi scegli **Crea** per creare la regola.
# Configurazione del Raspberry Pi e del sensore di umidità
Inserire la scheda micro SD nel Raspberry Pi, connettere il monitor, la tastiera, il mouse e, se non si utilizza la rete Wi-Fi, il cavo Ethernet. Non collegare il cavo di alimentazione per il momento.
Collegare il cavo jumper JST al sensore di umidità. L'estremità opposta del jumper presenta quattro fili:
+ Verde: I2C SCL
+ Bianco: I2C SDA
+ Rosso: alimentazione (3,5 V)
+ Nero: terra
Tieni il Raspberry Pi con il connettore Ethernet a destra. In questo orientamento, ci sono due file di pin GPIO nella parte superiore. Collega i fili dal sensore di umidità alla fila inferiore di pin nel seguente ordine. Partendo dal pin più a sinistra, collega il rosso (alimentazione), bianco (SDA) e verde (SCL). Salta un pin, quindi collega il file nero (terra). Per ulteriori informazioni, consulta la pagina relativa al [cablaggio per i computer Python](https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/python-circuitpython-test).
Collega il cavo di alimentazione al Raspberry Pi e collega l'estremità opposta a una presa di corrente per accenderlo.
**Configurare il Raspberry Pi**
1. In **Welcome to Raspberry Pi (Benvenuto in Raspberry Pi)**, scegliere **Next (Avanti)**.
1. Scegliere il paese, la lingua, il fuso orario e il layout della tastiera. Scegli **Next (Successivo)**.
1. Immettere una password per il Raspberry Pi, quindi scegliere **Next (Avanti)**.
1. Scegliere la rete Wi-Fi, quindi scegliere **Next (Avanti)**. Se non si utilizza una rete Wi-Fi, scegliere **Skip (Ignora)**.
1. Scegliere **Next (Avanti)** per verificare la presenza di aggiornamenti software. Al termine degli aggiornamenti, scegliere **Restart (Riavvia)** per riavviare il Raspberry Pi.
Dopo l'avvio del Raspberry Pi, abilitare l'interfaccia I2C.
1. Nell'angolo in alto a sinistra del desktop Raspbian, fare clic sull'icona Raspberry, scegliere **Preferences (Preferenze)**, quindi scegliere **Raspberry Pi Configuration (Configurazione Raspberry Pi)**.
1. Nella scheda **Interfaces (Interfacce)**, per **I2C**, scegliere **Enable (Abilita)**.
1. Scegli **OK**.
Le librerie per il sensore di umidità Adafruit STEMMA sono state scritte per. CircuitPython Per eseguirle su un Raspberry Pi, è necessario installare la versione più recente di Python 3.
1. Eseguire i comandi seguenti da un prompt dei comandi per aggiornare il software Raspberry Pi:
`sudo apt-get update`
`sudo apt-get upgrade`
1. Eseguire il comando seguente per aggiornare l'installazione di Python 3:
`sudo pip3 install --upgrade setuptools`
1. Eseguire il comando seguente per installare le librerie GPIO di Raspberry Pi:
`pip3 install RPI.GPIO`
1. Eseguire il comando seguente per installare le librerie Adafruit Blinka:
`pip3 install adafruit-blinka`
Per ulteriori informazioni, consulta [Installazione delle CircuitPython librerie su Raspberry](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi) Pi.
1. Eseguire il comando seguente per installare le librerie Adafruit Seesaw:
`sudo pip3 install adafruit-circuitpython-seesaw`
1. Esegui il seguente comando per installare AWS IoT Device SDK per Python:
`pip3 install AWSIoTPythonSDK`
Il Raspberry Pi ora dispone di tutte le librerie necessarie. Crea un file denominato **moistureSensor.py** e copia il seguente codice Python nel file:
```
from adafruit_seesaw.seesaw import Seesaw
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA
import logging
import time
import json
import argparse
import busio
# Shadow JSON schema:
#
# {
# "state": {
# "desired":{
# "moisture":,
# "temp":
# }
# }
# }
# Function called when a shadow is updated
def customShadowCallback_Update(payload, responseStatus, token):
# Display status and data from update request
if responseStatus == "timeout":
print("Update request " + token + " time out!")
if responseStatus == "accepted":
payloadDict = json.loads(payload)
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Update request with token: " + token + " accepted!")
print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Update request " + token + " rejected!")
# Function called when a shadow is deleted
def customShadowCallback_Delete(payload, responseStatus, token):
# Display status and data from delete request
if responseStatus == "timeout":
print("Delete request " + token + " time out!")
if responseStatus == "accepted":
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Delete request with token: " + token + " accepted!")
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Delete request " + token + " rejected!")
# Read in command-line parameters
def parseArgs():
parser = argparse.ArgumentParser()
parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host", help="Your device data endpoint")
parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
parser.add_argument("-c", "--cert", action="store", dest="certificatePath", help="Certificate file path")
parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private key file path")
parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port number override")
parser.add_argument("-n", "--thingName", action="store", dest="thingName", default="Bot", help="Targeted thing name")
parser.add_argument("-id", "--clientId", action="store", dest="clientId", default="basicShadowUpdater", help="Targeted client id")
args = parser.parse_args()
return args
# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Parse command line arguments
args = parseArgs()
if not args.certificatePath or not args.privateKeyPath:
parser.error("Missing credentials for authentication.")
exit(2)
# If no --port argument is passed, default to 8883
if not args.port:
args.port = 8883
# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath, args.certificatePath)
# AWSIoTMQTTShadowClient connection configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec
# Initialize Raspberry Pi's I2C interface
i2c_bus = busio.I2C(SCL, SDA)
# Intialize SeeSaw, Adafruit's Circuit Python library
ss = Seesaw(i2c_bus, addr=0x36)
# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()
# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName, True)
# Delete current shadow JSON doc
deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)
# Read data from moisture sensor and update shadow
while True:
# read moisture level through capacitive touch pad
moistureLevel = ss.moisture_read()
# read temperature from the temperature sensor
temp = ss.get_temp()
# Display moisture and temp readings
print("Moisture Level: {}".format(moistureLevel))
print("Temperature: {}".format(temp))
# Create message payload
payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}
# Update shadow
deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
time.sleep(1)
```
Salva il file nella posizione che preferisci. Esegui `moistureSensor.py` dalla riga di comando con i parametri seguenti:
endpoint
Il tuo endpoint personalizzato AWS IoT . Per ulteriori informazioni, consulta [API REST del servizio Device Shadow](device-shadow-rest-api.md).
rootCA
Il percorso completo del certificato CA AWS IoT root.
cert
Il percorso completo del certificato AWS IoT del dispositivo.
Chiave
Il percorso completo della chiave privata AWS IoT del certificato del dispositivo.
thingName
Nome dell'oggetto, in questo caso `RaspberryPi`.
clientId
ID client MQTT. Utilizza `RaspberryPi`.
La riga di comando dovrebbe essere simile alla seguente:
`python3 moistureSensor.py --endpoint your-endpoint --rootCA ~/certs/AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi`
Prova a toccare il sensore, a inserirlo in una fioriera o a immergerlo in un bicchiere d'acqua per vedere come risponde a vari livelli di umidità. Se necessario, puoi modificare il valore di soglia in `MoistureSensorRule`. Quando la lettura del sensore di umidità scende al di sotto del valore specificato nell'istruzione di query SQL della regola, AWS IoT pubblica un messaggio sull'argomento Amazon SNS. Riceverai un messaggio e-mail contenente i dati relativi all'umidità e alla temperatura.
Dopo aver verificato la ricezione dei messaggi e-mail da Amazon SNS, premi **CTRL\$1C** per arrestare il programma Python. È improbabile che il programma Python invii un numero di messaggi tale da comportare un addebito, ma è una best practice interrompere il programma al termine delle operazioni.