Wprowadzenie do zarządzania urządzeniami (Node.js)

Artykuł
06/24/2023

Aplikacje zaplecza mogą używać Azure IoT Hub pierwotnych, takich jak bliźniacze reprezentacje urządzeń i metody bezpośrednie, do zdalnego uruchamiania i monitorowania akcji zarządzania urządzeniami na urządzeniach. W tym artykule pokazano, jak aplikacja zaplecza i aplikacja urządzenia mogą współpracować w celu zainicjowania i monitorowania ponownego uruchomienia urządzenia zdalnego przy użyciu IoT Hub.

Uwaga

Funkcje opisane w tym artykule są dostępne tylko w warstwie Standardowa IoT Hub. Aby uzyskać więcej informacji na temat warstw podstawowych i standardowych/bezpłatnych IoT Hub, zobacz Wybieranie odpowiedniej warstwy IoT Hub dla rozwiązania.

Użyj metody bezpośredniej, aby zainicjować akcje zarządzania urządzeniami (takie jak ponowne uruchomienie, resetowanie do ustawień fabrycznych i aktualizacja oprogramowania układowego) z aplikacji zaplecza w chmurze. Urządzenie jest odpowiedzialne za:

Obsługa żądania metody wysyłanego z IoT Hub.
Inicjowanie odpowiedniej akcji specyficznej dla urządzenia.
Dostarczanie aktualizacji stanu za pośrednictwem zgłoszonych właściwości do IoT Hub.

Możesz użyć aplikacji zaplecza w chmurze do uruchamiania zapytań bliźniaczych reprezentacji urządzenia w celu raportowania postępu akcji zarządzania urządzeniami.

W tym artykule pokazano, jak utworzyć:

dmpatterns_getstarted_device.js: symulowana aplikacja urządzenia z metodą bezpośrednią, która ponownie uruchamia urządzenie i zgłasza czas ostatniego ponownego rozruchu. Metody bezpośrednie są wywoływane z chmury.
dmpatterns_getstarted_service.js: aplikacja konsolowa platformy .NET, która wywołuje metodę bezpośrednią w aplikacji urządzenia symulowanego za pośrednictwem centrum IoT. Wyświetla odpowiedź i zaktualizowane zgłoszone właściwości.

Wymagania wstępne

Centrum IoT. Utwórz go za pomocą interfejsu wiersza polecenia lub Azure Portal.
Zarejestrowane urządzenie. Zarejestruj jeden w Azure Portal.
Node.js w wersji 10.0.x lub nowszej. W artykule Przygotowanie środowiska deweloperskiego opisano sposób instalowania Node.js dla tego artykułu 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 zostać zablokowany w niektórych środowiskach sieci firmowych i edukacyjnych. Aby uzyskać więcej informacji i sposobów obejścia tego problemu, zobacz Łączenie się z IoT Hub (MQTT).

Tworzenie aplikacji urządzenia przy użyciu metody bezpośredniej

W tej sekcji omówiono następujące zagadnienia:

Utwórz aplikację konsolową Node.js, która odpowiada na metodę bezpośrednią wywoływaną przez chmurę.
Wyzwalanie symulowanego ponownego uruchomienia urządzenia.
Użyj zgłoszonych właściwości, aby włączyć zapytania bliźniaczej reprezentacji urządzenia w celu zidentyfikowania urządzeń i ich ostatniego ponownego uruchomienia.

Utwórz pusty folder o nazwie managed-device. W folderze managed-device 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 managed-device uruchom następujące polecenie, aby zainstalować pakiet azure-iot-device Device SDK i pakiet azure-iot-device-mqtt :
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Za pomocą edytora tekstów utwórz plik dmpatterns_getstarted_device.js w folderze managed-device .

Dodaj następujące instrukcje "require" na początku pliku dmpatterns_getstarted_device.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. {yourdeviceconnectionstring} Zastąp wartość symbolu zastępczego parametrami połączenia urządzenia, które zostały wyświetlone podczas rejestrowania urządzenia w IoT Hub:
```
var connectionString = '{yourdeviceconnectionstring}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Dodaj następującą funkcję, aby zaimplementować metodę bezpośrednią na urządzeniu

var onReboot = function(request, response) {

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

    // Report the reboot before the physical restart
    var date = new Date();
    var patch = {
        iothubDM : {
            reboot : {
                lastReboot : date.toISOString(),
            }
        }
    };

    // Get device Twin
    client.getTwin(function(err, twin) {
        if (err) {
            console.error('could not get twin');
        } else {
            console.log('twin acquired');
            twin.properties.reported.update(patch, function(err) {
                if (err) throw err;
                console.log('Device reboot twin state reported')
            });  
        }
    });

    // Add your device's reboot API for physical restart.
    console.log('Rebooting!');
};

Otwórz połączenie z centrum IoT Hub i uruchom odbiornik metody bezpośredniej:

client.open(function(err) {
    if (err) {
        console.error('Could not open IotHub client');
    }  else {
        console.log('Client opened.  Waiting for reboot method.');
        client.onDeviceMethod('reboot', onReboot);
    }
});

Zapisz i zamknij plik dmpatterns_getstarted_device.js .

Uwaga

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

Pobieranie parametrów połączenia centrum IoT Hub

W tym artykule utworzysz usługę zaplecza, która wywołuje metodę bezpośrednią na urządzeniu. Aby wywołać metodę bezpośrednią na urządzeniu za pośrednictwem IoT Hub, usługa wymaga uprawnienia połączenia z usługą. Domyślnie każda IoT Hub jest tworzona z zasadami dostępu współdzielonego o nazwie usługa, która przyznaje to uprawnienie.

Aby uzyskać IoT Hub parametry połączenia dla zasad usługi, 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 IoT wybierz pozycję Zasady dostępu współdzielonego.
Z listy zasad wybierz zasady usługi .
Skopiuj podstawowe parametry połączenia i zapisz wartość.

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

Tworzenie aplikacji usługi w celu wyzwolenia ponownego rozruchu

W tej sekcji utworzysz aplikację konsolową Node.js, która inicjuje zdalne ponowne uruchomienie na urządzeniu przy użyciu metody bezpośredniej. Aplikacja używa zapytań bliźniaczych reprezentacji urządzeń do odnajdywania czasu ostatniego ponownego rozruchu dla tego urządzenia.

Utwórz pusty folder o nazwie trigger-reboot-on-device. W folderze trigger-reboot-on-device 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 trigger-reboot-on-device uruchom następujące polecenie, aby zainstalować pakiet azure-iothub Device SDK i pakiet azure-iot-device-mqtt :
```
npm install azure-iothub --save
```
Za pomocą edytora tekstów utwórz plik dmpatterns_getstarted_service.js w folderze trigger-reboot-on-device .

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

'use strict';

var Registry = require('azure-iothub').Registry;
var Client = require('azure-iothub').Client;

Dodaj następujące deklaracje zmiennych i zastąp wartość symbolu zastępczego {iothubconnectionstring} parametrami połączenia centrum IoT skopiowanymi wcześniej w sekcji Pobierz parametry połączenia centrum IoT:
```
var connectionString = '{iothubconnectionstring}';
var registry = Registry.fromConnectionString(connectionString);
var client = Client.fromConnectionString(connectionString);
var deviceToReboot = 'myDeviceId';
```

Dodaj następującą funkcję, aby wywołać metodę urządzenia w celu ponownego uruchomienia urządzenia docelowego:

var startRebootDevice = function(twin) {

    var methodName = "reboot";

    var methodParams = {
        methodName: methodName,
        payload: null,
        timeoutInSeconds: 30
    };

    client.invokeDeviceMethod(deviceToReboot, methodParams, function(err, result) {
        if (err) {
            console.error("Direct method error: "+err.message);
        } else {
            console.log("Successfully invoked the device to reboot.");  
        }
    });
};

Dodaj następującą funkcję, aby wysłać zapytanie o urządzenie i uzyskać czas ostatniego ponownego rozruchu:

var queryTwinLastReboot = function() {

    registry.getTwin(deviceToReboot, function(err, twin){

        if (twin.properties.reported.iothubDM != null)
        {
            if (err) {
                console.error('Could not query twins: ' + err.constructor.name + ': ' + err.message);
            } else {
                var lastRebootTime = twin.properties.reported.iothubDM.reboot.lastReboot;
                console.log('Last reboot time: ' + JSON.stringify(lastRebootTime, null, 2));
            }
        } else 
            console.log('Waiting for device to report last reboot time.');
    });
};

Dodaj następujący kod, aby wywołać funkcje, które wyzwalają metodę bezpośrednią ponownego rozruchu i wysyłają zapytanie o czas ostatniego ponownego rozruchu:
```
startRebootDevice();
setInterval(queryTwinLastReboot, 2000);
```
Zapisz i zamknij plik dmpatterns_getstarted_service.js .

Uruchamianie aplikacji

Teraz możesz przystąpić do uruchamiania aplikacji.

W wierszu polecenia w folderze managed-device uruchom następujące polecenie, aby rozpocząć nasłuchiwanie metody bezpośredniej ponownego uruchamiania.
```
node dmpatterns_getstarted_device.js
```
W wierszu polecenia w folderze trigger-reboot-on-device uruchom następujące polecenie, aby wyzwolić zdalny ponowny rozruch i wykonać zapytanie dotyczące bliźniaczej reprezentacji urządzenia, aby znaleźć czas ostatniego ponownego rozruchu.
```
node dmpatterns_getstarted_service.js
```
Zostanie wyświetlona odpowiedź urządzenia na metodę bezpośrednią ponownego rozruchu i stan ponownego uruchomienia w konsoli programu .

Poniżej przedstawiono odpowiedź urządzenia na metodę bezpośrednią ponownego rozruchu wysłaną przez usługę:

Poniżej przedstawiono usługę wyzwalającą ponowny rozruch i sondując bliźniaczą reprezentację urządzenia po ostatnim ponownym uruchomieniu:

Dostosowywanie i rozszerzanie akcji zarządzania urządzeniami

Rozwiązania IoT mogą rozszerzać zdefiniowany zestaw wzorców zarządzania urządzeniami lub włączać wzorce niestandardowe przy użyciu elementów pierwotnych metody bliźniaczej reprezentacji urządzenia i metody chmury do urządzenia. Inne przykłady akcji zarządzania urządzeniami obejmują resetowanie do ustawień fabrycznych, aktualizację oprogramowania, aktualizację oprogramowania, zarządzanie energią, zarządzanie siecią i łącznością oraz szyfrowanie danych.

Okna obsługi urządzeń

Zazwyczaj można skonfigurować urządzenia do wykonywania akcji w czasie, które minimalizują przerwy i przestoje. Okna obsługi urządzeń są często używanym wzorcem do definiowania czasu aktualizacji konfiguracji urządzenia. Rozwiązania zaplecza mogą używać żądanych właściwości bliźniaczej reprezentacji urządzenia do definiowania i aktywowania zasad na urządzeniu, które umożliwia okno obsługi. Gdy urządzenie otrzyma zasady okna obsługi, może użyć zgłaszanej właściwości bliźniaczej reprezentacji urządzenia, aby zgłosić stan zasad. Aplikacja zaplecza może następnie używać zapytań bliźniaczych reprezentacji urządzenia, aby potwierdzić zgodność urządzeń i poszczególnych zasad.

Następne kroki

W tym artykule użyto metody bezpośredniej do wyzwolenia zdalnego ponownego uruchomienia na urządzeniu. Za pomocą zgłoszonych właściwości zgłosiliśmy czas ostatniego ponownego rozruchu z urządzenia i wykonano zapytanie dotyczące bliźniaczej reprezentacji urządzenia w celu odnalezienia czasu ostatniego ponownego rozruchu urządzenia z chmury.

Aby kontynuować rozpoczynanie pracy z wzorcami zarządzania IoT Hub i urządzeniami, takimi jak kompleksowa aktualizacja obrazu w aktualizacji urządzeń dla Azure IoT Hub artykułu przy użyciu obrazu referencyjnego urządzenia Raspberry Pi 3 B+.

Aby dowiedzieć się, jak rozszerzyć rozwiązanie IoT i zaplanować wywołania metody na wielu urządzeniach, zobacz Planowanie i emisja zadań.

Share via