Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: 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).