Trabalhos de programação e transmissão (Node.js)

Artigo
10/01/2024

Use o Hub IoT do Azure para agendar e rastrear trabalhos que atualizam milhões de dispositivos. Use trabalhos para:

Atualizar as propriedades pretendidas
Atualizar tags
Invocar métodos diretos

Conceitualmente, um trabalho encapsula uma dessas ações e rastreia o progresso da execução em relação a um conjunto de dispositivos, que é definido por uma consulta gêmea de dispositivo. Por exemplo, um aplicativo back-end pode usar um trabalho para invocar um método de reinicialização em 10.000 dispositivos, especificado por uma consulta gêmea de dispositivo e agendado em um momento futuro. Esse aplicativo pode então acompanhar o progresso à medida que cada um desses dispositivos recebe e executa o método de reinicialização.

Saiba mais sobre cada um desses recursos nestes artigos:

Gêmeos e propriedades de dispositivos: Introdução aos gêmeos de dispositivo e Compreender e usar gêmeos de dispositivo no Hub IoT
Métodos diretos: Guia do desenvolvedor do Hub IoT - métodos diretos

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.

Este artigo mostra como criar dois aplicativos Node.js:

Um aplicativo de dispositivo simulado Node.js, simDevice.js, que implementa um método direto chamado lockDoor, que pode ser chamado pelo aplicativo back-end.
Um aplicativo de console Node.js, scheduleJobService.js, que cria dois trabalhos. Um trabalho chama o método direto lockDoor e outro trabalho envia atualizações de propriedade desejadas para vários dispositivos.

Nota

Consulte SDKs do Azure IoT para obter mais informações sobre as ferramentas SDK disponíveis para criar aplicativos de dispositivo e back-end.

Pré-requisitos

Um hub IoT em sua assinatura do Azure. Se você ainda não tiver um hub, siga as etapas em Criar um hub IoT.
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 uma aplicação de dispositivo simulada

Nesta seção, você cria um aplicativo de console Node.js que responde a um método direto chamado pela nuvem, que aciona um método lockDoor simulado.

Importante

Este artigo inclui etapas para conectar um dispositivo usando uma assinatura de acesso compartilhado, também chamada de autenticação de chave simétrica. Esse método de autenticação é conveniente para testes e avaliações, mas autenticar um dispositivo usando certificados X.509 é uma abordagem mais segura. Para saber mais, consulte Práticas > recomendadas de segurança Segurança de conexão.

Crie uma nova pasta vazia chamada simDevice. Na pasta simDevice, 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 simDevice, 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 novo arquivo simDevice.js na pasta simDevice .

Adicione as seguintes instruções 'require' no início do arquivo simDevice.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 {yourDeviceConnectionString} valor do espaço reservado pela cadeia de conexão do dispositivo copiada anteriormente.
```
var connectionString = '{yourDeviceConnectionString}';
var client = Client.fromConnectionString(connectionString, Protocol);
```

Adicione a seguinte função para manipular o método 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!');
};

Adicione o seguinte código para registrar o manipulador para o método 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);
     }
});

Salve e feche o arquivo simDevice.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 agenda um trabalho para invocar um método direto em um dispositivo, agenda um trabalho para atualizar o gêmeo do dispositivo e monitora o progresso de cada trabalho. Para executar essas operações, seu serviço precisa das permissões de leitura e gravação do Registro. Por padrão, cada hub IoT é criado com uma política de acesso compartilhado chamada registryReadWrite que concede essas permissões.

Para obter a cadeia de conexão do Hub IoT para a política registryReadWrite , 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, selecione Políticas de acesso compartilhado.
Na lista de políticas, selecione a política registryReadWrite .
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.

Importante

Este artigo inclui etapas para se conectar a um serviço usando uma assinatura de acesso compartilhado. Esse método de autenticação é conveniente para teste e avaliação, mas autenticar em um serviço com ID do Microsoft Entra ou identidades gerenciadas é uma abordagem mais segura. Para saber mais, consulte Práticas > recomendadas de segurança Segurança na nuvem.

Agendar trabalhos para chamar um método direto e atualizar as propriedades de um gêmeo de dispositivo

Nesta seção, você cria um aplicativo de console Node.js que inicia um lockDoor remoto em um dispositivo usando um método direto e atualiza as propriedades do gêmeo do dispositivo.

Crie uma nova pasta vazia chamada scheduleJobService. Na pasta scheduleJobService, 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 scheduleJobService, execute o seguinte comando para instalar o pacote azure-iothub Device SDK e o pacote azure-iot-device-mqtt:
```
npm install azure-iothub uuid --save
```
Usando um editor de texto, crie um novo arquivo de scheduleJobService.js na pasta scheduleJobService .

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

'use strict';

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

Adicione as seguintes declarações de variáveis. Substitua o valor do {iothubconnectionstring} espaço reservado pelo valor copiado em Obter a cadeia de conexão do hub IoT. Se você registrou um dispositivo diferente de myDeviceId, certifique-se de alterá-lo na condição de consulta.
```
var connectionString = '{iothubconnectionstring}';
var queryCondition = "deviceId IN ['myDeviceId']";
var startTime = new Date();
var maxExecutionTimeInSeconds =  300;
var jobClient = JobClient.fromConnectionString(connectionString);
```

Adicione a seguinte função que é usada para monitorar a execução do trabalho:

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

Adicione o seguinte código para agendar o trabalho que chama o método de dispositivo:

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

Adicione o seguinte código para agendar o trabalho para atualizar o gêmeo do dispositivo:

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

Salve e feche o arquivo scheduleJobService.js .

Executar as aplicações

Pode agora executar as aplicações.

No prompt de comando na pasta simDevice , execute o seguinte comando para começar a ouvir o método direto de reinicialização.
```
node simDevice.js
```
No prompt de comando na pasta scheduleJobService , execute o seguinte comando para acionar os trabalhos para bloquear a porta e atualizar o gêmeo
```
node scheduleJobService.js
```
Você vê a resposta do dispositivo ao método direto e o status do trabalho no console.

A seguir mostra a resposta do dispositivo ao método direto:

A seguir mostra os trabalhos de agendamento de serviço para o método direto e a atualização gêmea do dispositivo, e os trabalhos em execução até a conclusão:

Próximos passos

Neste artigo, você agendou trabalhos para executar um método direto e atualizar as propriedades do gêmeo do dispositivo.

Para continuar explorando o Hub IoT e os padrões de gerenciamento de dispositivos, atualize uma imagem no tutorial Atualização de Dispositivo para o Hub IoT do Azure usando a Imagem de Referência do Raspberry Pi 3 B+.

Partilhar via

Trabalhos de programação e transmissão (Node.js)

Pré-requisitos

Criar uma aplicação de dispositivo simulada

Obter a cadeia de conexão do Hub IoT

Agendar trabalhos para chamar um método direto e atualizar as propriedades de um gêmeo de dispositivo

Executar as aplicações

Próximos passos

Comentários

Recursos adicionais