Schemalägga och sända jobb (Node.js)

Artikel
03/17/2023

Använd Azure IoT Hub för att schemalägga och spåra jobb som uppdaterar miljontals enheter. Använd jobb för att:

Uppdatera önskade egenskaper
Uppdatera taggar
Anropa direktmetoder

Konceptuellt omsluter ett jobb en av dessa åtgärder och spårar körningens förlopp mot en uppsättning enheter, som definieras av en enhetstvillingfråga. En serverdelsapp kan till exempel använda ett jobb för att anropa en omstartsmetod på 10 000 enheter, som anges av en enhetstvillingfråga och schemaläggs vid en framtida tidpunkt. Programmet kan sedan spåra förloppet när var och en av dessa enheter tar emot och kör omstartsmetoden.

Läs mer om var och en av dessa funktioner i de här artiklarna:

Enhetstvilling och egenskaper: Kom igång med enhetstvillingar och Förstå och använda enhetstvillingar i IoT Hub
Direktmetoder: IoT Hub utvecklarguide – direktmetoder

Anteckning

Funktionerna som beskrivs i den här artikeln är endast tillgängliga på standardnivån för IoT Hub. Mer information om nivåerna grundläggande och standard/kostnadsfri IoT Hub finns i Välj rätt IoT Hub nivå för din lösning.

Den här artikeln visar hur du skapar två Node.js appar:

En Node.js simulerad enhetsapp ,simDevice.js, som implementerar en direktmetod som kallas lockDoor, som kan anropas av serverdelsappen.
En Node.js konsolapp ,scheduleJobService.js, som skapar två jobb. Ett jobb anropar direct-metoden lockDoor och ett annat jobb skickar önskade egenskapsuppdateringar till flera enheter.

Anteckning

Mer information om de SDK-verktyg som är tillgängliga för att skapa både enhets- och serverdelsappar finns i Azure IoT SDK:er .

Förutsättningar

En IoT-hubb. Skapa en med CLI eller Azure Portal.
En registrerad enhet. Registrera en i Azure Portal.
Node.js version 10.0.x eller senare. Förbered utvecklingsmiljön beskriver hur du installerar Node.js för den här artikeln i Antingen Windows eller Linux.
Kontrollera att port 8883 är öppen i brandväggen. Enhetsexemplet i den här artikeln använder MQTT-protokollet, som kommunicerar över port 8883. Den här porten kan blockeras i vissa företags- och utbildningsnätverksmiljöer. Mer information och sätt att kringgå det här problemet finns i Ansluta till IoT Hub (MQTT).

Skapa en simulerad enhetsapp

I det här avsnittet skapar du en Node.js-konsolapp som svarar på en direktmetod som anropas av molnet, vilket utlöser en simulerad lockDoor-metod .

Skapa en ny tom mapp med namnet simDevice. I mappen simDevice skapar du en package.json-fil med följande kommando i kommandotolken. Acceptera alla standardvärden:
```
npm init
```
I kommandotolken i mappen simDevice kör du följande kommando för att installera SDK-paketet azure-iot-device och paketet azure-iot-device-mqtt :
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Skapa en ny simDevice.js-fil i mappen simDevice med hjälp av en textredigerare.

Lägg till följande "kräv"-instruktioner i början av simDevice.js-filen :

'use strict';

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

Lägg till en connectionString-variabel och använd den för att skapa en klientinstans. {yourDeviceConnectionString} Ersätt platshållarvärdet med enhetsanslutningssträngen som du kopierade tidigare.
```
var connectionString = '{yourDeviceConnectionString}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Lägg till följande funktion för att hantera metoden 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!');
};

Lägg till följande kod för att registrera hanteraren för metoden 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);
     }
});

Spara och stäng filensimDevice.js .

Anteckning

För att hålla det enkelt implementerar den här artikeln inte en återförsöksprincip. I produktionskoden bör du implementera återförsöksprinciper (till exempel en exponentiell backoff), som föreslås i artikeln Hantering av tillfälliga fel.

Hämta IoT Hub anslutningssträng

I den här artikeln skapar du en serverdelstjänst som schemalägger ett jobb för att anropa en direktmetod på en enhet, schemalägger ett jobb för att uppdatera enhetstvillingen och övervakar förloppet för varje jobb. För att utföra dessa åtgärder behöver din tjänst behörighet att läsa ochskriva register . Som standard skapas varje IoT-hubb med en princip för delad åtkomst med namnet registryReadWrite som ger dessa behörigheter.

Följ dessa steg för att hämta IoT Hub anslutningssträng för registryReadWrite-principen:

I Azure Portal väljer du Resursgrupper. Välj den resursgrupp där hubben finns och välj sedan din hubb i listan över resurser.
I fönstret till vänster i hubben väljer du Principer för delad åtkomst.
I listan över principer väljer du registryReadWrite-principen .
Kopiera den primära anslutningssträngen och spara värdet.

Mer information om IoT Hub principer och behörigheter för delad åtkomst finns i Åtkomstkontroll och behörigheter.

Schemalägga jobb för att anropa en direktmetod och uppdatera en enhetstvillings egenskaper

I det här avsnittet skapar du en Node.js-konsolapp som initierar ett fjärrlåsDoor på en enhet med hjälp av en direktmetod och uppdaterar enhetstvillingens egenskaper.

Skapa en ny tom mapp med namnet scheduleJobService. I mappen scheduleJobService skapar du en package.json-fil med följande kommando i kommandotolken. Acceptera alla standardvärden:
```
npm init
```
Kör följande kommando i kommandotolken i mappen scheduleJobService för att installera SDK-paketet azure-iothub Device och paketet azure-iot-device-mqtt :
```
npm install azure-iothub uuid --save
```
Skapa en ny scheduleJobService.js fil i mappen scheduleJobService med hjälp av en textredigerare.

Lägg till följande "kräv"-instruktioner i början av scheduleJobService.js-filen :

'use strict';

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

Lägg till följande variabeldeklarationer. {iothubconnectionstring} Ersätt platshållarvärdet med det värde som du kopierade i Hämta IoT Hub-anslutningssträngen. Om du har registrerat en annan enhet än myDeviceId måste du ändra den i frågevillkoret.
```
var connectionString = '{iothubconnectionstring}';
var queryCondition = "deviceId IN ['myDeviceId']";
var startTime = new Date();
var maxExecutionTimeInSeconds =  300;
var jobClient = JobClient.fromConnectionString(connectionString);
```

Lägg till följande funktion som används för att övervaka körningen av jobbet:

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

Lägg till följande kod för att schemalägga jobbet som anropar enhetsmetoden:

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

Lägg till följande kod för att schemalägga jobbet för att uppdatera enhetstvillingen:

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

Spara och stäng filenscheduleJobService.js .

Köra programmen

Nu är det dags att köra programmen.

I kommandotolken i mappen simDevice kör du följande kommando för att börja lyssna efter direktmetoden för omstart.
```
node simDevice.js
```
I kommandotolken i mappen scheduleJobService kör du följande kommando för att utlösa jobben för att låsa dörren och uppdatera tvillingen
```
node scheduleJobService.js
```
Du ser enhetssvaret på direktmetoden och jobbstatusen i konsolen.

Följande visar enhetens svar på direktmetoden:

Följande visar tjänstschemaläggningsjobben för direktmetoden och enhetstvillinguppdateringen och jobben som körs till slutförande:

Nästa steg

I den här artikeln har du schemalagt jobb för att köra en direktmetod och uppdatera enhetstvillingens egenskaper.

Om du vill fortsätta utforska IoT Hub och enhetshanteringsmönster uppdaterar du en avbildning i Enhetsuppdatering för Azure IoT Hub självstudiekurs med hjälp av Raspberry Pi 3 B+-referensbilden.

Schemalägga och sända jobb (Node.js)

Förutsättningar

Skapa en simulerad enhetsapp

Hämta IoT Hub anslutningssträng

Schemalägga jobb för att anropa en direktmetod och uppdatera en enhetstvillings egenskaper

Köra programmen

Nästa steg

Ytterligare resurser