Introduzione alla gestione dei dispositivi (Python)

Articolo
10/01/2024

Le app back-end possono usare primitive dell'hub IoT di Azure, ad esempio dispositivi gemelli e metodi diretti, per avviare e monitorare le azioni di gestione nei dispositivi in modalità remota. Questo articolo mostra il funzionamento combinato di un'app back-end e un'app per dispositivo per avviare e monitorare il riavvio remoto di un dispositivo tramite l'hub IoT.

Nota

Le funzionalità descritte in questo articolo sono disponibili solo nel livello Standard dell'hub IoT. Per altre informazioni sui livelli Basic e Standard/Gratuito dell'hub IoT, vedere Scegliere il livello appropriato dell'hub IoT per la soluzione.

Usare un metodo diretto per avviare le operazioni di gestione dei dispositivi, ad esempio il riavvio, il ripristino delle impostazioni predefinite e l'aggiornamento del firmware, da un'applicazione back-end nel cloud. Il dispositivo è responsabile per:

La gestione della richiesta di metodo inviata dall'hub IoT.
L'avvio, nel dispositivo, dell'azione corrispondente specifica del dispositivo.
Gli aggiornamenti di stato tramite le proprietà segnalate nell'hub IoT.

È possibile usare un'applicazione back-end nel cloud per eseguire query di un dispositivo gemello in modo da creare report sullo stato di avanzamento delle operazioni di gestione del dispositivo.

Questo articolo illustra come creare:

dmpatterns_getstarted_device.py: un'app per dispositivi simulata con un metodo diretto che riavvia il dispositivo e segnala l'ora dell'ultimo riavvio. I metodi diretti vengono richiamati dal cloud.
dmpatterns_getstarted_service.py: un'app console Python che chiama il metodo diretto nell'app per dispositivi simulati tramite l'hub IoT. Visualizza la risposta e le proprietà segnalate aggiornate.

Nota

Vedere Azure IoT SDK per altre informazioni sugli strumenti SDK disponibili per creare app sia per dispositivi che back-end.

Prerequisiti

Un account Azure attivo. Se non si dispone di un account, è possibile crearne uno gratuito in pochi minuti.
Un hub IoT nella sottoscrizione di Azure. Se non si ha ancora un hub, è possibile seguire la procedura descritta in Creare un hub IoT.
Un dispositivo registrato nell'hub IoT. Se non si ha un dispositivo nell'hub IoT, seguire la procedura descritta in Registrare un dispositivo.
È consigliabile usare Python versione 3.7 o successive. Assicurarsi di usare le installazioni a 32 bit o 64 bit, come richiesto dalla configurazione. Quando richiesto durante l'installazione, assicurarsi di aggiungere Python alla variabile di ambiente specifica per la piattaforma.
Assicurarsi che la porta 8883 sia aperta nel firewall. L'esempio di dispositivo di questo articolo usa il protocollo MQTT, che comunica tramite la porta 8883. Questa porta potrebbe essere bloccata in alcuni ambienti di rete aziendali e didattici. Per altre informazioni e soluzioni alternative per questo problema, vedere Connettersi all'hub IoT (MQTT).

Registrare un nuovo dispositivo nell'hub IoT

In questa sezione si usa l'interfaccia della riga di comando di Azure per creare un'identità del dispositivo per questo articolo. Gli ID dispositivo fanno distinzione tra maiuscole e minuscole.

Aprire Azure Cloud Shell.
In Azure Cloud Shell, eseguire questo comando per aggiungere l'estensione Microsoft Azure IoT per l'interfaccia della riga di comando di Azure:
```
az extension add --name azure-iot
```
Creare una nuova identità del dispositivo denominata myDeviceId e recuperare la stringa di connessione con questi comandi:
```
az iot hub device-identity create --device-id myDeviceId --hub-name {Your IoT Hub name} --resource-group {Resource group of the Hub}
az iot hub device-identity connection-string show --device-id myDeviceId --hub-name {Your IoT Hub name} --resource-group {Resource group of the Hub} -o table
```
Importante

L'ID dispositivo può essere visibile nei log raccolti per il supporto tecnico e la risoluzione dei problemi, quindi evitare di includere informazioni sensibili nel nome assegnato.

Annotare la stringa di connessione del dispositivo visualizzata nei risultati. Questa stringa di connessione del dispositivo viene usata dall'app del dispositivo per la connessione all'hub IoT come dispositivo.

Creare un'app per dispositivi con un metodo diretto

In questa sezione verrà illustrato come:

Creare un'app console Python che risponde a un metodo diretto chiamato dal cloud.
Simulare un riavvio del dispositivo.
Usare le proprietà segnalate per abilitare le query nei dispositivi gemelli in modo da identificare i dispositivi e l'ora dell'ultimo riavvio.

Importante

Questo articolo include la procedura per connettere un dispositivo usando una firma di accesso condiviso, altrimenti chiamata autenticazione con chiave simmetrica. Questo metodo di autenticazione è comodo per i test e le valutazioni, ma l'autenticazione tramite certificati X.509 rappresenta un approccio più sicuro. Per scoprire di più, vedere Procedure consigliate per la sicurezza > Sicurezza della connessione.

In Azure Cloud Shell usato in precedenza o in qualsiasi altro ambiente con Python creare il codice del dispositivo.

Al prompt dei comandi eseguire il comando seguente per installare il pacchetto azure-iot-device:
```
pip install azure-iot-device
```
Usando un editor di testo, nella directory di lavoro creare un file denominato dmpatterns_getstarted_device.py.

Aggiungere le istruzioni import seguenti all'inizio del file dmpatterns_getstarted_device.py.

import time
import datetime
from azure.iot.device import IoTHubDeviceClient, MethodResponse

Aggiungere la variabile CONNECTION_STRING. Sostituire il segnaposto {deviceConnectionString} con la stringa di connessione del dispositivo. Questa stringa di connessione è stata copiata in precedenza in Registrare un nuovo dispositivo nell’hub IoT.
```
CONNECTION_STRING = "{deviceConnectionString}"
```

Aggiungere la funzione seguente per creare un'istanza di un client configurato per i metodi diretti nel dispositivo.

def create_client():
    # Instantiate the client
    client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)

    # Define the handler for method requests
    def method_request_handler(method_request):
        if method_request.name == "rebootDevice":
            # Act on the method by rebooting the device
            print("Rebooting device")
            time.sleep(20)
            print("Device rebooted")

            # ...and patching the reported properties
            current_time = str(datetime.datetime.now())
            reported_props = {"rebootTime": current_time}
            client.patch_twin_reported_properties(reported_props)
            print( "Device twins updated with latest rebootTime")

            # Create a method response indicating the method request was resolved
            resp_status = 200
            resp_payload = {"Response": "This is the response from the device"}
            method_response = MethodResponse(method_request.request_id, resp_status, resp_payload)

        else:
            # Create a method response indicating the method request was for an unknown method
            resp_status = 404
            resp_payload = {"Response": "Unknown method"}
            method_response = MethodResponse(method_request.request_id, resp_status, resp_payload)

        # Send the method response
        client.send_method_response(method_response)

    try:
        # Attach the handler to the client
        client.on_method_request_received = method_request_handler
    except:
        # In the event of failure, clean up
        client.shutdown()

    return client

Avviare l'esempio di metodo diretto e attendere.

def main():
    print ("Starting the IoT Hub Python sample...")
    client = create_client()

    print ("Waiting for commands, press Ctrl-C to exit")
    try:
        # Wait for program exit
        while True:
            time.sleep(1000)
    except KeyboardInterrupt:
        print("IoTHubDeviceClient sample stopped")
    finally:
        # Graceful exit
        print("Shutting down IoT Hub Client")
        client.shutdown()

if __name__ == '__main__':
    main()

Salvare e chiudere il file dmpatterns_getstarted_device.py.

Nota

Per semplicità, in questa esercitazione non si implementa alcun criterio di ripetizione dei tentativi. Nel codice di produzione è consigliabile implementare criteri di ripetizione dei tentativi, ad esempio un backoff esponenziale, come suggerito nell'articolo Gestione degli errori temporanei.

Ottenere la stringa di connessione dell'hub IoT

In questo articolo viene creato un servizio back-end che richiama un metodo diretto in un dispositivo. Per richiamare un metodo diretto in un dispositivo tramite l'hub IoT, è necessario che il servizio disponga delle autorizzazioni di connessione al servizio. Per impostazione predefinita, ogni hub IoT viene creato con un servizio con nome di criteri di accesso condiviso che concede tale autorizzazione.

Per ottenere la stringa di connessione dell'hub IoT per i criteri del servizio, seguire questa procedura:

Nel portale di Azure fare clic su Gruppi di risorse. Selezionare il gruppo di risorse in cui si trova l'hub e quindi selezionare l'hub dall'elenco di risorse.
Nel riquadro sinistro dell'hub IoT selezionare Criteri di accesso condiviso.
Dall'elenco dei criteri selezionare i criteri del servizio.
Copiare la Stringa di connessione primaria e salvare il valore.

Per altre informazioni sui criteri di accesso condiviso e sulle autorizzazioni dell'hub IoT, vedere Controllo dell'accesso e autorizzazioni.

Creare un'app del servizio per attivare un riavvio

In questa sezione viene creata un'app console Python che attiva un riavvio remoto in un dispositivo usando un metodo diretto. L'app esegue query nel dispositivo gemello per ottenere l'ora dell'ultimo riavvio del dispositivo in questione.

Importante

Questo articolo include la procedura per connettersi a un servizio usando una firma di accesso condiviso. Questo metodo di autenticazione è comodo per i test e le valutazioni, ma l'autenticazione a un servizio con Microsoft Entra ID o identità gestite rappresenta un approccio più sicuro. Per altre informazioni, vedere Procedure consigliate per la sicurezza > Sicurezza cloud.

In Azure Cloud Shell o in qualsiasi altro ambiente con Python creare il codice della console.

Al prompt dei comandi eseguire il comando seguente per installare il pacchetto azure-iot-hub:
```
pip install azure-iot-hub
```
Usando un editor di testo, nella directory di lavoro creare un file denominato dmpatterns_getstarted_service.py.

Aggiungere le istruzioni import seguenti all'inizio del file dmpatterns_getstarted_service.py.

import sys, time

from azure.iot.hub import IoTHubRegistryManager
from azure.iot.hub.models import CloudToDeviceMethod, CloudToDeviceMethodResult, Twin

Aggiungere le dichiarazioni di variabili seguenti. Sostituire il valore segnaposto {IoTHubConnectionString} con la stringa di connessione dell'hub IoT copiata in precedenza in Ottenere la stringa di connessione dell’hub IoT. Sostituire il valore segnaposto {deviceId} con l’ID dispositivo registrato in Registrare un nuovo dispositivo nell’hub IoT.
```
CONNECTION_STRING = "{IoTHubConnectionString}"
DEVICE_ID = "{deviceId}"

METHOD_NAME = "rebootDevice"
METHOD_PAYLOAD = "{\"method_number\":\"42\"}"
TIMEOUT = 60
WAIT_COUNT = 10
```

Aggiungere la funzione seguente per richiamare il metodo del dispositivo per riavviare il dispositivo di destinazione, quindi eseguire una query per i dispositivi gemelli e ottenere la data e l'ora dell'ultimo riavvio.

def iothub_devicemethod_sample_run():
    try:
        # Create IoTHubRegistryManager
        registry_manager = IoTHubRegistryManager(CONNECTION_STRING)

        print ( "" )
        print ( "Invoking device to reboot..." )

        # Call the direct method.
        deviceMethod = CloudToDeviceMethod(method_name=METHOD_NAME, payload=METHOD_PAYLOAD)
        response = registry_manager.invoke_device_method(DEVICE_ID, deviceMethod)

        print ( "" )
        print ( "Successfully invoked the device to reboot." )

        print ( "" )
        print ( response.payload )

        while True:
            print ( "" )
            print ( "IoTHubClient waiting for commands, press Ctrl-C to exit" )

            status_counter = 0
            while status_counter <= WAIT_COUNT:
                twin_info = registry_manager.get_twin(DEVICE_ID)

                if twin_info.properties.reported.get("rebootTime") != None :
                    print ("Last reboot time: " + twin_info.properties.reported.get("rebootTime"))
                else:
                    print ("Waiting for device to report last reboot time...")

                time.sleep(5)
                status_counter += 1

    except Exception as ex:
        print ( "" )
        print ( "Unexpected error {0}".format(ex) )
        return
    except KeyboardInterrupt:
        print ( "" )
        print ( "IoTHubDeviceMethod sample stopped" )

if __name__ == '__main__':
    print ( "Starting the IoT Hub Service Client DeviceManagement Python sample..." )
    print ( "    Connection string = {0}".format(CONNECTION_STRING) )
    print ( "    Device ID         = {0}".format(DEVICE_ID) )

    iothub_devicemethod_sample_run()

Salvare e chiudere il file dmpatterns_getstarted_service.py.

Eseguire le app

È ora possibile eseguire il codice del dispositivo e il codice del servizio che avvia un riavvio del dispositivo.

Al prompt dei comandi nella cartella dove è stato creato il dispositivo eseguire questo comando per iniziare l'ascolto del metodo diretto di riavvio.
```
python dmpatterns_getstarted_device.py
```
Al prompt dei comandi nella cartella dove si crea il servizio eseguire questo comando per attivare il riavvio remoto ed eseguire query in modo che il dispositivo gemello trovi l'ora dell'ultimo riavvio.
```
python dmpatterns_getstarted_service.py
```
Nella console viene visualizzata la risposta del dispositivo al metodo diretto.

Di seguito viene illustrata la risposta del dispositivo al metodo diretto di riavvio:

Di seguito viene illustrato il servizio che chiama il metodo diretto di riavvio e il polling del dispositivo gemello per lo stato:

Personalizzare ed estendere le operazioni di gestione dei dispositivi

Le soluzioni IoT possono espandere il set definito di modelli di gestione dei dispositivi o abilitare modelli personalizzati mediante l'uso di primitive di metodo da cloud a dispositivo e del dispositivo gemello. Altri esempi di operazioni di gestione dei dispositivi includono il ripristino delle informazioni predefinite, l'aggiornamento del firmware, l'aggiornamento del software, il risparmio energia, la gestione di rete e connettività e la crittografia dei dati.

Finestre di manutenzione del dispositivo

Configurare i dispositivi in modo che eseguano le azioni in un momento che riduce al minimo le interruzioni e i tempi di inattività. Le finestre di manutenzione del dispositivo costituiscono un modello comunemente usato per definire il momento in cui un dispositivo deve eseguire l'aggiornamento della configurazione. Le soluzioni di back-end possono usare le proprietà desiderate del dispositivo gemello per definire e attivare un criterio sul dispositivo che attiva una finestra di manutenzione. Quando un dispositivo riceve il criterio della finestra di manutenzione, può usare la proprietà segnalata del dispositivo gemello per segnalare lo stato del criterio. L'applicazione back-end può quindi usare le query del dispositivo gemello per attestare la conformità dei dispositivi e di tutti i criteri.

Passaggi successivi

In questo articolo è stato usato un metodo diretto per attivare un riavvio remoto su un dispositivo. Sono state usate le proprietà segnalate per indicare l'ora dell'ultimo riavvio dal dispositivo ed è stata eseguita una query sul dispositivo gemello per ottenere l'ora dell'ultimo riavvio del dispositivo dal cloud.

Per continuare l'introduzione ai modelli di gestione dei dispositivi hub IoT, come l'aggiornamento end-to-end basato su immagini, vedere l'articolo Aggiornamento del dispositivo per hub IoT di Azure con l'immagine di riferimento Raspberry Pi 3 B+.

Per informazioni su come estendere la soluzione IoT e pianificare le chiamate al metodo su più dispositivi, vedere Pianificare e trasmettere processi.

Condividi tramite

Introduzione alla gestione dei dispositivi (Python)

Prerequisiti

Registrare un nuovo dispositivo nell'hub IoT

Creare un'app per dispositivi con un metodo diretto

Ottenere la stringa di connessione dell'hub IoT

Creare un'app del servizio per attivare un riavvio

Eseguire le app

Personalizzare ed estendere le operazioni di gestione dei dispositivi

Finestre di manutenzione del dispositivo

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive