Introdução ao gerenciamento de dispositivos (Node.js)

Artigo
06/20/2024

Os aplicativos back-end podem usar primitivos do Hub IoT do Azure, como gêmeos de dispositivo e métodos diretos, para iniciar e monitorar remotamente ações de gerenciamento de dispositivos em dispositivos. Este artigo mostra como um aplicativo back-end e um aplicativo de dispositivo podem trabalhar juntos para iniciar e monitorar uma reinicialização remota de dispositivo usando o Hub IoT.

Nota

Os recursos descritos neste artigo estão disponíveis somente na camada padrão do Hub IoT. Para obter mais informações sobre as camadas básica e padrão/gratuita do Hub IoT, consulte Escolha a camada certa do Hub IoT para sua solução.

Use um método direto para iniciar ações de gerenciamento de dispositivos (como reinicialização, redefinição de fábrica e atualização de firmware) a partir de um aplicativo back-end na nuvem. O dispositivo é responsável por:

Manipulando a solicitação de método enviada do Hub IoT.
Iniciar a ação específica do dispositivo correspondente no dispositivo.
Fornecer atualizações de status por meio de propriedades relatadas para o Hub IoT.

Você pode usar um aplicativo back-end na nuvem para executar consultas gêmeas de dispositivo para relatar o progresso de suas ações de gerenciamento de dispositivos.

Este artigo mostra como criar:

dmpatterns_getstarted_device.js: um aplicativo de dispositivo simulado com um método direto que reinicializa o dispositivo e relata a última hora de reinicialização. Os métodos diretos são invocados a partir da nuvem.
dmpatterns_getstarted_service.js: um aplicativo de console .NET que chama o método direto no aplicativo de dispositivo simulado por meio de seu hub IoT. Ele exibe a resposta e as propriedades relatadas atualizadas.

Pré-requisitos

Um hub IoT. Crie um com a CLI ou o portal do Azure.
Um dispositivo registrado em seu hub IoT. Se você não tiver um dispositivo em seu hub IoT, siga as etapas em Registrar um dispositivo.
Node.js versão 10.0.x ou posterior. Prepare your development environment descreve como instalar Node.js para este artigo no Windows ou Linux.
Verifique se a porta 8883 está aberta no firewall. O exemplo de dispositivo neste artigo usa o protocolo MQTT, que se comunica pela porta 8883. Essa porta pode estar bloqueada em alguns ambientes de rede corporativa e educacional. Para obter mais informações e maneiras de contornar esse problema, consulte Conectando-se ao Hub IoT (MQTT).

Criar um aplicativo de dispositivo com um método direto

Nesta secção, pode:

Crie um aplicativo de console Node.js que responda a um método direto chamado pela nuvem.
Acione uma reinicialização simulada do dispositivo.
Use as propriedades relatadas para habilitar consultas gêmeas de dispositivo para identificar dispositivos e quando eles foram reinicializados pela última vez.

Crie uma pasta vazia chamada managed-device. Na pasta managed-device, crie um arquivo package.json usando o seguinte comando no prompt de comando. Aceite todas as predefinições:
```
npm init
```
No prompt de comando na pasta managed-device, execute o seguinte comando para instalar o pacote azure-iot-device Device SDK e o pacote azure-iot-device-mqtt:
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Usando um editor de texto, crie um arquivo de dmpatterns_getstarted_device.js na pasta do dispositivo gerenciado.

Adicione as seguintes instruções 'require' no início do arquivo dmpatterns_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} espaço reservado pela cadeia de conexão do dispositivo que você viu quando registrou um dispositivo no Hub IoT:
```
var connectionString = '{yourdeviceconnectionstring}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Adicione a seguinte função para implementar o método direct 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 conexão com seu hub IoT e inicie o ouvinte de 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);
    }
});

Salve e feche o arquivo dmpatterns_getstarted_device.js .

Nota

Para simplificar, este artigo não implementa uma política de novas tentativas. No código de produção, você deve implementar políticas de repetição (como um backoff exponencial), conforme sugerido no artigo, Tratamento de falhas transitórias.

Obter a cadeia de conexão do hub IoT

Neste artigo, você cria um serviço de back-end que invoca um método direto em um dispositivo. Para invocar um método direto em um dispositivo por meio do Hub IoT, seu serviço precisa da permissão de conexão de serviço. Por padrão, cada Hub IoT é criado com uma política de acesso compartilhado chamada serviço que concede essa permissão.

Para obter a cadeia de conexão do Hub IoT para a política de serviço , siga estas etapas:

No 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 compartilhado.
Na lista de políticas, selecione a política de serviço .
Copie a cadeia de conexão primária e salve o valor.

Para obter mais informações sobre políticas e permissões de acesso compartilhado do Hub IoT, consulte Controle de acesso e permissões.

Criar um aplicativo de serviço para disparar uma reinicialização

Nesta seção, você cria um aplicativo de console Node.js que inicia uma reinicialização remota em um dispositivo usando um método direto. O aplicativo usa consultas gêmeas de dispositivo para descobrir o último tempo de reinicialização para esse dispositivo.

Crie uma pasta vazia chamada trigger-reboot-on-device. Na pasta trigger-reboot-on-device, crie um arquivo package.json usando o seguinte comando no prompt de comando. Aceite todas as predefinições:
```
npm init
```
No prompt de comando 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
```
Usando um editor de texto, crie um arquivo de dmpatterns_getstarted_service.js na pasta trigger-reboot-on-device .

Adicione as seguintes instruções 'require' no início do arquivo dmpatterns_getstarted_service.js:

'use strict';

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

Adicione as seguintes declarações de variável e substitua o valor do espaço reservado {iothubconnectionstring} pela cadeia de conexão do hub IoT copiada anteriormente em Obter a cadeia de conexã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 de 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 o último tempo de reinicialização:

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 reinicialização e consultar a última hora de reinicialização:
```
startRebootDevice();
setInterval(queryTwinLastReboot, 2000);
```
Salve e feche o arquivo dmpatterns_getstarted_service.js .

Executar as aplicações

Agora você está pronto para executar os aplicativos.

No prompt de comando na pasta managed-device , execute o seguinte comando para começar a ouvir o método direto de reinicialização.
```
node dmpatterns_getstarted_device.js
```
No prompt de comando na pasta trigger-reboot-on-device , execute o seguinte comando para acionar a reinicialização remota e consultar o gêmeo do dispositivo para encontrar a última hora de reinicialização.
```
node dmpatterns_getstarted_service.js
```
Você vê a resposta do dispositivo ao método direto de reinicialização e o status de reinicialização no console.

A seguir mostra a resposta do dispositivo ao método direto de reinicialização enviado pelo serviço:

A seguir mostra o serviço acionando a reinicialização e sondando o gêmeo do dispositivo para a última hora de reinicialização:

Personalizar e estender as ações de gerenciamento de dispositivos

Suas soluções de IoT podem expandir o conjunto definido de padrões de gerenciamento de dispositivos ou habilitar padrões personalizados usando as primitivas de método de gêmeo de dispositivo e de nuvem para dispositivo. Outros exemplos de ações de gerenciamento de dispositivos incluem redefinição de fábrica, atualização de firmware, atualização de software, gerenciamento de energia, gerenciamento de rede e conectividade e criptografia de dados.

Janelas de manutenção de dispositivos

Normalmente, você configura dispositivos para executar ações em um momento que minimiza interrupções e tempo de inatividade. As janelas de manutenção de dispositivos são um padrão comumente usado para definir o momento em que um dispositivo deve atualizar sua configuração. Suas soluções de back-end podem usar as propriedades desejadas do gêmeo de dispositivo para definir e ativar uma política em seu dispositivo que permita uma janela de manutenção. Quando um dispositivo recebe a política da janela de manutenção, ele pode usar a propriedade relatada do gêmeo do dispositivo para relatar o status da política. O aplicativo back-end pode usar consultas gêmeas de dispositivo para atestar a conformidade dos dispositivos e de cada política.

Próximos passos

Neste artigo, você usou um método direto para disparar uma reinicialização remota em um dispositivo. Você usou as propriedades relatadas para relatar a última hora de reinicialização do dispositivo e consultou o gêmeo do dispositivo para descobrir a última hora de reinicialização do dispositivo a partir da nuvem.

ToPara continuar a introdução ao Hub IoT e aos padrões de gerenciamento de dispositivos, como a atualização completa baseada em imagem no artigo Atualização de Dispositivo para o Hub IoT do Azure usando a Imagem de Referência do Raspberry Pi 3 B+.

Para saber como estender sua solução de IoT e agendar chamadas de método em vários dispositivos, consulte Agendar e transmitir trabalhos.

Partilhar via