Introdução à gestão de dispositivos (Node.js)

Artigo
03/16/2023

As aplicações de back-end podem utilizar Hub IoT do Azure primitivos, como dispositivos duplos e métodos diretos, para iniciar e monitorizar remotamente ações de gestão de dispositivos em dispositivos. Este artigo mostra-lhe como uma aplicação de back-end e uma aplicação de dispositivo podem funcionar em conjunto para iniciar e monitorizar um reinício remoto do dispositivo com Hub IoT.

Nota

As funcionalidades descritas neste artigo só estão disponíveis no escalão padrão do Hub IoT. Para obter mais informações sobre os escalões de Hub IoT básico e standard/gratuito, consulte Escolher o escalão de Hub IoT certo para a sua solução.

Utilize um método direto para iniciar ações de gestão de dispositivos (como reinício, reposição de fábrica e atualização de firmware) a partir de uma aplicação de back-end na cloud. O dispositivo é responsável por:

Processar o pedido de método enviado a partir de Hub IoT.
Iniciar a ação específica do dispositivo correspondente no dispositivo.
Fornecer atualizações de estado através de propriedades reportadas para Hub IoT.

Pode utilizar uma aplicação de back-end na cloud para executar consultas de dispositivo duplo para comunicar o progresso das ações de gestão de dispositivos.

Este artigo mostra-lhe como criar:

dmpatterns_getstarted_device.js: uma aplicação de dispositivo simulado com um método direto que reinicia o dispositivo e reporta a hora do último reinício. Os métodos diretos são invocados a partir da cloud.
dmpatterns_getstarted_service.js: uma aplicação de consola .NET que chama o método direto na aplicação de dispositivo simulado através do seu hub IoT. Apresenta a resposta e as propriedades reportadas atualizadas.

Pré-requisitos

Um hub IoT. Crie uma com a CLI ou a portal do Azure.
Um dispositivo registado. Registe um na portal do Azure.
Node.js versão 10.0.x ou posterior. Preparar o ambiente de desenvolvimento descreve como instalar Node.js para este artigo no Windows ou Linux.
Certifique-se de que a porta 8883 está aberta na firewall. O exemplo de dispositivo neste artigo utiliza o protocolo MQTT, que comunica através da porta 8883. Esta porta pode ser bloqueada em alguns ambientes de rede empresarial e educacional. Para obter mais informações e formas de contornar este problema, veja Ligar ao Hub IoT (MQTT).

Criar uma aplicação de dispositivo com um método direto

Nesta secção, pode:

Crie uma aplicação de consola Node.js que responda a um método direto chamado pela cloud.
Acionar um reinício simulado do dispositivo.
Utilize as propriedades comunicadas para permitir que as consultas do dispositivo duplo identifiquem dispositivos e quando foram reiniciadas pela última vez.

Crie uma pasta vazia denominada dispositivo gerido. Na pasta managed-device , crie um ficheiro package.json com o seguinte comando na linha de comandos. Aceite todas as predefinições:
```
npm init
```
Na linha de comandos na pasta managed-device , execute o seguinte comando para instalar o pacote do SDK do Dispositivo azure-iot-device e o pacote azure-iot-device-mqtt :
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Com um editor de texto, crie um ficheiro dmpatterns_getstarted_device.js na pasta managed-device .

Adicione as seguintes instruções "require" no início do ficheiro dedmpatterns_getstarted_device.js :

'use strict';

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

Adicione uma variável connectionString e utilize-a para criar uma instância do Cliente. Substitua o valor do {yourdeviceconnectionstring} marcador de posição pela cadeia de ligação do dispositivo que viu quando registou um dispositivo no Hub IoT:
```
var connectionString = '{yourdeviceconnectionstring}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Adicione a seguinte função para implementar o método direto no dispositivo

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

Abra a ligação ao hub IoT e inicie o serviço de escuta do método direto:

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

Guarde e feche o ficheiro dmpatterns_getstarted_device.js .

Nota

Para manter as coisas simples, este artigo não implementa uma política de repetição. No código de produção, deve implementar políticas de repetição (como um recuo exponencial), conforme sugerido no artigo Processamento transitório de falhas.

Obter a cadeia de ligação do hub IoT

Neste artigo, vai criar um serviço de back-end que invoca um método direto num dispositivo. Para invocar um método direto num dispositivo através de Hub IoT, o serviço precisa da permissão de ligação do serviço. Por predefinição, todos os Hub IoT são criados com uma política de acesso partilhado denominada serviço que concede esta permissão.

Para obter a cadeia de ligação Hub IoT para a política de serviço, siga estes passos:

Na portal do Azure, selecione Grupos de recursos. Selecione o grupo de recursos onde o hub está localizado e, em seguida, selecione o hub na lista de recursos.
No painel esquerdo do hub IoT, selecione Políticas de acesso partilhado.
Na lista de políticas, selecione a política de serviço .
Copie a cadeia de ligação Primária e guarde o valor.

Para obter mais informações sobre Hub IoT permissões e políticas de acesso partilhado, veja Controlo de acesso e permissões.

Criar uma aplicação de serviço para acionar um reinício

Nesta secção, vai criar uma aplicação de consola Node.js que inicia um reinício remoto num dispositivo através de um método direto. A aplicação utiliza consultas de dispositivo duplo para detetar a hora do último reinício desse dispositivo.

Crie uma pasta vazia denominada trigger-reboot-on-device. Na pasta trigger-reboot-on-device , crie um ficheiro package.json com o seguinte comando na linha de comandos. Aceite todas as predefinições:
```
npm init
```
Na linha de comandos na pasta trigger-reboot-on-device , execute o seguinte comando para instalar o pacote Azure-iothub Device SDK e o pacote azure-iot-device-mqtt :
```
npm install azure-iothub --save
```
Com um editor de texto, crie um ficheiro dmpatterns_getstarted_service.js na pasta trigger-reboot-on-device .

Adicione as seguintes instruções "require" no início do ficheiro dedmpatterns_getstarted_service.js :

'use strict';

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

Adicione as seguintes declarações de variáveis e substitua o valor do {iothubconnectionstring} marcador de posição pela cadeia de ligação do hub IoT que copiou anteriormente em Obter a cadeia de ligação do hub IoT:
```
var connectionString = '{iothubconnectionstring}';
var registry = Registry.fromConnectionString(connectionString);
var client = Client.fromConnectionString(connectionString);
var deviceToReboot = 'myDeviceId';
```

Adicione a seguinte função para invocar o método do dispositivo para reiniciar o dispositivo de destino:

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

Adicione a seguinte função para consultar o dispositivo e obter a hora do último reinício:

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

Adicione o seguinte código para chamar as funções que acionam o método direto de reinício e a consulta para a última hora de reinício:
```
startRebootDevice();
setInterval(queryTwinLastReboot, 2000);
```
Guarde e feche o ficheiro dmpatterns_getstarted_service.js .

Executar as aplicações

Agora, está pronto para executar as aplicações.

Na linha de comandos na pasta managed-device , execute o seguinte comando para começar a escutar o método direto de reinício.
```
node dmpatterns_getstarted_device.js
```
Na linha de comandos na pasta trigger-reboot-on-device , execute o seguinte comando para acionar o reinício remoto e a consulta do dispositivo duplo para encontrar a hora do último reinício.
```
node dmpatterns_getstarted_service.js
```
Verá a resposta do dispositivo ao método direto de reinício e ao estado de reinício na consola do .

O seguinte mostra a resposta do dispositivo ao método direto de reinício enviado pelo serviço:

O seguinte mostra o serviço a acionar o reinício e a consultar o dispositivo duplo durante a última hora de reinício:

Personalizar e expandir as ações de gestão de dispositivos

As suas soluções de IoT podem expandir o conjunto definido de padrões de gestão de dispositivos ou ativar padrões personalizados com os primitivos do dispositivo duplo e do método cloud para dispositivo. Outros exemplos de ações de gestão de dispositivos incluem a reposição de fábrica, atualização de firmware, atualização de software, gestão de energia, gestão de rede e conectividade e encriptação de dados.

Janelas de manutenção do dispositivo

Normalmente, configura dispositivos para efetuar ações de cada vez que minimizam as interrupções e o tempo de inatividade. As janelas de manutenção do dispositivo são um padrão frequentemente utilizado para definir a hora em que um dispositivo deve atualizar a configuração. As suas soluções de back-end podem utilizar as propriedades pretendidas do dispositivo duplo para definir e ativar uma política no seu dispositivo que permite uma janela de manutenção. Quando um dispositivo recebe a política de janela de manutenção, pode utilizar a propriedade reportada do dispositivo duplo para comunicar o estado da política. Em seguida, a aplicação de back-end pode utilizar consultas de dispositivo duplo para atestar a conformidade dos dispositivos e de cada política.

Passos seguintes

Neste artigo, utilizou um método direto para acionar um reinício remoto num dispositivo. Utilizou as propriedades comunicadas para comunicar a hora do último reinício do dispositivo e consultou o dispositivo duplo para detetar a hora do último reinício do dispositivo a partir da cloud.

Para continuar a introdução aos padrões de gestão de Hub IoT e dispositivos, como a atualização ponto a ponto baseada em imagens no artigo Atualização de Dispositivos para Hub IoT do Azure utilizando a Imagem de Referência raspberry Pi 3 B+.

Para saber como expandir a sua solução de IoT e agendar chamadas de método em vários dispositivos, veja Agendar e difundir tarefas.

Share via