Aan de slag met apparaatbeheer (Node.js)

Artikel
04/27/2023

Back-end-apps kunnen gebruikmaken van Azure IoT Hub primitieven, zoals apparaatdubbels en directe methoden, om apparaatbeheeracties op apparaten op afstand te starten en te bewaken. In dit artikel wordt beschreven hoe een back-end-app en een apparaat-app kunnen samenwerken om het opnieuw opstarten van een extern apparaat te starten en te bewaken met behulp van IoT Hub.

Notitie

De functies die in dit artikel worden beschreven, zijn alleen beschikbaar in de standaardlaag van de IoT Hub. Zie Choose the right IoT Hub tier for your solution (De juiste IoT Hub laag voor uw oplossing kiezen) voor meer informatie over de lagen Basic en Standard/free IoT Hub.

Gebruik een directe methode om acties voor apparaatbeheer (zoals opnieuw opstarten, fabrieksinstellingen en firmware-update) te initiëren vanuit een back-end-app in de cloud. Het apparaat is verantwoordelijk voor:

De methodeaanvraag verwerken die is verzonden vanaf IoT Hub.
De bijbehorende apparaatspecifieke actie op het apparaat initiëren.
Het verstrekken van statusupdates via gerapporteerde eigenschappen aan IoT Hub.

U kunt een back-end-app in de cloud gebruiken om query's op apparaatdubbels uit te voeren om de voortgang van uw apparaatbeheeracties te rapporteren.

In dit artikel wordt beschreven hoe u het volgende maakt:

dmpatterns_getstarted_device.js: een gesimuleerde apparaat-app met een directe methode waarmee het apparaat opnieuw wordt opgestart en de laatste keer dat het apparaat opnieuw wordt opgestart. Directe methoden worden aangeroepen vanuit de cloud.
dmpatterns_getstarted_service.js: een .NET-console-app die de directe methode in de gesimuleerde apparaat-app aanroept via uw IoT-hub. Het antwoord en bijgewerkte gerapporteerde eigenschappen worden weergegeven.

Vereisten

Een IoT-hub. Maak er een met de CLI of de Azure Portal.
Een geregistreerd apparaat. Registreer er een in de Azure Portal.
Node.js versie 10.0.x of hoger. In Uw ontwikkelomgeving voorbereiden wordt beschreven hoe u Node.js voor dit artikel installeert in Windows of Linux.
Zorg ervoor dat de poort 8883 is geopend in de firewall. Het apparaatvoorbeeld in dit artikel maakt gebruik van het MQTT-protocol, dat communiceert via poort 8883. 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 apparaat-app maken met een directe methode

In deze sectie doet u het volgende:

Maak een Node.js console-app die reageert op een directe methode die door de cloud wordt aangeroepen.
Een gesimuleerd apparaat opnieuw opstarten activeren.
Gebruik de gerapporteerde eigenschappen om apparaatdubbelquery's in te schakelen om apparaten te identificeren en wanneer ze voor het laatst opnieuw zijn opgestart.

Maak een lege map met de naam managed-device. Maak in de map managed-device een package.json-bestand met behulp van de volgende opdracht bij de opdrachtprompt. Accepteer alle standaardwaarden:
```
npm init
```
Voer bij de opdrachtprompt in de map managed-device de volgende opdracht uit om het device SDK-pakket azure-iot-device en het pakket azure-iot-device-mqtt te installeren:
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Maak met behulp van een teksteditor een dmpatterns_getstarted_device.js-bestand in de map beheerde apparaten .

Voeg de volgende 'vereisen'-instructies toe aan het begin van het dmpatterns_getstarted_device.js-bestand :

'use strict';

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

Voeg een connectionString-variabele toe en gebruik deze om een clientexemplaar te maken. Vervang de waarde van de {yourdeviceconnectionstring} tijdelijke aanduiding door het apparaat connection string u hebt gezien toen u een apparaat in de IoT Hub hebt geregistreerd:
```
var connectionString = '{yourdeviceconnectionstring}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Voeg de volgende functie toe om de directe methode op het apparaat te implementeren

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

Open de verbinding met uw IoT-hub en start de listener voor de directe methode:

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

Sla hetdmpatterns_getstarted_device.jsbestand op en sluit het.

Notitie

Om het eenvoudig te houden, wordt in dit artikel geen beleid voor opnieuw proberen geïmplementeerd. In productiecode moet u beleid voor opnieuw proberen implementeren (zoals exponentieel uitstel), zoals wordt voorgesteld in het artikel Tijdelijke foutafhandeling.

De IoT Hub-connection string ophalen

In dit artikel maakt u een back-endservice die een directe methode op een apparaat aanroept. Als u een directe methode op een apparaat wilt aanroepen via IoT Hub, heeft uw service de machtiging serviceverbinding nodig. Standaard wordt elke IoT Hub gemaakt met een gedeeld toegangsbeleid met de naam service die deze machtiging verleent.

Volg deze stappen om de IoT Hub connection string voor het servicebeleid op te halen:

Selecteer Resourcegroepenin de Azure Portal. Selecteer de resourcegroep waar uw hub zich bevindt en selecteer vervolgens uw hub in de lijst met resources.
Selecteer in het linkerdeelvenster van uw IoT-hub beleid voor gedeelde toegang.
Selecteer het servicebeleid in de lijst met beleidsregels.
Kopieer de Primaire connection string en sla de waarde op.

Zie Toegangsbeheer en machtigingen voor meer informatie over IoT Hub gedeelde toegangsbeleid en -machtigingen.

Een service-app maken om opnieuw opstarten te activeren

In deze sectie maakt u een Node.js-console-app die op afstand opnieuw opstarten op een apparaat start met behulp van een directe methode. De app maakt gebruik van apparaatdubbelquery's om de laatste keer dat het apparaat opnieuw wordt opgestart te detecteren.

Maak een lege map met de naam trigger-reboot-on-device. Maak in de map trigger-reboot-on-device een package.json-bestand met behulp van de volgende opdracht bij de opdrachtprompt. Accepteer alle standaardwaarden:
```
npm init
```
Voer bij de opdrachtprompt in de map trigger-reboot-on-device de volgende opdracht uit om het pakket azure-iothub Device SDK en het pakket azure-iot-device-mqtt te installeren:
```
npm install azure-iothub --save
```
Maak met een teksteditor een dmpatterns_getstarted_service.js-bestand in de map trigger-reboot-on-device .

Voeg de volgende 'vereisen'-instructies toe aan het begin van het dmpatterns_getstarted_service.js-bestand :

'use strict';

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

Voeg de volgende variabeledeclaraties toe en vervang de {iothubconnectionstring} tijdelijke aanduidingswaarde door de IoT-hub-connection string die u eerder hebt gekopieerd in De IoT-hub ophalen connection string:

var connectionString = '{iothubconnectionstring}';
var registry = Registry.fromConnectionString(connectionString);
var client = Client.fromConnectionString(connectionString);
var deviceToReboot = 'myDeviceId';

Voeg de volgende functie toe om de apparaatmethode aan te roepen om het doelapparaat opnieuw op te starten:

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

Voeg de volgende functie toe om een query uit te voeren voor het apparaat en de laatste keer dat het apparaat opnieuw wordt opgestart:

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

Voeg de volgende code toe om de functies aan te roepen die de directe methode voor opnieuw opstarten activeren en voer een query uit voor de laatste keer dat opnieuw wordt opgestart:
```
startRebootDevice();
setInterval(queryTwinLastReboot, 2000);
```
Sla hetdmpatterns_getstarted_service.jsbestand op en sluit het.

De apps uitvoeren

U bent nu klaar om de apps uit te voeren.

Voer bij de opdrachtprompt in de map managed-device de volgende opdracht uit om te luisteren naar de directe methode voor opnieuw opstarten.
```
node dmpatterns_getstarted_device.js
```
Voer bij de opdrachtprompt in de map trigger-reboot-on-device de volgende opdracht uit om het extern opnieuw opstarten te activeren en een query uit te voeren voor de apparaatdubbel om de laatste herstarttijd te vinden.
```
node dmpatterns_getstarted_service.js
```
U ziet het antwoord van het apparaat op de directe methode voor opnieuw opstarten en de status van het opnieuw opstarten in de console.

Hieronder ziet u het antwoord van het apparaat op de directe methode voor opnieuw opstarten die door de service is verzonden:

Hieronder ziet u de service die het opnieuw opstarten activeert en de apparaatdubbel pollt voor de laatste keer dat het opnieuw wordt opgestart:

De acties voor apparaatbeheer aanpassen en uitbreiden

Uw IoT-oplossingen kunnen de gedefinieerde set apparaatbeheerpatronen uitbreiden of aangepaste patronen inschakelen met behulp van de apparaatdubbel en cloud-naar-apparaat methode primitieven. Andere voorbeelden van acties voor apparaatbeheer zijn fabrieksinstellingen terugzetten, firmware-update, software-update, energiebeheer, netwerk- en connectiviteitsbeheer en gegevensversleuteling.

Onderhoudsvensters voor apparaten

Normaal gesproken configureert u apparaten om acties uit te voeren op een moment dat onderbrekingen en downtime tot een minimum worden beperkt. Apparaatonderhoudsvensters zijn een veelgebruikt patroon om de tijd te definiëren waarop een apparaat de configuratie moet bijwerken. Uw back-endoplossingen kunnen gebruikmaken van de gewenste eigenschappen van de apparaatdubbel om een beleid op uw apparaat te definiëren en activeren dat een onderhoudsvenster mogelijk maakt. Wanneer een apparaat het onderhoudsvensterbeleid ontvangt, kan het de gerapporteerde eigenschap van de apparaatdubbel gebruiken om de status van het beleid te rapporteren. De back-end-app kan vervolgens apparaatdubbelquery's gebruiken om de naleving van apparaten en elk beleid te bevestigen.

Volgende stappen

In dit artikel hebt u een directe methode gebruikt om opnieuw opstarten op afstand op een apparaat te activeren. U hebt de gerapporteerde eigenschappen gebruikt om de laatste keer opnieuw opstarten van het apparaat te rapporteren en de apparaatdubbel opgevraagd om de laatste opstarttijd van het apparaat vanuit de cloud te detecteren.

ToAanaan de slag gaan met IoT Hub- en apparaatbeheerpatronen, zoals end-to-end update op basis van afbeeldingen in Device Update voor Azure IoT Hub artikel met behulp van de Raspberry Pi 3 B+-referentieafbeelding.

Zie Taken plannen en uitzenden voor meer informatie over het uitbreiden van uw IoT-oplossing en het plannen van methode-aanroepen op meerdere apparaten.