Taken plannen en uitzenden (Node.js)

• CLI
• .NET
• Python
• Node.js
• Java

Gebruik Azure IoT Hub om taken te plannen en bij te houden die miljoenen apparaten bijwerken. Taken gebruiken om:

• Gewenste eigenschappen bijwerken
• Tags bijwerken
• Directe methoden aanroepen

Conceptueel verpakt een taak een van deze acties en houdt de voortgang van de uitvoering bij op een set apparaten, die wordt gedefinieerd door een apparaatdubbelquery. Een back-end-app kan bijvoorbeeld een taak gebruiken om een methode voor opnieuw opstarten aan te roepen op 10.000 apparaten, opgegeven door een apparaatdubbelquery en gepland op een later tijdstip. Deze toepassing kan vervolgens de voortgang bijhouden terwijl elk van deze apparaten de methode voor opnieuw opstarten ontvangt en uitvoert.

Meer informatie over elk van deze mogelijkheden vindt u in deze artikelen:

• Apparaatdubbel en eigenschappen: Aan de slag met apparaatdubbels en Apparaatdubbels begrijpen en gebruiken in IoT Hub

• Directe methoden: Ontwikkelaarshandleiding voor IoT Hub - directe methoden

Notitie

De functies die in dit artikel worden beschreven, zijn alleen beschikbaar in de standaardlaag van de IoT Hub. Zie De juiste IoT Hub-laag voor uw oplossing kiezen voor meer informatie over de Basic- en Standard-/gratis IoT Hub-lagen.

In dit artikel leest u hoe u twee Node.js-apps maakt:

• Een Node.js gesimuleerde apparaat-app, simDevice.js, die een directe methode implementeert met de naam lockDoor, die kan worden aangeroepen door de back-end-app.

• Een Node.js console-app, scheduleJobService.js, waarmee twee taken worden gemaakt. Een taak roept de directe lockDoor-methode aan en een andere taak verzendt gewenste eigenschapsupdates naar meerdere apparaten.

Notitie

Zie Azure IoT SDK's voor meer informatie over de SDK-hulpprogramma's die beschikbaar zijn voor het bouwen van zowel apparaat- als back-end-apps.

Vereisten

• Een IoT-hub. Maak er een met de CLI of Azure Portal.

• Een apparaat dat is geregistreerd in uw IoT-hub. Als u geen apparaat in uw IoT-hub hebt, volgt u de stappen in Een apparaat registreren.

• Node.js versie 10.0.x of hoger. In de ontwikkelomgeving wordt beschreven hoe u Node.js installeert voor dit artikel in Windows of Linux.

• Zorg ervoor dat de poort 8883 is geopend in uw firewall. Het apparaatvoorbeeld in dit artikel maakt gebruik van het MQTT-protocol, dat via poort 8883 communiceert. Deze poort is in sommige netwerkomgevingen van bedrijven en onderwijsinstellingen mogelijk geblokkeerd. Zie Verbinding maken met IoT Hub (MQTT) voor meer informatie en manieren om dit probleem te omzeilen.

Een gesimuleerde apparaattoepassing maken

In deze sectie maakt u een Node.js console-app die reageert op een directe methode die wordt aangeroepen door de cloud, waarmee een gesimuleerde lockDoor-methode wordt geactiveerd.

1. Maak een nieuwe lege map met de naam simDevice. Maak in de map simDevice een package.json-bestand met behulp van de volgende opdracht bij de opdrachtprompt. Accepteer alle standaardwaarden:

   npm init
   

2. Voer bij de opdrachtprompt in de map simDevice de volgende opdracht uit om het azure-iot-device Device SDK-pakket en het azure-iot-device-mqtt-pakket te installeren:

   npm install azure-iot-device azure-iot-device-mqtt --save
   

3. Maak met behulp van een teksteditor een nieuw simDevice.js-bestand in de map simDevice .

4. Voeg de volgende 'require'-instructies toe aan het begin van het simDevice.js-bestand :

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

5. Voeg een connectionString-variabele toe en gebruik deze om een clientexemplaar te maken. Vervang de waarde van de {yourDeviceConnectionString} tijdelijke aanduiding door het apparaat verbindingsreeks u eerder hebt gekopieerd.

   var connectionString = '{yourDeviceConnectionString}';
   var client = Client.fromConnectionString(connectionString, Protocol);
   

6. Voeg de volgende functie toe om de lockDoor-methode te verwerken.

   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!');
   };
   

7. Voeg de volgende code toe om de handler voor de lockDoor-methode te registreren.

   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);
        }
   });
   

8. Sla het simDevice.js bestand op en sluit het.

Notitie

Om het eenvoudig te houden, implementeert dit artikel geen beleid voor opnieuw proberen. In productiecode moet u beleid voor opnieuw proberen implementeren (zoals een exponentiële uitstel), zoals wordt voorgesteld in het artikel Tijdelijke foutafhandeling.

De IoT Hub-verbindingsreeks ophalen

In dit artikel maakt u een back-endservice die een taak plant om een directe methode op een apparaat aan te roepen, een taak plant om de apparaatdubbel bij te werken en de voortgang van elke taak bewaakt. Om deze bewerkingen uit te voeren, heeft uw service de lees- en schrijfmachtigingen voor het register nodig. Standaard wordt elke IoT-hub gemaakt met een gedeeld toegangsbeleid met de naam registryReadWrite dat deze machtigingen verleent.

Voer de volgende stappen uit om de IoT Hub-verbindingsreeks voor het registerReadWrite-beleid op te halen:

1. Selecteer resourcegroepen in de Azure-portal. Selecteer de resourcegroep waar uw hub zich bevindt en selecteer vervolgens uw hub in de lijst met resources.

2. Selecteer in het linkerdeelvenster van uw hub beleid voor gedeelde toegang.

3. Selecteer in de lijst met beleidsregels het registerReadWrite-beleid .

4. Kopieer de primaire verbindingsreeks en sla de waarde op.

   

Zie Toegangsbeheer en machtigingen voor meer informatie over beleid en machtigingen voor gedeelde toegang van IoT Hub.

Taken plannen voor het aanroepen van een directe methode en het bijwerken van de eigenschappen van een apparaatdubbel

In deze sectie maakt u een Node.js console-app die een externe lockDoor op een apparaat initieert met behulp van een directe methode en de eigenschappen van de apparaatdubbel bijwerkt.

1. Maak een nieuwe lege map met de naam scheduleJobService. Maak in de map scheduleJobService een package.json-bestand met behulp van de volgende opdracht bij de opdrachtprompt. Accepteer alle standaardwaarden:

   npm init
   

2. Voer bij de opdrachtprompt in de map scheduleJobService de volgende opdracht uit om het azure-iothub Device SDK-pakket en het azure-iot-device-mqtt-pakket te installeren:

   npm install azure-iothub uuid --save
   

3. Maak met behulp van een teksteditor een nieuw scheduleJobService.js-bestand in de map scheduleJobService .

4. Voeg de volgende 'require'-instructies toe aan het begin van het scheduleJobService.js-bestand :

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

5. Voeg de volgende variabeledeclaraties toe. Vervang de {iothubconnectionstring} tijdelijke aanduidingswaarde door de waarde die u hebt gekopieerd in De IoT-hub ophalen verbindingsreeks. Als u een ander apparaat hebt geregistreerd dan myDeviceId, moet u dit wijzigen in de queryvoorwaarde.

   var connectionString = '{iothubconnectionstring}';
   var queryCondition = "deviceId IN ['myDeviceId']";
   var startTime = new Date();
   var maxExecutionTimeInSeconds =  300;
   var jobClient = JobClient.fromConnectionString(connectionString);
   

6. Voeg de volgende functie toe die wordt gebruikt om de uitvoering van de taak te bewaken:

   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);
   }
   

7. Voeg de volgende code toe om de taak te plannen die de apparaatmethode aanroept:

   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));
               }
           });
       }
   });
   

8. Voeg de volgende code toe om de taak te plannen om de apparaatdubbel bij te werken:

   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));
               }
           });
       }
   });
   

9. Sla het scheduleJobService.js bestand op en sluit het.

De toepassingen uitvoeren

U kunt nu de toepassingen gaan uitvoeren.

1. Voer bij de opdrachtprompt in de map simDevice de volgende opdracht uit om te beginnen met luisteren naar de directe methode voor opnieuw opstarten.

   node simDevice.js
   

2. Voer bij de opdrachtprompt in de map scheduleJobService de volgende opdracht uit om de taken te activeren om de deur te vergrendelen en de dubbel bij te werken

   node scheduleJobService.js
   

3. U ziet het apparaatantwoord op de directe methode en de taakstatus in de console.

   Hieronder ziet u het apparaatantwoord op de directe methode:

   

   Hieronder ziet u de serviceplanningstaken voor de directe methode- en apparaatdubbelupdate en de taken die tot voltooiing worden uitgevoerd:

   

Volgende stappen

In dit artikel hebt u taken gepland om een directe methode uit te voeren en de eigenschappen van de apparaatdubbel bij te werken.

Als u ioT Hub- en apparaatbeheerpatronen wilt blijven verkennen, werkt u een afbeelding bij in de zelfstudie Apparaatupdate voor Azure IoT Hub met behulp van de Raspberry Pi 3 B+ Reference Image.