Planifier et diffuser des travaux (Node.js)

Article
03/21/2023

Utilisez Azure IoT Hub pour planifier et suivre des travaux qui mettent à jour des millions d’appareils. Utilisez les travaux pour :

Mettre à jour les propriétés souhaitées
Mettre à jour les balises
Appeler des méthodes directes

Sur le plan conceptuel, un travail encapsule l’une de ces actions et suit la progression de l’exécution par rapport à un ensemble d’appareils, défini par une requête de représentation d’appareil. Par exemple, à l’aide d’un travail, une application principale peut appeler une méthode de redémarrage sur 10 000 appareils, spécifiée par une requête de représentation d’appareil et planifiée dans l’avenir. Cette application peut ensuite suivre la progression à mesure que chacun de ces appareils reçoit et exécute la méthode de redémarrage.

Pour en savoir plus sur chacune de ces fonctionnalités, consultez les articles suivants :

Jumeau d’appareil et propriétés : Prise en main des représentations d’appareils (Node) et Comprendre et utiliser les jumeaux d’appareil IoT Hub
Méthodes directes : Guide du développeur IoT Hub - méthodes directes

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.

Cet article vous montre comment créer deux applications Node.js :

Une application Node.js d’appareil simulé, simDevice.js, qui implémente une méthode directe appelée lockDoor, qui peut être appelée par l’application back-end.
Une application console Node.js, scheduleJobService.js, qui crée deux travaux. Un travail appelle la méthode directe lockDoor et un autre travail envoie les mises à jour de propriété souhaitées à plusieurs appareils.

Notes

Pour plus d’informations sur les outils SDK disponibles pour créer des applications d’appareil et de back-end, consultez les SDK Azure IoT.

Prérequis

Un IoT Hub. Créez-en un avec l’interface CLI ou le portail Azure.
Un appareil inscrit dans votre hub IoT. Si vous n’avez pas d’appareil dans votre hub IoT, suivez les étapes décrites dans Inscrire un appareil.
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éation d’une application de périphérique simulé

Dans cette section, vous allez créer une application console Node.js qui répond à une méthode directe appelée par le cloud, ce qui déclenche une méthode lockDoor simulée.

Créez un dossier vide appelé simDevice. Dans le dossier simDevice , créez un fichier package.json à l’aide de la commande ci-dessous, à l’invite de commandes. Acceptez toutes les valeurs par défaut :
```
npm init
```
À l’invite de commandes, dans le dossier simDevice, exécutez la commande suivante pour installer les packages Kit de développement logiciel (SDK) pour appareils azure-iot-device et azure-iot-device-mqtt :
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Dans un éditeur de texte, créez un fichier simDevice.js dans le dossier simDevice.

Ajoutez les instructions ’require’ ci-dessous au début du fichier simDevice.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 copiée précédemment.
```
var connectionString = '{yourDeviceConnectionString}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Ajoutez la fonction suivante pour gérer la méthode 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!');
};

Ajoutez le code suivant pour inscrire le gestionnaire de la méthode 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);
     }
});

Enregistrez et fermez le fichier simDevice.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.

Obtention de la chaîne de connexion de l’IoT Hub

Dans cet article, vous créez un service back-end qui planifie une tâche pour appeler une méthode directe sur un appareil, planifie une tâche pour mettre à jour le jumeau d’appareil, et supervise l’avancement de chaque tâche. Pour effectuer ces opérations, votre service requiert les autorisations de lecture du registre et d’écriture du registre. Par défaut, chaque hub IoT est créé avec une stratégie d’accès partagé nommée registryReadWrite qui accorde ces autorisations.

Pour obtenir la chaîne de connexion IoT Hub pour la stratégie registryReadWrite, 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 hub, sélectionnez Stratégies d’accès partagé.
Dans la liste des stratégies, sélectionnez la stratégie registryReadWrite.
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.

Planifier des travaux pour appeler une méthode directe et mettre à jour les propriétés d’une représentation d’appareil

Dans cette section, vous créez une application console Node.js qui lance lockDoor à distance sur un appareil à l’aide d’une méthode directe et met à jour les propriétés de représentation d’appareil.

Créez un dossier vide appelé scheduleJobService. Dans le dossier scheduleJobService, créez un fichier package.json à l’aide de la commande ci-dessous, à l’invite de commandes. Acceptez toutes les valeurs par défaut :
```
npm init
```
À l’invite de commandes, dans le dossier scheduleJobService, exécutez la commande suivante pour installer les packages Kit de développement logiciel (SDK) pour appareils azure-iothub et azure-iot-device-mqtt :
```
npm install azure-iothub uuid --save
```
À l’aide d’un éditeur de texte, créez un nouveau fichier scheduleJobService.js dans le dossier scheduleJobService.

Ajoutez les instructions ’require’ ci-dessous au début du fichier scheduleJobService.js :

'use strict';

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

Ajoutez les déclarations de variable suivantes. Remplacez la valeur de l’espace réservé {iothubconnectionstring}par la valeur copiée dans Obtenir la chaîne de connexion du hub IoT. Si vous avez inscrit un autre appareil que myDeviceId, veillez à le modifier dans la condition de requête.
```
var connectionString = '{iothubconnectionstring}';
var queryCondition = "deviceId IN ['myDeviceId']";
var startTime = new Date();
var maxExecutionTimeInSeconds =  300;
var jobClient = JobClient.fromConnectionString(connectionString);
```

Ajoutez la fonction suivante, qui permet de surveiller l’exécution du travail :

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

Ajoutez le code suivant pour planifier le travail qui appelle la méthode de l’appareil :

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

Ajoutez le code suivant pour planifier le travail de mise à jour de la représentation d’appareil :

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

Enregistrez et fermez le fichier scheduleJobService.js.

Exécution des applications

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

À l’invite de commandes, dans le dossier simDevice, exécutez la commande suivante pour commencer à écouter la méthode directe de redémarrage.
```
node simDevice.js
```
À l’invite de commandes dans le dossier scheduleJobService, exécutez la commande suivante pour déclencher les travaux afin de verrouiller la porte et de mettre à jour le jumeau
```
node scheduleJobService.js
```
La réponse de l’appareil à la méthode directe et l’état du travail s’affichent dans la console.

La réponse de l’appareil à la méthode directe est affichée ci-dessous :

L’exemple suivant montre les travaux de planification de service pour la méthode directe et la mise à jour du jumeau d'appareil, ainsi que les tâches qui s’exécutent jusqu’à la fin :

Étapes suivantes

Dans cet article, vous avez planifié des travaux pour exécuter une méthode directe et mettre à jour les propriétés du jumeau d’appareil.

Pour continuer à explorer le hub IoT et les modèles de gestion des appareils, mettez à jour une image dans le Tutoriel sur le service Device Update pour IoT Hub : Utilisation de l’image de référence Raspberry Pi 3 B+.

Partager via

Planifier et diffuser des travaux (Node.js)

Prérequis

Création d’une application de périphérique simulé

Obtention de la chaîne de connexion de l’IoT Hub

Planifier des travaux pour appeler une méthode directe et mettre à jour les propriétés d’une représentation d’appareil

Exécution des applications

Étapes suivantes

Commentaires

Commentaires

Ressources supplémentaires