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 a AWS IoT Core utilizzando SDK per dispositivi AWS IoT

In questo tutorial viene illustrato come collegare un dispositivo a AWS IoT Core in modo che possa inviare e ricevere dati da e verso AWS IoT. Una volta completato il tutorial, il dispositivo verrà configurato per connettersi a AWS IoT Core e capirai come i dispositivi comunicano con AWS IoT.

In questo tutorial, verranno eseguite le operazioni seguenti:

Questo tutorial dura circa un’ora.

Prepara il dispositivo per AWS IoT

In Guida introduttiva ai AWS IoT Core tutorial, hai preparato il tuo dispositivo e account AWS in modo che potessero comunicare. Questa sezione esamina gli aspetti di tale preparazione che si applicano a qualsiasi connessione del dispositivo con AWS IoT Core.

Affinché un dispositivo si connetta a AWS IoT Core:

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.

MQTT utilizza un modello di comunicazione pubblica/sottoscrivi

Il protocollo MQTT utilizza un modello di comunicazione pubblica/sottoscrivi con il relativo host. Questo modello differisce dal modello di richiesta/risposta 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 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) 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 a AWS IoT Core per pubblicare e sottoscrivere messaggi MQTT. Nella sezione successiva vengono presentati alcuni esercizi che consentono di esplorare il modo in cui un dispositivo si connette e comunica con AWS IoT Core.

Protocolli di comunicazione

L’esempio pubsub.py illustra una connessione MQTT utilizzando i protocolli MQTT e MQTT su WSS. Il AWS runtime comune (CRT AWS) fornisce il supporto del protocollo di comunicazione di basso livello ed è incluso con il SDK per dispositivi AWS IoT v2 per Python.

MQTT

L'esempio pubsub.py chiama mtls_from_path (mostrato qui) in mqtt_connection_builder 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 CRT AWS 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
)

MQTT su WSS

L'esempio pubsub.py chiama websockets_with_default_aws_signing (mostrato qui) in mqtt_connection_builder 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 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
)

HTTPS

Per quanto riguarda il protocollo HTTPS? AWS IoT Core supporta i 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 utilizzando la libreria di Python requests. In questo esempio viene inviato un messaggio a AWS IoT Core utilizzando HTTPS in modo tale che AWS IoT Core lo interpreti come un messaggio MQTT.

AWS IoT Core supporta le richieste HTTPS dai dispositivi ma assicurati di rivedere le informazioni su Scelta di un protocollo applicativo per la comunicazione del dispositivo in modo da poter prendere una decisione informata sul protocollo da utilizzare per le comunicazioni del dispositivo.

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 MQTTsessioni persistenti.

Qualità del servizio

Quando il dispositivo pubblica e si sottoscrive ai 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 su AWS IoT, consulta MQTTOpzioni di qualità del servizio (QoS).

Il runtime CRT AWS per Python definisce queste costanti per i livelli QoS che supporta:

Nell'app di esempio, le richieste di pubblicazione e sottoscrizione vengono effettuate con un livello QoS di 1 (mqtt.QoS.AT_LEAST_ONCE).

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
)

Abbonamento messaggi

Per ricevere messaggi da AWS IoT e altri servizi e dispositivi, i dispositivi sottoscrivono tali messaggi in base al nome dell'argomento. I dispositivi possono sottoscrivere singoli messaggi specificando un nome argomento e a un gruppo di messaggi specificando un filtro di argomenti 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()

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()

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.

Connessione del dispositivo e comunicazione 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 nella console AWS IoT per vedere cosa pubblica il dispositivo e pubblicare messaggi sul dispositivo. Questi esercizi utilizzano il pubsub.py di esempio dall'SDK del dispositivo AWS IoT v2 per Python e si basano sulla tua esperienza con i tutorial Guida introduttiva ai AWS IoT Core tutorial.

Per questi esercizi, inizierai dal programma di esempio pubsub.py.

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.

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

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 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

Con questo, il dispositivo può generare messaggi da inviare a AWS IoT Core per testare la connettività di base e fornire messaggi sui dispositivi per farli elaborare a AWS IoT Core. Ad esempio, puoi usare questa app per inviare dati di test dal tuo dispositivo per testare le operazioni delle regole AWS IoT.

Rivedi i risultati

Gli esempi in questo tutorial ti hanno offerto un'esperienza pratica con le nozioni di base su come i dispositivi possono comunicare con AWS IoT Core, una parte fondamentale della soluzione AWS IoT. Quando i dispositivi sono in grado di comunicare con AWS IoT Core, possono passare messaggi ai servizi AWS e ad altri dispositivi su cui possono agire. Allo stesso modo, i servizi AWS e altri dispositivi possono elaborare informazioni che si traducono in messaggi inviati ai tuoi dispositivi.

Quando sei pronto per esplorare maggiormente AWS IoT Core, prova questi tutorial: