Introduzione alla gestione dei dispositivi (Node.js)

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.js: 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.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 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.
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 dispositivi 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 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.

Creare una cartella vuota denominata managed-device. Nella cartella managed-device creare un file package.json eseguendo questo comando al prompt dei comandi. Accettare tutte le impostazioni predefinite:
```
npm init
```
Eseguire questo comando al prompt dei comandi nella cartella managed-device per installare il pacchetto SDK per dispositivi azure-iot-device e il pacchetto azure-iot-device-mqtt:
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Con 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 valore segnaposto {yourdeviceconnectionstring} con la stringa di connessione del dispositivo visualizzata quando è stato registrato un dispositivo nell'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 semplicità, in questo articolo 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 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.

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.

Creare una cartella vuota denominata trigger-reboot-on-device. Nella cartella trigger-reboot-on-device creare un file package.json eseguendo questo comando al prompt dei comandi. Accettare tutte le impostazioni predefinite:
```
npm init
```
Eseguire questo comando al prompt dei comandi nella cartella trigger-reboot-on-device per installare il pacchetto SDK per dispositivi azure-iothub e il pacchetto azure-iot-device-mqtt:
```
npm install azure-iothub --save
```
Con 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 questo comando per iniziare l'ascolto del metodo diretto di riavvio.
```
node dmpatterns_getstarted_device.js
```
Al prompt dei comandi nella cartella trigger-reboot-on-device eseguire questo comando per attivare il riavvio remoto e cercare 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 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