Prise en main de la gestion d’appareils (Node.js)

Article
03/18/2023

Les applications back-end peuvent utiliser des primitives Azure IoT Hub, par exemple les jumeaux d’appareil et les méthodes directes, pour effectuer le démarrage et le monitoring à distance des actions de gestion des appareils sur les appareils. Cet article illustre la manière dont une application back-end et une application pour périphérique fonctionnent conjointement afin de lancer et d’analyser le redémarrage à distance d’un appareil à l’aide de IoT Hub.

Notes

Les fonctionnalités décrites dans cet article sont uniquement disponibles au niveau Standard d’IoT Hub. Pour plus d’informations sur les niveaux de base et standard/gratuit d’IoT Hub, consultez Choisir le niveau IoT Hub correspondant à votre solution.

Utilisez une méthode directe pour lancer des actions de gestion d’appareils (redémarrage, réinitialisation des paramètres d’usine et mise à jour du microprogramme) à partir d’une application principale dans le cloud. L’appareil est chargé de :

Gérer la requête de méthode envoyée à partir d’IoT Hub.
Démarrer l’action correspondante spécifique à l’appareil sur l’appareil.
Fournir à IoT Hub des mises à jour de l’état via des propriétés signalées.

Vous pouvez utiliser une application principale dans le cloud pour exécuter des requêtes sur la représentation d’appareil afin d’indiquer la progression des actions de gestion de votre appareil.

Cet article explique comment créer :

dmpatterns_getstarted_device.js : une application d’appareil simulée avec une méthode directe qui redémarre l’appareil et signale la dernière heure de redémarrage. Les méthodes directes sont appelées à partir du cloud.
dmpatterns_getstarted_service.js :une application console .NET qui appelle la méthode directe sur l’application d’appareil simulé via votre IoT Hub. Il affiche la réponse et les propriétés signalées mises à jour.

Prérequis

Un IoT Hub. Créez-en un avec l’interface CLI ou le portail Azure.
Appareil inscrit. Inscrivez-en un dans le portail Azure.
Node.j version 10.0.x ou ultérieure. Préparer votre environnement de développement décrit l’installation de Node.js sur Windows ou sur Linux.
Vérifiez que le port 8883 est ouvert dans votre pare-feu. L’exemple d’appareil décrit dans cet article utilise le protocole MQTT, qui communique via le port 8883. Ce port peut être bloqué dans certains environnements réseau professionnels et scolaires. Pour plus d’informations sur les différentes façons de contourner ce problème, consultez Connexion à IoT Hub (MQTT).

Créer une application d’appareil avec une méthode directe

Dans cette section, vous allez :

Créer une application console Node.js qui répond à une méthode directe appelée par le cloud.
Déclencher un redémarrage d’appareil simulé.
Utiliser les propriétés signalées pour activer les requêtes sur le jumeau d’appareil afin d’identifier les appareils et l’heure de leur dernier redémarrage.

Créez un dossier vide nommé appareil-géré. Dans le dossier appareil-géré, créez un fichier package.json en utilisant la commande suivante lors de l’invite de commandes. Acceptez toutes les valeurs par défaut :
```
npm init
```
Lors de l’invite de commandes, dans le dossier appareil-géré, exécutez la commande suivante pour installer le package du SDK d’appareil azure-iot-device et le package azure-iot-device-mqtt :
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
À l’aide d’un éditeur de texte, créez un fichier dmpatterns_getstarted_device.js dans le dossier appareil-géré.

Ajoutez les instructions 'require' suivantes au début du fichier dmpatterns_getstarted_device.js :

'use strict';

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

Ajoutez une variable connectionString et utilisez-la pour créer une instance de Client. Remplacez la valeur d’espace réservé {yourdeviceconnectionstring} par la chaîne de connexion de l’appareil affichée lorsque vous avez inscrit un appareil dans IoT Hub :
```
var connectionString = '{yourdeviceconnectionstring}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Ajoutez la fonction suivante pour implémenter la méthode directe sur l’appareil

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

Ouvrez la connexion à votre hub IoT et démarrez l’écouteur de la méthode directe :

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

Enregistrez et fermez le fichier dmpatterns_getstarted_device.js.

Notes

Pour simplifier les choses, cet article n’implémente aucune stratégie de nouvelles tentatives. Dans le code de production, vous devez implémenter des stratégies de nouvelle tentative (par exemple, une interruption exponentielle), comme indiqué dans l’article Gestion des erreurs temporaires.

Obtenir la chaîne de connexion du hub IoT

Dans cet article, vous créez un service principal qui invoque une méthode directe sur un appareil. Pour invoquer une méthode directe sur un appareil via l’IoT Hub, votre service a besoin de l'autorisation de connexion de service. Par défaut, chaque IoT Hub est créé avec une stratégie d’accès partagé nommée service qui accorde cette autorisation.

Pour obtenir la chaîne de connexion IoT Hub pour la stratégie service, procédez comme suit :

Dans le portail Azure, sélectionnez Groupes de ressources. Sélectionnez le groupe de ressources dans lequel se trouve votre hub, puis sélectionnez votre hub dans la liste des ressources.
Dans le volet de gauche de votre IoT Hub, sélectionnez Stratégies d’accès partagé.
Dans la liste des stratégies, sélectionnez la stratégie service.
Copiez la Chaîne de connexion principale, puis enregistrez la valeur.

Pour plus d’informations sur les autorisations et les stratégies d’accès partagé IoT Hub, consultez Contrôle d’accès et autorisations.

Créer une application de service pour déclencher un redémarrage

Dans cette section, vous créez une application console Node.js qui lance un redémarrage à distance sur un appareil avec une méthode directe. L’application utilise des requêtes du jumeau d’appareil pour déterminer l’heure du dernier redémarrage de cet appareil.

Créez un dossier vide nommé déclencher-redémarrage-sur-appareil. Dans le dossier déclencher-redémarrage-sur-appareil, créez un fichier package.json en utilisant la commande suivante lors de l’invite de commandes. Acceptez toutes les valeurs par défaut :
```
npm init
```
Lors de l’invite de commandes, dans le dossier déclencher-redémarrage-sur-appareil, exécutez la commande suivante pour installer le package du SDK d’appareil azure-iothub et le package azure-iot-device-mqtt :
```
npm install azure-iothub --save
```
À l’aide d’un éditeur de texte, créez un fichier dmpatterns_getstarted_service.js dans le dossier déclencher-redémarrage-sur-appareil.

Ajoutez les instructions ’require’ suivantes au début du fichier dmpatterns_getstarted_service.js :

'use strict';

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

Ajoutez les déclarations de variable suivantes et remplacez la valeur d’espace réservé {iothubconnectionstring} par la chaîne de connexion du hub IoT que vous avez copiée précédemment dans Obtenir la chaîne de connexion du hub IoT :
```
var connectionString = '{iothubconnectionstring}';
var registry = Registry.fromConnectionString(connectionString);
var client = Client.fromConnectionString(connectionString);
var deviceToReboot = 'myDeviceId';
```

Ajoutez la fonction suivante pour appeler la méthode device afin de redémarrer l’appareil cible :

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

Ajoutez la fonction suivante pour interroger l’appareil et obtenir l’heure du dernier redémarrage :

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

Ajoutez le code suivant pour appeler les fonctions qui déclenchent la méthode directe de redémarrage et la requête sur le dernier redémarrage :
```
startRebootDevice();
setInterval(queryTwinLastReboot, 2000);
```
Enregistrez et fermez le fichier dmpatterns_getstarted_service.js.

Exécuter les applications

Vous êtes maintenant prêt à exécuter les applications.

À l’invite de commandes, dans le dossier appreil-géré, exécutez la commande suivante pour commencer à écouter la méthode directe de redémarrage.
```
node dmpatterns_getstarted_device.js
```
Lors de l’invite de commandes, dans le dossier déclencher-redémarrage-sur-appareil, exécutez la commande suivante pour déclencher le redémarrage à distance et interroger le jumeau d’appareil pour déterminer l’heure du dernier redémarrage.
```
node dmpatterns_getstarted_service.js
```
La réponse de l’appareil à la méthode directe de redémarrage et l’état de redémarrage s’affichent dans la console.

Voici la réponse de l’appareil à la méthode directe de redémarrage envoyée par le service :

Le code suivant montre le service déclenchant le redémarrage et interrogeant le jumeau d’appareil sur le dernier redémarrage :

Personnaliser et étendre les actions de gestion d’appareils

Vos solutions IoT peuvent étendre l’ensemble défini de modèles de gestion d’appareils ou activer des modèles personnalisés en utilisant les primitives de la méthode cloud-à-appareil et du jumeau d’appareil. La réinitialisation des paramètres d’usine, la mise à jour du microprogramme, la mise à jour logicielle, la gestion de l’alimentation, la gestion du réseau et de la connectivité, et le chiffrement des données sont d’autres exemples d’actions de gestion des appareils.

Fenêtres de maintenance d’appareil

En règle générale, vous configurez des appareils pour effectuer des actions à un moment qui minimise les interruptions et les temps d’arrêt. Les fenêtres de maintenance d’appareil constituent un modèle couramment utilisé pour définir l’heure à laquelle un appareil doit mettre à jour sa configuration. Vos solutions principales peuvent utiliser les propriétés souhaitées de la représentation d’appareil pour définir et activer une stratégie sur votre appareil qui permet d’obtenir une fenêtre de maintenance. Lorsqu’un appareil reçoit la stratégie de fenêtre de maintenance, il peut utiliser la propriété signalée de la représentation d’appareil pour indiquer l’état de la stratégie. L’application principale peut ensuite utiliser des requêtes de représentation d’appareil pour certifier la conformité des appareils et de chaque stratégie.

Étapes suivantes

Dans cet article, vous avez utilisé une méthode directe pour déclencher un redémarrage à distance sur un appareil. Vous avez utilisé les propriétés signalées pour indiquer le moment du dernier redémarrage de l’appareil et vous avez interrogé le jumeau d’appareil pour découvrir l’heure du dernier redémarrage de l’appareil à partir du cloud.

Pour approfondir vos connaissances sur IoT Hub et les modèles de gestion des appareils, comme la mise à jour de bout en bout basée sur une image, consultez l’article relatif à la mise à jour des appareils pour Azure IoT Hub à l’aide de l’image de référence Raspberry Pi 3 B+.

Pour savoir comment étendre votre solution IoT et planifier des appels de méthode sur plusieurs appareils, consultez Planifier et diffuser des travaux.