Pianificare e trasmettere processi (Node.js)

Articolo
10/01/2024

Usare l'hub IoT per pianificare e tenere traccia dei processi che aggiornano milioni di dispositivi. Usare i processi per:

Aggiornare le proprietà desiderate
Aggiornare i tag
Richiamare metodi diretti

Concettualmente, un processo esegue il wrapping di una di queste azioni e tiene traccia dell'avanzamento dell'esecuzione rispetto a un set di dispositivi, definito da una query di dispositivi gemelli. Grazie a un processo, ad esempio, un'app back-end può richiamare un metodo di riavvio in 10.000 dispositivi, specificato da una query di dispositivi gemelli e pianificato in un secondo momento. L'applicazione può quindi tenere traccia dell'avanzamento mentre ognuno dei dispositivi riceve ed esegue il metodo di riavvio.

Altre informazioni su queste funzionalità sono disponibili in questi articoli:

Proprietà e dispositivi gemelli: Introduzione ai dispositivi gemelli e Comprendere e usare dispositivi gemelli nell'hub IoT
Metodi diretti: Guida per sviluppatori dell'hub IoT - Metodi diretti

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.

Questo articolo illustra come creare due app Node.js:

Un'app dispositivo simulato Node.js, simDevice.js, che implementa un metodo diretto denominato lockDoor, che può essere chiamato dall'app back-end.
Un'app console Node.js, scheduleJobService.js, che crea due processi. Un processo chiama il metodo diretto lockDoor e un altro processo invia gli aggiornamenti delle proprietà desiderati a più dispositivi.

Nota

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

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 di dispositivo simulato

In questa sezione viene creata un'applicazione console Node.js che risponde a un metodo chiamato dal cloud, che attiva un metodo lockDoor simulato.

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 nuova cartella vuota chiamata simDevice. Nella cartella simDevice 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 simDevice 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 nuovo file simDevice.js nella cartella simDevice.

Aggiungere le istruzioni "require" seguenti all'inizio del file simDevice.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 del segnaposto {yourDeviceConnectionString} con la stringa di connessione del dispositivo copiata in precedenza.
```
var connectionString = '{yourDeviceConnectionString}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Aggiungere la funzione seguente per gestire il metodo lockDoor.

var onLockDoor = function(request, response) {

    // Respond the cloud app for the direct method
    response.send(200, 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.');
        }
    });

    console.log('Locking Door!');
};

Aggiungere il codice seguente per registrare il gestore per il metodo lockDoor.

client.open(function(err) {
     if (err) {
         console.error('Could not connect to IotHub client.');
     }  else {
         console.log('Client connected to IoT Hub. Register handler for lockDoor direct method.');
         client.onDeviceMethod('lockDoor', onLockDoor);
     }
});

Salvare e chiudere il file simDevice.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 pianifica un processo per richiamare un metodo diretto in un dispositivo, pianifica un processo per l'aggiornamento del dispositivo gemello e monitora lo stato di ogni processo. Per eseguire queste operazioni, è necessario che il servizio disponga delle autorizzazioni di lettura del registro di sistema e scrittura del registro di sistema. Per impostazione predefinita, ogni hub IoT viene creato con un registryReadWrite con nome di criteri di accesso condiviso che concede tale autorizzazione.i.

Per ottenere la stringa di connessione dell'hub IoT per i criteri registryReadWrite, 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 selezionare Criteri di accesso condiviso.
Dall'elenco dei criteri selezionare il criterio registryReadWrite.
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.

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.

Pianificare i processi per chiamare un metodo diretto e aggiornare le proprietà dei dispositivi gemelli

In questa sezione si creerà un'app console Node.js che avvia un lockDoor remoto su un dispositivo usando un metodo diretto e verranno aggiornate le proprietà del dispositivo gemello.

Creare una nuova cartella vuota chiamata scheduleJobService. Nella cartella scheduleJobService 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 scheduleJobService per installare il pacchetto SDK per dispositivi azure-iothub e il pacchetto azure-iot-device-mqtt:
```
npm install azure-iothub uuid --save
```
Usando un editor di testo, creare un nuovo file scheduleJobService.js nella cartella scheduleJobService.

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

'use strict';

var uuid = require('uuid');
var JobClient = require('azure-iothub').JobClient;

Aggiungere le dichiarazioni di variabili seguenti. Sostituire il valore segnaposto {iothubconnectionstring} con quello copiato in Ottenere la stringa di connessione dell'hub IoT. Se è stato registrato un dispositivo diverso da myDeviceId, assicurarsi di modificarlo nella condizione di query.
```
var connectionString = '{iothubconnectionstring}';
var queryCondition = "deviceId IN ['myDeviceId']";
var startTime = new Date();
var maxExecutionTimeInSeconds =  300;
var jobClient = JobClient.fromConnectionString(connectionString);
```

Aggiungere la funzione seguente che verrà usata per monitorare l'esecuzione del processo:

function monitorJob (jobId, callback) {
    var jobMonitorInterval = setInterval(function() {
        jobClient.getJob(jobId, function(err, result) {
        if (err) {
            console.error('Could not get job status: ' + err.message);
        } else {
            console.log('Job: ' + jobId + ' - status: ' + result.status);
            if (result.status === 'completed' || result.status === 'failed' || result.status === 'cancelled') {
            clearInterval(jobMonitorInterval);
            callback(null, result);
            }
        }
        });
    }, 5000);
}

Aggiungere il codice seguente per pianificare il processo che chiama il metodo del dispositivo:

var methodParams = {
    methodName: 'lockDoor',
    payload: null,
    responseTimeoutInSeconds: 15 // Timeout after 15 seconds if device is unable to process method
};

var methodJobId = uuid.v4();
console.log('scheduling Device Method job with id: ' + methodJobId);
jobClient.scheduleDeviceMethod(methodJobId,
                            queryCondition,
                            methodParams,
                            startTime,
                            maxExecutionTimeInSeconds,
                            function(err) {
    if (err) {
        console.error('Could not schedule device method job: ' + err.message);
    } else {
        monitorJob(methodJobId, function(err, result) {
            if (err) {
                console.error('Could not monitor device method job: ' + err.message);
            } else {
                console.log(JSON.stringify(result, null, 2));
            }
        });
    }
});

Aggiungere il codice seguente per pianificare il processo che aggiorna il dispositivo gemello:

var twinPatch = {
   etag: '*',
   properties: {
       desired: {
           building: '43',
           floor: 3
       }
   }
};

var twinJobId = uuid.v4();

console.log('scheduling Twin Update job with id: ' + twinJobId);
jobClient.scheduleTwinUpdate(twinJobId,
                            queryCondition,
                            twinPatch,
                            startTime,
                            maxExecutionTimeInSeconds,
                            function(err) {
    if (err) {
        console.error('Could not schedule twin update job: ' + err.message);
    } else {
        monitorJob(twinJobId, function(err, result) {
            if (err) {
                console.error('Could not monitor twin update job: ' + err.message);
            } else {
                console.log(JSON.stringify(result, null, 2));
            }
        });
    }
});

Salvare e chiudere il file scheduleJobService.js.

Eseguire le applicazioni

A questo punto è possibile eseguire le applicazioni.

Al prompt dei comandi nella cartella simDevice eseguire questo comando per iniziare l'ascolto del metodo diretto di riavvio.
```
node simDevice.js
```
Eseguire il comando riportato di seguito al prompt dei comandi nella cartella scheduleJobService per attivare i processi per bloccare la porta e aggiornare il dispositivo gemello
```
node scheduleJobService.js
```
Viene visualizzata la risposta del dispositivo al metodo diretto e lo stato del processo nella console.

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

Di seguito vengono illustrati i processi di pianificazione dei servizi per il metodo diretto e l'aggiornamento del dispositivo gemello e i processi in esecuzione fino al completamento:

Passaggi successivi

In questo articolo sono stati pianificati processi per eseguire un metodo diretto e aggiornare le proprietà del dispositivo gemello.

Per continuare a esplorare i modelli di gestione dell'hub IoT e dei dispositivi, aggiornare un'immagine nell'esercitazione sull'aggiornamento dei dispositivi per l'hub IoT di Azure usando l'immagine di riferimento Raspberry Pi 3 B+.

Condividi tramite

Pianificare e trasmettere processi (Node.js)

Prerequisiti

Creare un'app di dispositivo simulato

Ottenere la stringa di connessione dell'hub IoT

Pianificare i processi per chiamare un metodo diretto e aggiornare le proprietà dei dispositivi gemelli

Eseguire le applicazioni

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive