Planowanie i emisja zadań (Node.js)

Artykuł
06/24/2023

Użyj Azure IoT Hub, aby zaplanować i śledzić zadania aktualizujące miliony urządzeń. Użyj zadań, aby:

Aktualizowanie żądanych właściwości
Aktualizowanie tagów
Wywoływanie metod bezpośrednich

Koncepcyjnie zadanie opakowuje jedną z tych akcji i śledzi postęp wykonywania względem zestawu urządzeń, który jest definiowany przez zapytanie bliźniaczej reprezentacji urządzenia. Na przykład aplikacja zaplecza może użyć zadania w celu wywołania metody ponownego rozruchu na 10 000 urządzeniach określonych przez zapytanie bliźniaczej reprezentacji urządzenia i zaplanowanych w przyszłości. Ta aplikacja może następnie śledzić postęp, gdy każde z tych urządzeń odbiera i wykonuje metodę ponownego rozruchu.

Dowiedz się więcej o każdej z tych funkcji w następujących artykułach:

Bliźniacze reprezentacje urządzenia i właściwości: Wprowadzenie do bliźniaczych reprezentacji urządzeń oraz Opis bliźniaczych reprezentacji urządzeń i korzystanie z nich w IoT Hub
Metody bezpośrednie: przewodnik dla deweloperów IoT Hub — metody bezpośrednie

Uwaga

Funkcje opisane w tym artykule są dostępne tylko w warstwie Standardowa IoT Hub. Aby uzyskać więcej informacji o warstwach podstawowa i Standardowa/Bezpłatna IoT Hub, zobacz Wybieranie odpowiedniej warstwy IoT Hub dla rozwiązania.

W tym artykule pokazano, jak utworzyć dwie aplikacje Node.js:

Aplikacja urządzenia symulowanego Node.js,simDevice.js, implementuje metodę bezpośrednią o nazwie lockDoor, którą można wywołać przez aplikację zaplecza.
Aplikacja konsolowa Node.js scheduleJobService.js, która tworzy dwa zadania. Jedno zadanie wywołuje metodę bezpośrednią lockDoor , a drugie wysyła żądane aktualizacje właściwości do wielu urządzeń.

Uwaga

Zobacz Zestawy SDK usługi Azure IoT , aby uzyskać więcej informacji na temat narzędzi zestawu SDK dostępnych do tworzenia aplikacji zarówno urządzeń, jak i zaplecza.

Wymagania wstępne

Centrum IoT. Utwórz go przy użyciu interfejsu wiersza polecenia lub Azure Portal.
Zarejestrowane urządzenie. Zarejestruj go w Azure Portal.
Node.js w wersji 10.0.x lub nowszej. W artykule Prepare your development environment (Przygotowanie środowiska deweloperskiego ) opisano sposób instalowania Node.js w systemie Windows lub Linux.
Upewnij się, że port 8883 jest otwarty w zaporze. Przykład urządzenia w tym artykule używa protokołu MQTT, który komunikuje się za pośrednictwem portu 8883. Ten port może być zablokowany w niektórych środowiskach sieci firmowych i edukacyjnych. Aby uzyskać więcej informacji i sposobów obejścia tego problemu, zobacz Connecting to IoT Hub (MQTT) (Nawiązywanie połączenia z IoT Hub (MQTT).

Tworzenie aplikacji symulowanego urządzenia

W tej sekcji utworzysz aplikację konsolową Node.js, która reaguje na metodę bezpośrednią wywoływaną przez chmurę, która wyzwala symulowaną metodę lockDoor .

Utwórz nowy pusty folder o nazwie simDevice. W folderze simDevice utwórz plik package.json przy użyciu następującego polecenia w wierszu polecenia. Zaakceptuj wszystkie ustawienia domyślne:
```
npm init
```
W wierszu polecenia w folderze simDevice uruchom następujące polecenie, aby zainstalować pakiet zestawu SDK urządzenia azure-iot-device i pakiet azure-iot-device-mqtt :
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Za pomocą edytora tekstów utwórz nowy plik simDevice.js w folderze simDevice .

Dodaj następujące instrukcje "require" na początku pliku simDevice.js :

'use strict';

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

Dodaj zmienną connectionString i użyj jej do utworzenia wystąpienia Client. Zastąp wartość symbolu {yourDeviceConnectionString} zastępczego skopiowanymi wcześniej parametrami połączenia urządzenia.
```
var connectionString = '{yourDeviceConnectionString}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Dodaj następującą funkcję, aby obsłużyć metodę 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!');
};

Dodaj następujący kod, aby zarejestrować procedurę obsługi metody 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);
     }
});

Zapisz i zamknij plik simDevice.js .

Uwaga

Aby zachować prostotę, ten artykuł nie implementuje zasad ponawiania. W kodzie produkcyjnym należy zaimplementować zasady ponawiania (takie jak wycofywanie wykładnicze), zgodnie z sugestią w artykule Obsługa błędów przejściowych.

Pobieranie parametrów połączenia IoT Hub

W tym artykule tworzysz usługę zaplecza, która planuje wywołanie metody bezpośredniej na urządzeniu, planuje zadanie aktualizacji bliźniaczej reprezentacji urządzenia i monitoruje postęp każdego zadania. Aby wykonać te operacje, usługa wymaga uprawnień do odczytu rejestru i zapisu rejestru . Domyślnie każde centrum IoT jest tworzone przy użyciu zasad dostępu współdzielonego o nazwie registryReadWrite , które przyznaje te uprawnienia.

Aby uzyskać parametry połączenia IoT Hub dla zasad registryReadWrite, wykonaj następujące kroki:

W Azure Portal wybierz pozycję Grupy zasobów. Wybierz grupę zasobów, w której znajduje się centrum, a następnie wybierz centrum z listy zasobów.
W okienku po lewej stronie centrum wybierz pozycję Zasady dostępu współdzielonego.
Z listy zasad wybierz zasady registryReadWrite .
Skopiuj podstawowe parametry połączenia i zapisz wartość.

Aby uzyskać więcej informacji na temat IoT Hub zasad dostępu współdzielonego i uprawnień, zobacz Kontrola dostępu i uprawnienia.

Planowanie zadań na potrzeby wywoływania metody bezpośredniej i aktualizowania właściwości bliźniaczej reprezentacji urządzenia

W tej sekcji utworzysz aplikację konsolową Node.js, która inicjuje zdalne blokowanieDoor na urządzeniu przy użyciu metody bezpośredniej i aktualizuje właściwości bliźniaczej reprezentacji urządzenia.

Utwórz nowy pusty folder o nazwie scheduleJobService. W folderze scheduleJobService utwórz plik package.json przy użyciu następującego polecenia w wierszu polecenia. Zaakceptuj wszystkie ustawienia domyślne:
```
npm init
```
W wierszu polecenia w folderze scheduleJobService uruchom następujące polecenie, aby zainstalować pakiet zestawu SDK urządzenia azure-iothub i pakiet azure-iot-device-mqtt :
```
npm install azure-iothub uuid --save
```
Za pomocą edytora tekstów utwórz nowy plik scheduleJobService.js w folderze scheduleJobService .

Dodaj następujące instrukcje "require" na początku pliku scheduleJobService.js :

'use strict';

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

Dodaj następujące deklaracje zmiennych. Zastąp wartość symbolu {iothubconnectionstring} zastępczego wartością skopiowaną w obszarze Pobieranie parametrów połączenia centrum IoT. Jeśli zarejestrowano urządzenie inne niż myDeviceId, pamiętaj, aby zmienić je w warunku zapytania.
```
var connectionString = '{iothubconnectionstring}';
var queryCondition = "deviceId IN ['myDeviceId']";
var startTime = new Date();
var maxExecutionTimeInSeconds =  300;
var jobClient = JobClient.fromConnectionString(connectionString);
```

Dodaj następującą funkcję, która jest używana do monitorowania wykonywania zadania:

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

Dodaj następujący kod, aby zaplanować zadanie, które wywołuje metodę urządzenia:

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

Dodaj następujący kod, aby zaplanować zadanie aktualizacji bliźniaczej reprezentacji urządzenia:

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

Zapisz i zamknij plik scheduleJobService.js .

Uruchamianie aplikacji

Teraz można uruchomić aplikacje.

W wierszu polecenia w folderze simDevice uruchom następujące polecenie, aby rozpocząć nasłuchiwanie metody bezpośredniej ponownego rozruchu.
```
node simDevice.js
```
W wierszu polecenia w folderze scheduleJobService uruchom następujące polecenie, aby wyzwolić zadania w celu zablokowania drzwi i zaktualizowania bliźniaczej reprezentacji bliźniaczej
```
node scheduleJobService.js
```
Zostanie wyświetlona odpowiedź urządzenia na metodę bezpośrednią i stan zadania w konsoli programu .

Poniżej przedstawiono odpowiedź urządzenia na metodę bezpośrednią:

Poniżej przedstawiono zadania planowania usług dla metody bezpośredniej i aktualizacji bliźniaczej reprezentacji urządzenia oraz zadania uruchomione do ukończenia:

Następne kroki

W tym artykule zaplanowano uruchamianie metody bezpośredniej i aktualizowanie właściwości bliźniaczej reprezentacji urządzenia.

Aby kontynuować eksplorowanie wzorców IoT Hub i zarządzania urządzeniami, zaktualizuj obraz w usłudze Device Update na potrzeby Azure IoT Hub samouczka przy użyciu obrazu referencyjnego urządzenia Raspberry Pi 3 B+.

Planowanie i emisja zadań (Node.js)

Wymagania wstępne

Tworzenie aplikacji symulowanego urządzenia

Pobieranie parametrów połączenia IoT Hub

Planowanie zadań na potrzeby wywoływania metody bezpośredniej i aktualizowania właściwości bliźniaczej reprezentacji urządzenia

Uruchamianie aplikacji

Następne kroki

Dodatkowe zasoby