Introduzione alla gestione dei dispositivi (Node.js)

Articolo
06/24/2023

Le app back-end possono usare hub IoT di Azure primitive, ad esempio dispositivi gemelli e metodi diretti, per avviare e monitorare in remoto le azioni di gestione dei dispositivi nei dispositivi. Questo articolo illustra come un'app back-end e un'app per dispositivi possono collaborare per avviare e monitorare un riavvio remoto del dispositivo usando hub IoT.

Nota

Le funzionalità descritte in questo articolo sono disponibili solo nel livello Standard dell'hub IoT. Per altre informazioni sui livelli di hub IoT standard e standard, vedere Scegliere il livello di hub IoT appropriato 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.js: un'app per dispositivo simulato 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.js: un'app console .NET che chiama il metodo diretto nell'app per dispositivi simulati tramite l'hub IoT. Visualizza la risposta e le proprietà segnalate aggiornate.

Prerequisiti

Un hub IoT. Crearne uno con l'interfaccia della riga di comando o il portale di Azure.
Un dispositivo registrato. Registrarne uno nel portale di Azure.
Node.js 10.0.x o versione successiva. Preparare l'ambiente di sviluppo descrive come installare Node.js per questo articolo in Windows o Linux.
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).

Creare un'app per dispositivo con un metodo diretto

In questa sezione verrà illustrato come:

Creare un'app console Node.js che risponde a un metodo diretto chiamato dal cloud.
Attivare un riavvio del dispositivo simulato.
Usare le proprietà segnalate per consentire alle query del dispositivo gemello di identificare i dispositivi e all'ultimo riavvio.

Creare una cartella vuota denominata managed-device. Nella cartella managed-device creare un file package.json usando il comando seguente al prompt dei comandi. Accettare tutte le impostazioni predefinite:
```
npm init
```
Al prompt dei comandi nella cartella managed-device eseguire il comando seguente per installare il pacchetto azure-iot-device Device SDK e il pacchetto azure-iot-device-mqtt :
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Usando un editor di testo, creare un file dmpatterns_getstarted_device.js nella cartella managed-device .

Aggiungere le istruzioni "require" seguenti all'inizio del file dmpatterns_getstarted_device.js:

'use strict';

var Client = require('azure-iot-device').Client;
var Protocol = require('azure-iot-device-mqtt').Mqtt;

Aggiungere una variabile connectionString e usarla per creare un'istanza Client. Sostituire il {yourdeviceconnectionstring} valore segnaposto con la stringa di connessione del dispositivo visualizzata quando è stato registrato un dispositivo nel hub IoT:
```
var connectionString = '{yourdeviceconnectionstring}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Aggiungere la funzione seguente per implementare il metodo diretto nel dispositivo

var onReboot = function(request, response) {

    // Respond the cloud app for the direct method
    response.send(200, 'Reboot started', function(err) {
        if (err) {
            console.error('An error occurred when sending a method response:\n' + err.toString());
        } else {
            console.log('Response to method \'' + request.methodName + '\' sent successfully.');
        }
    });

    // Report the reboot before the physical restart
    var date = new Date();
    var patch = {
        iothubDM : {
            reboot : {
                lastReboot : date.toISOString(),
            }
        }
    };

    // Get device Twin
    client.getTwin(function(err, twin) {
        if (err) {
            console.error('could not get twin');
        } else {
            console.log('twin acquired');
            twin.properties.reported.update(patch, function(err) {
                if (err) throw err;
                console.log('Device reboot twin state reported')
            });  
        }
    });

    // Add your device's reboot API for physical restart.
    console.log('Rebooting!');
};

Aprire la connessione all'hub IoT e avviare il listener del metodo diretto:

client.open(function(err) {
    if (err) {
        console.error('Could not open IotHub client');
    }  else {
        console.log('Client opened.  Waiting for reboot method.');
        client.onDeviceMethod('reboot', onReboot);
    }
});

Salvare e chiudere il file dmpatterns_getstarted_device.js.

Nota

Per semplificare le operazioni, questo articolo non implementa criteri 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 Node.js 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.

Creare una cartella vuota denominata trigger-reboot-on-device. Nella cartella trigger-reboot-on-device creare un file package.json usando il comando seguente al prompt dei comandi. Accettare tutte le impostazioni predefinite:
```
npm init
```
Al prompt dei comandi nella cartella trigger-reboot-on-device eseguire il comando seguente per installare il pacchetto azure-iothub Device SDK e il pacchetto azure-iot-device-mqtt :
```
npm install azure-iothub --save
```
Usando un editor di testo, creare un file dmpatterns_getstarted_service.js nella cartella trigger-reboot-on-device .

Aggiungere le istruzioni "require" seguenti all'inizio del file dmpatterns_getstarted_service.js:

'use strict';

var Registry = require('azure-iothub').Registry;
var Client = require('azure-iothub').Client;

Aggiungere le dichiarazioni di variabile seguenti e 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:
```
var connectionString = '{iothubconnectionstring}';
var registry = Registry.fromConnectionString(connectionString);
var client = Client.fromConnectionString(connectionString);
var deviceToReboot = 'myDeviceId';
```

Aggiungere la funzione seguente per richiamare il metodo per riavviare il dispositivo di destinazione:

var startRebootDevice = function(twin) {

    var methodName = "reboot";

    var methodParams = {
        methodName: methodName,
        payload: null,
        timeoutInSeconds: 30
    };

    client.invokeDeviceMethod(deviceToReboot, methodParams, function(err, result) {
        if (err) {
            console.error("Direct method error: "+err.message);
        } else {
            console.log("Successfully invoked the device to reboot.");  
        }
    });
};

Aggiungere la funzione seguente per eseguire una query per il dispositivo e ottenere l'ora dell'ultimo riavvio:

var queryTwinLastReboot = function() {

    registry.getTwin(deviceToReboot, function(err, twin){

        if (twin.properties.reported.iothubDM != null)
        {
            if (err) {
                console.error('Could not query twins: ' + err.constructor.name + ': ' + err.message);
            } else {
                var lastRebootTime = twin.properties.reported.iothubDM.reboot.lastReboot;
                console.log('Last reboot time: ' + JSON.stringify(lastRebootTime, null, 2));
            }
        } else 
            console.log('Waiting for device to report last reboot time.');
    });
};

Aggiungere il codice seguente per chiamare le funzioni che attivano il metodo diretto per il riavvio ed eseguire una query per ottenere l'ora dell'ultimo riavvio:
```
startRebootDevice();
setInterval(queryTwinLastReboot, 2000);
```
Salvare e chiudere il file dmpatterns_getstarted_service.js.

Eseguire le app

A questo punto è possibile eseguire le app.

Al prompt dei comandi nella cartella managed-device eseguire il comando seguente per iniziare ad ascoltare il metodo diretto di riavvio.
```
node dmpatterns_getstarted_device.js
```
Al prompt dei comandi nella cartella trigger-reboot-on-device eseguire il comando seguente per attivare il riavvio remoto ed eseguire una query per il dispositivo gemello per trovare l'ora dell'ultimo riavvio.
```
node dmpatterns_getstarted_service.js
```
Viene visualizzata la risposta del dispositivo al metodo diretto di riavvio e lo stato di riavvio nella console.

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

Di seguito viene illustrato il servizio che attiva il riavvio e il polling del dispositivo gemello per lo stato di ultimo riavvio:

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

ToTo continua a iniziare a usare i modelli di gestione di hub IoT e dispositivi, ad esempio l'aggiornamento basato su immagini end-to-end in Aggiornamento dispositivi per hub IoT di Azure articolo usando 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.