Connettere il dispositivo simulato all'hub IoT usando Python

Introduzione

L'hub IoT di Azure è un servizio completamente gestito che consente comunicazioni bidirezionali affidabili e sicure tra milioni di dispositivi IoT (Internet delle cose) e un back-end della soluzione. Una delle maggiori difficoltà con i progetti IoT consiste nel connettere in modo affidabile e sicuro i dispositivi al back-end della soluzione. Per affrontare questa sfida, l'hub IoT:

  • Offre messaggistica affidabile da dispositivo a cloud e da cloud a dispositivo su vasta scala.
  • Rende possibili comunicazioni sicure mediante le credenziali di sicurezza per i singoli dispositivi e il controllo di accesso.
  • Comprende librerie di dispositivi per i linguaggi e le piattaforme più diffusi.

Questa esercitazione illustra come:

  • Usare il portale di Azure per creare un hub IoT.
  • Creare un'identità del dispositivo nell'hub IoT.
  • Creare un'app per dispositivo simulato che invii dati di telemetria al back-end della soluzione.

Al termine di questa esercitazione si avranno due app Python:

  • CreateDeviceIdentity.py, che crea un'identità del dispositivo e la chiave di sicurezza associata per connettere l'app per dispositivo simulato.
  • SimulatedDevice.py, che si connette all'hub IoT con l'identità del dispositivo creata in precedenza e invia periodicamente un messaggio di telemetria usando il protocollo MQTT.
Nota

L'articolo Azure IoT SDK offre informazioni sui vari Azure IoT SDK che è possibile usare per compilare applicazioni da eseguire nei dispositivi e il backend della soluzione.

Per completare l'esercitazione, sono necessari gli elementi seguenti:

Nota

I pacchetti pip per azure-iothub-service-client e azure-iothub-device-client sono attualmente disponibili solo per il sistema operativo Windows. Per Linux o Mac OS, vedere le sezioni dedicate ai sistemi operativi Linux e Mac OS nel post Prepare your development environment for Python (Preparare l'ambiente di sviluppo per Python).

Creare un hub IoT

Creare un hub IoT per connettere l'app per dispositivo simulato. La procedura seguente illustra come completare questa attività usando il portale di Azure.

  1. Accedere al portale di Azure.
  2. Nell'indice fare clic su Nuovo > Internet delle cose > Hub IoT.

    Indice del portale di Azure

  3. Nel pannello Hub IoT scegliere la configurazione per l'hub IoT.

    Pannello Hub IoT

    1. Nella casella Nome immettere un nome per l'hub IoT. Se il Nome è valido e disponibile, appare un segno di spunta verde nella casella Nome.

      Importante

      L'hub IoT sarà individuabile pubblicamente come endpoint DNS, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.

    2. Selezionare un piano tariffario e un livello di scalabilità. Per questa esercitazione non è necessario un livello specifico. Per questa esercitazione, usare il livello F1 gratuito.

    3. In Gruppo di risorse creare un gruppo di risorse o selezionarne uno esistente. Per altre informazioni, vedere Using resource groups to manage your Azure resources (Uso di Gruppi di risorse per gestire le risorse di Azure).
    4. In Percorsoselezionare il percorso per ospitare l'hub IoT. Per questa esercitazione, scegliere la località più vicina.
  4. Dopo aver scelto le opzioni di configurazione dell'hub IoT, fare clic su Crea. La creazione dell'hub IoT da parte di Azure può richiedere alcuni minuti. Per verificare lo stato, è possibile monitorare l'avanzamento nella Schermata iniziale o nel pannello Notifiche.

    Stato del nuovo hub IoT

  5. Dopo avere creato l'hub IoT, fare clic sul nuovo riquadro per l'hub IoT nel portale di Azure per aprire il pannello del nuovo hub IoT. Annotare il Nome host, quindi fare clic su Criteri di accesso condiviso.

    Pannello del nuovo hub IoT

  6. Nel pannello Criteri di accesso condivisi fare clic sul criterio iothubowner, quindi copiare e annotare la stringa di connessione dell'hub IoT nel pannello iothubowner. Per altre informazioni, vedere Controllo di accesso nella "Guida per gli sviluppatori dell'hub IoT".

    Pannello Criteri di accesso condivisi

L'hub IoT è stato creato. Usare il nome host e la stringa di connessione dell'hub IoT nel resto dell'esercitazione.

Nota

È anche possibile creare con facilità un hub IoT personalizzato in una riga di comando, usando l'interfaccia della riga di comando di Azure basata su Python o Node.js. L'articolo Creare un hub IoT usando l'interfaccia della riga di comando di Azure 2.0 illustra la procedura rapida per eseguire questa operazione.

Creare un'identità del dispositivo

Questa sezione elenca i passaggi per la creazione di un'app console Python, che crea un'identità del dispositivo nel registro delle identità dell'hub IoT. Un dispositivo può connettersi all'hub IoT solo se ha una voce nel registro delle identità. Per altre informazioni, vedere la sezione Registro di identità della Guida per gli sviluppatori dell'hub IoT. Quando si esegue questa app console vengono generati un ID dispositivo univoco e una chiave con cui il dispositivo può identificarsi quando invia messaggi da dispositivo a cloud all'hub IoT.

  1. Aprire un prompt dei comandi e installare Azure IoT Hub Service SDK per Python. Chiudere il prompt dei comandi dopo l'installazione dell'SDK.

    pip install azure-iothub-service-client
    
  2. Creare un file di Python denominato CreateDeviceIdentity.py. Aprirlo in un editor/IDE di Python di propria scelta, ad esempio l'editor IDLE predefinito.

  3. Aggiungere il codice seguente per importare i moduli necessari dall'SDK del servizio:

    import sys
    import iothub_service_client
    from iothub_service_client import IoTHubRegistryManager, IoTHubRegistryManagerAuthMethod
    from iothub_service_client import IoTHubDeviceStatus, IoTHubError
    
  4. Aggiungere il codice seguente, sostituendo il segnaposto per [IoTHub Connection String] con la stringa di connessione dell'hub IoT creato nella sezione precedente. È possibile usare qualsiasi nome per DEVICE_ID.

    CONNECTION_STRING = "[IoTHub Connection String]"
    DEVICE_ID = "MyFirstPythonDevice"
    
    Importante

    L'ID dispositivo può essere visibile nei log raccolti per il supporto tecnico e la risoluzione dei problemi, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.

  5. Aggiungere la funzione seguente per stampare alcune informazioni del dispositivo.

    def print_device_info(title, iothub_device):
        print ( title + ":" )
        print ( "iothubDevice.deviceId                    = {0}".format(iothub_device.deviceId) )
        print ( "iothubDevice.primaryKey                  = {0}".format(iothub_device.primaryKey) )
        print ( "iothubDevice.secondaryKey                = {0}".format(iothub_device.secondaryKey) )
        print ( "iothubDevice.connectionState             = {0}".format(iothub_device.connectionState) )
        print ( "iothubDevice.status                      = {0}".format(iothub_device.status) )
        print ( "iothubDevice.lastActivityTime            = {0}".format(iothub_device.lastActivityTime) )
        print ( "iothubDevice.cloudToDeviceMessageCount   = {0}".format(iothub_device.cloudToDeviceMessageCount) )
        print ( "iothubDevice.isManaged                   = {0}".format(iothub_device.isManaged) )
        print ( "iothubDevice.authMethod                  = {0}".format(iothub_device.authMethod) )
        print ( "" )
    
  6. Aggiungere la funzione seguente per creare l'identificazione del dispositivo usando Gestore Registro di sistema.

    def iothub_createdevice():
        try:
            iothub_registry_manager = IoTHubRegistryManager(CONNECTION_STRING)
            auth_method = IoTHubRegistryManagerAuthMethod.SHARED_PRIVATE_KEY
            new_device = iothub_registry_manager.create_device(DEVICE_ID, "", "", auth_method)
            print_device_info("CreateDevice", new_device)
    
        except IoTHubError as iothub_error:
            print ( "Unexpected error {0}".format(iothub_error) )
            return
        except KeyboardInterrupt:
            print ( "iothub_createdevice stopped" )
    
  7. Aggiungere infine la funzione main, come indicato di seguito, quindi salvare il file.

    if __name__ == '__main__':
        print ( "" )
        print ( "Python {0}".format(sys.version) )
        print ( "Creating device using the Azure IoT Hub Service SDK for Python" )
        print ( "" )
        print ( "    Connection string = {0}".format(CONNECTION_STRING) )
        print ( "    Device ID         = {0}".format(DEVICE_ID) )
    
        iothub_createdevice()
    
  8. Nel prompt dei comandi eseguire CreateDeviceIdentity.py, come indicato di seguito:

    python CreateDeviceIdentity.py
    
  9. Verrà visualizzata la creazione del dispositivo simulato. Annotare il valore di deviceId e di primaryKey per il dispositivo. che saranno necessari più avanti quando si creerà un'applicazione che si connette all'hub IoT come dispositivo.

    La creazione del dispositivo è stata completata

Nota

Il registro di identità dell'hub IoT archivia solo le identità del dispositivo per abilitare l'accesso sicuro all'hub. Archivia le chiavi e gli ID dispositivo da usare come credenziali di sicurezza e un flag di abilitazione/disabilitazione che consente di disabilitare l'accesso per un singolo dispositivo. Se l'applicazione deve archiviare altri metadati specifici del dispositivo, dovrà usare un archivio specifico dell'applicazione. Per altre informazioni, vedere la Guida per gli sviluppatori dell'hub IoT.

Creare un'app di dispositivo simulato

Questa sezione elenca i passaggi per la creazione di un'app console di Python, che simula un dispositivo e invia messaggi da dispositivo a cloud all'hub IoT.

  1. Aprire un nuovo prompt dei comandi e installare Azure IoT Hub Device SDK per Python, come indicato di seguito. Chiudere il prompt dei comandi dopo l'installazione.

    pip install azure-iothub-device-client
    
  2. Creare un file denominato SimulatedDevice.py. Aprire il file in un editor/IDE di Python di propria scelta, ad esempio IDLE.

  3. Aggiungere il codice seguente per importare i moduli necessari dall'SDK del dispositivo.

    import random
    import time
    import sys
    import iothub_client
    from iothub_client import IoTHubClient, IoTHubClientError, IoTHubTransportProvider, IoTHubClientResult
    from iothub_client import IoTHubMessage, IoTHubMessageDispositionResult, IoTHubError, DeviceMethodReturnValue
    
  4. Aggiungere il codice seguente e sostituire il segnaposto per [IoTHub Device Connection String] con la stringa di connessione per il dispositivo. La stringa di connessione del dispositivo ha in genere il formato HostName=<hostName>;DeviceId=<deviceId>;SharedAccessKey=<primaryKey>. Usare il valore deviceId e il valore primaryKey del dispositivo creato nella sezione precedente per sostituire rispettivamente i valori <deviceId> e <primaryKey>. Sostituire <hostName> con il nome host dell'hub IoT, in genere come <IoT hub name>.azure-devices.net.

    # String containing Hostname, Device Id & Device Key in the format
    CONNECTION_STRING = "[IoTHub Device Connection String]"
    # choose HTTP, AMQP or MQTT as transport protocol
    PROTOCOL = IoTHubTransportProvider.MQTT
    MESSAGE_TIMEOUT = 10000
    AVG_WIND_SPEED = 10.0
    SEND_CALLBACKS = 0
    MSG_TXT = "{\"deviceId\": \"MyFirstPythonDevice\",\"windSpeed\": %.2f}"    
    
  5. Aggiungere il codice seguente per definire un callback di conferma di invio.

    def send_confirmation_callback(message, result, user_context):
        global SEND_CALLBACKS
        print ( "Confirmation[%d] received for message with result = %s" % (user_context, result) )
        map_properties = message.properties()
        print ( "    message_id: %s" % message.message_id )
        print ( "    correlation_id: %s" % message.correlation_id )
        key_value_pair = map_properties.get_internals()
        print ( "    Properties: %s" % key_value_pair )
        SEND_CALLBACKS += 1
        print ( "    Total calls confirmed: %d" % SEND_CALLBACKS )
    
  6. Aggiungere il codice seguente per inizializzare il client del dispositivo.

    def iothub_client_init():
        # prepare iothub client
        client = IoTHubClient(CONNECTION_STRING, PROTOCOL)
        # set the time until a message times out
        client.set_option("messageTimeout", MESSAGE_TIMEOUT)
        client.set_option("logtrace", 0)
        return client
    
  7. Aggiungere la funzione seguente al formato e inviare un messaggio dal dispositivo simulato all'hub IoT.

    def iothub_client_telemetry_sample_run():
    
        try:
            client = iothub_client_init()
            print ( "IoT Hub device sending periodic messages, press Ctrl-C to exit" )
            message_counter = 0
    
            while True:
                msg_txt_formatted = MSG_TXT % (AVG_WIND_SPEED + (random.random() * 4 + 2))
                # messages can be encoded as string or bytearray
                if (message_counter & 1) == 1:
                    message = IoTHubMessage(bytearray(msg_txt_formatted, 'utf8'))
                else:
                    message = IoTHubMessage(msg_txt_formatted)
                # optional: assign ids
                message.message_id = "message_%d" % message_counter
                message.correlation_id = "correlation_%d" % message_counter
                # optional: assign properties
                prop_map = message.properties()
                prop_text = "PropMsg_%d" % message_counter
                prop_map.add("Property", prop_text)
    
                client.send_event_async(message, send_confirmation_callback, message_counter)
                print ( "IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub." % message_counter )
    
                status = client.get_send_status()
                print ( "Send status: %s" % status )
                time.sleep(30)
    
                status = client.get_send_status()
                print ( "Send status: %s" % status )
    
                message_counter += 1
    
        except IoTHubError as iothub_error:
            print ( "Unexpected error %s from IoTHub" % iothub_error )
            return
        except KeyboardInterrupt:
            print ( "IoTHubClient sample stopped" )
    
  8. Aggiungere infine la funzione main.

    if __name__ == '__main__':
        print ( "Simulating a device using the Azure IoT Hub Device SDK for Python" )
        print ( "    Protocol %s" % PROTOCOL )
        print ( "    Connection string=%s" % CONNECTION_STRING )
    
        iothub_client_telemetry_sample_run()
    
  9. Salvare e chiudere il file SimulatedDevice.py. A questo punto è possibile eseguire l'app.
Nota

Per semplicità, in questa esercitazione non si implementa alcun criterio di ripetizione dei tentativi. Nel codice di produzione è consigliabile implementare criteri per i tentativi, ad esempio un backoff esponenziale, come illustrato nell'articolo di MSDN Transient Fault Handling (Gestione degli errori temporanei).

Ricevere messaggi dal dispositivo simulato

Per ricevere messaggi di telemetria dal dispositivo, è necessario usare un endpoint compatibile con Hub eventi esposto dall'hub IoT, che legge i messaggi dal dispositivo al cloud. Per informazioni su come elaborare i messaggi dagli hub eventi per l'endpoint compatibile con hub eventi dell'hub IoT, vedere l'esercitazione Introduzione agli hub eventi. Gli hub eventi non supportano ancora la telemetria in Python. È quindi possibile creare un'app console di Node.js o .NET basata sugli hub eventi per leggere i messaggi dal dispositivo al cloud dall'hub IoT. Questa esercitazione mostra come usare lo strumento IoT Hub Explorer per leggere questi messaggi del dispositivo.

  1. Aprire un prompt dei comandi e installare IoT Hub Explorer.

    npm install -g iothub-explorer
    
  2. Eseguire il comando seguente nel prompt dei comandi per avviare il monitoraggio dei messaggi dal dispositivo al cloud dal dispositivo. Usare la stringa di connessione dell'hub IoT nel segnaposto dopo --login.

    iothub-explorer monitor-events MyFirstPythonDevice --login "[IoTHub connection string]"
    
  3. Aprire un nuovo prompt dei comandi e passare alla directory contenente il file SimulatedDevice.py.

  4. Eseguire il file SimulatedDevice.py, che invia periodicamente dati di telemetria all'hub IoT.

    python SimulatedDevice.py
    
  5. Osservare i messaggi del dispositivo nel prompt dei comandi eseguendo lo strumento IoT Hub Explorer dalla sezione precedente.

    Messaggi dal dispositivo Python al cloud

Passaggi successivi

In questa esercitazione è stato configurato un nuovo hub IoT nel Portale di Azure ed è stata quindi creata un'identità del dispositivo nel registro di identità dell'hub IoT. Questa identità del dispositivo è stata usata per consentire all'app per dispositivo simulato di inviare all'hub IoT messaggi dispositivo a cloud. Sono stati osservati i messaggi ricevuti dall'hub IoT tramite lo strumento IoT Hub Explorer.

Per esplorare Python SDK per ottenere informazioni approfondite sull'utilizzo dell'hub IoT di Azure, vedere questo repository di GitHub. Per verificare le funzionalità di messaggistica di Azure IoT Hub Service SDK per Python, è possibile scaricare ed eseguire iothub_messaging_sample.py. Per la simulazione lato dispositivo con Azure IoT Hub Device SDK per Python, è possibile scaricare ed eseguire iothub_client_sample.py.

Per altre informazioni sulle attività iniziali con l'hub IoT e per esplorare altri scenari IoT, vedere:

Per informazioni sull'estensione della soluzione IoT e l'elaborazione di messaggi dispositivo a cloud su vasta scala, vedere l'esercitazione Elaborare messaggi dispositivo a cloud.

Per altre informazioni sulle attività iniziali con l'hub IoT di Azure e per esplorare altri scenari IoT, vedere: