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

Artikel
06/20/2024

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:

Enhetstvillingar och egenskaper: Kom igång med enhetstvillingar och Förstå och använda enhetstvillingar i IoT Hub
Direktmetoder: Utvecklarguide för IoT Hub – direktmetoder

Kommentar

De funktioner som beskrivs i den här artikeln är endast tillgängliga på standardnivån för IoT Hub. Mer information om de grundläggande och standard-/kostnadsfria IoT Hub-nivåerna 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 lockDoor-direktmetoden och ett annat jobb skickar önskade egenskapsuppdateringar till flera enheter.

Kommentar

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 i din Azure-prenumeration. Om du inte har någon hubb ännu kan du följa stegen i Skapa en IoT-hubb.
En enhet som är registrerad i din IoT-hubb. Om du inte har en enhet i din IoT-hubb följer du stegen i Registrera en enhet.
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 via 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 hjälp av följande kommando i kommandotolken. Acceptera alla standardvärden:
```
npm init
```
Kör följande kommando i kommandotolken i mappen simDevice för att installera SDK-paketet azure-iot-device och azure-iot-device-mqtt-paketet :
```
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 enheten niska veze 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 filen simDevice.js .

Kommentar

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), enligt vad som föreslås i artikeln Tillfälliga felhantering.

Hämta IoT Hub-niska veze

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 tjänsten behörigheterna för registerläsning och registerskrivning . 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-niska veze för registryReadWrite-principen:

I Azure-portalen väljer du Resursgrupper. Välj den resursgrupp där hubben finns och välj sedan din hubb i listan över resurser.
I den vänstra rutan i hubben väljer du Principer för delad åtkomst.
I listan över principer väljer du registerReadWrite-principen .
Kopiera den primära niska veze och spara värdet.

Mer information om principer och behörigheter för delad åtkomst i IoT Hub 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 en fjärrlåsningDoor 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 hjälp av 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 azure-iot-device-mqtt-paketet :
```
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 filen scheduleJobService.js :

'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-niska veze. 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 filen scheduleJobService.js .

Kör 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 enhetens svar 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 självstudiekursen Enhetsuppdatering för Azure IoT Hub med hjälp av Raspberry Pi 3 B+-referensbilden.

Dela via

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

Förutsättningar

Skapa en simulerad enhetsapp

Hämta IoT Hub-niska veze

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

Kör programmen

Nästa steg

Feedback

Ytterligare resurser