Introdução ao gerenciamento de dispositivos (Java)

Artigo
10/01/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:

Simulated-Device: 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.
trigger-reboot: um aplicativo Java que chama o método direct no aplicativo de dispositivo simulado por meio de seu hub IoT. Ele exibe a resposta e as propriedades relatadas atualizadas.

Nota

Para obter informações sobre os SDKs que você pode usar para criar aplicativos para execução em dispositivos e o back-end da solução, consulte Azure IoT SDKs.

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.
Kit de Desenvolvimento Java SE 8. Certifique-se de selecionar Java 8 em Suporte de longo prazo para obter downloads para JDK 8.
Maven 3
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 seção, você cria um aplicativo de console Java que simula um dispositivo. O aplicativo escuta a chamada do método direto de reinicialização do seu hub IoT e responde imediatamente a essa chamada. Em seguida, o aplicativo dorme por um tempo para simular o processo de reinicialização antes de usar uma propriedade relatada para notificar o aplicativo back-end trigger-reboot de que a reinicialização foi concluída.

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.

Na pasta dm-get-started, crie um projeto Maven chamado simulated-device usando o seguinte comando no prompt de comando:

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=simulated-device -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

No prompt de comando, navegue até a pasta de dispositivo simulado.
Usando um editor de texto, abra o arquivo pom.xml na pasta simulated-device e adicione a seguinte dependência ao nó dependencies . Essa dependência permite que você use o pacote iot-service-client em seu aplicativo para se comunicar com seu hub IoT:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-device-client</artifactId>
  <version>1.17.5</version>
</dependency>
```
Nota

Pode verificar a versão mais recente do iot-device-client utilizando a pesquisa Maven.
Adicione a seguinte dependência ao nó dependências . Essa dependência configura um NOP para a fachada de log Apache SLF4J , que é usada pelo SDK do cliente de dispositivo para implementar o registro. Essa configuração é opcional, mas, se você omiti-la, poderá ver um aviso no console quando executar o aplicativo. Para obter mais informações sobre como registrar no SDK do cliente de dispositivo, consulte Registrando os exemplos para o arquivo Leiame do SDK do dispositivo IoT do Azure para Java .
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>
```

Adicione o seguinte nó de compilação após o nó de dependências . Essa configuração instrui o Maven a usar o Java 1.8 para construir o aplicativo:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.3</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Guarde e feche o ficheiro pom.xml.
Usando um editor de texto, abra o arquivo de origem simulated-device\src\main\java\com\mycompany\app\App.java .

Adicione as seguintes declarações de importação ao ficheiro:

import com.microsoft.azure.sdk.iot.device.*;
import com.microsoft.azure.sdk.iot.device.DeviceTwin.*;

import java.io.IOException;
import java.net.URISyntaxException;
import java.time.LocalDateTime;
import java.util.Scanner;
import java.util.Set;
import java.util.HashSet;

Adicione as seguintes variáveis de nível de classe à classe Aplicação. Substitua {yourdeviceconnectionstring} pela cadeia de conexão de dispositivo que você viu quando registrou um dispositivo no Hub IoT:

private static final int METHOD_SUCCESS = 200;
private static final int METHOD_NOT_DEFINED = 404;

private static IotHubClientProtocol protocol = IotHubClientProtocol.MQTT;
private static String connString = "{yourdeviceconnectionstring}";
private static DeviceClient client;

Para implementar um manipulador de retorno de chamada para eventos de status de método direto, adicione a seguinte classe aninhada à classe App :

protected static class DirectMethodStatusCallback implements IotHubEventCallback
{
  public void execute(IotHubStatusCode status, Object context)
  {
    System.out.println("IoT Hub responded to device method operation with status " + status.name());
  }
}

Para implementar um manipulador de retorno de chamada para eventos de status de gêmeos de dispositivo, adicione a seguinte classe aninhada à classe App :

protected static class DeviceTwinStatusCallback implements IotHubEventCallback
{
    public void execute(IotHubStatusCode status, Object context)
    {
        System.out.println("IoT Hub responded to device twin operation with status " + status.name());
    }
}

Para implementar um manipulador de retorno de chamada para eventos de propriedade, adicione a seguinte classe aninhada à classe App :

protected static class PropertyCallback implements PropertyCallBack<String, String>
{
  public void PropertyCall(String propertyKey, String propertyValue, Object context)
  {
    System.out.println("PropertyKey:     " + propertyKey);
    System.out.println("PropertyKvalue:  " + propertyKey);
  }
}

Para implementar um thread para simular a reinicialização do dispositivo, adicione a seguinte classe aninhada à classe App . O thread suspende por cinco segundos e, em seguida, define a propriedade lastReboot reported:

protected static class RebootDeviceThread implements Runnable {
  public void run() {
    try {
      System.out.println("Rebooting...");
      Thread.sleep(5000);
      Property property = new Property("lastReboot", LocalDateTime.now());
      Set<Property> properties = new HashSet<Property>();
      properties.add(property);
      client.sendReportedProperties(properties);
      System.out.println("Rebooted");
    }
    catch (Exception ex) {
      System.out.println("Exception in reboot thread: " + ex.getMessage());
    }
  }
}

Para implementar o método direct no dispositivo, adicione a seguinte classe aninhada à classe App . Quando o aplicativo simulado recebe uma chamada para o método direto de reinicialização , ele retorna uma confirmação para o chamador e, em seguida, inicia um thread para processar a reinicialização:

protected static class DirectMethodCallback implements com.microsoft.azure.sdk.iot.device.DeviceTwin.DeviceMethodCallback
{
  @Override
  public DeviceMethodData call(String methodName, Object methodData, Object context)
  {
    DeviceMethodData deviceMethodData;
    switch (methodName)
    {
      case "reboot" :
      {
        int status = METHOD_SUCCESS;
        System.out.println("Received reboot request");
        deviceMethodData = new DeviceMethodData(status, "Started reboot");
        RebootDeviceThread rebootThread = new RebootDeviceThread();
        Thread t = new Thread(rebootThread);
        t.start();
        break;
      }
      default:
      {
        int status = METHOD_NOT_DEFINED;
        deviceMethodData = new DeviceMethodData(status, "Not defined direct method " + methodName);
      }
    }
    return deviceMethodData;
  }
}

Modifique a assinatura do método principal para lançar as seguintes exceções:

public static void main(String[] args) throws IOException, URISyntaxException

Para instanciar um DeviceClient, substitua o código no método principal com o seguinte código:

System.out.println("Starting device client sample...");
client = new DeviceClient(connString, protocol);

Para começar a escutar chamadas diretas de método, adicione o seguinte código ao método principal :

try
{
  client.open();
  client.subscribeToDeviceMethod(new DirectMethodCallback(), null, new DirectMethodStatusCallback(), null);
  client.startDeviceTwin(new DeviceTwinStatusCallback(), null, new PropertyCallback(), null);
  System.out.println("Subscribed to direct methods and polling for reported properties. Waiting...");
}
catch (Exception e)
{
  System.out.println("On exception, shutting down \n" + " Cause: " + e.getCause() + " \n" +  e.getMessage());
  client.close();
  System.out.println("Shutting down...");
}

Para desligar o simulador de dispositivo, adicione o seguinte código ao método principal :

System.out.println("Press any key to exit...");
Scanner scanner = new Scanner(System.in);
scanner.nextLine();
scanner.close();
client.close();
System.out.println("Shutting down...");

Salve e feche o arquivo simulated-device\src\main\java\com\mycompany\app\App.java.
Crie o aplicativo de dispositivo simulado e corrija quaisquer erros. No prompt de comando, navegue até a pasta simulated-device e execute o seguinte comando:
```
mvn clean package -DskipTests
```

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 Java que:

Invoca o método direto de reinicialização no aplicativo de dispositivo simulado.
Exibe a resposta.
Sonda as propriedades relatadas enviadas do dispositivo para determinar quando a reinicialização é concluída.

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.

Este aplicativo de console se conecta ao seu Hub IoT para invocar o método direto e ler as propriedades relatadas.

Crie uma pasta vazia chamada dm-get-started.

Na pasta dm-get-started, crie um projeto Maven chamado trigger-reboot usando o seguinte comando no prompt de comando:

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=trigger-reboot -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

No prompt de comando, navegue até a pasta trigger-reboot .
Usando um editor de texto, abra o arquivo pom.xml na pasta trigger-reboot e adicione a seguinte dependência ao nó dependencies . Essa dependência permite que você use o pacote iot-service-client em seu aplicativo para se comunicar com seu hub IoT:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.17.1</version>
  <type>jar</type>
</dependency>
```
Nota

Pode verificar a versão mais recente do iot-service-client utilizando a pesquisa Maven.

Adicione o seguinte nó de compilação após o nó de dependências . Essa configuração instrui o Maven a usar o Java 1.8 para construir o aplicativo:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.3</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Guarde e feche o ficheiro pom.xml.
Usando um editor de texto, abra o arquivo de origem trigger-reboot\src\main\java\com\mycompany\app\App.java .

Adicione as seguintes declarações de importação ao ficheiro:

import com.microsoft.azure.sdk.iot.service.devicetwin.DeviceMethod;
import com.microsoft.azure.sdk.iot.service.devicetwin.MethodResult;
import com.microsoft.azure.sdk.iot.service.exceptions.IotHubException;
import com.microsoft.azure.sdk.iot.service.devicetwin.DeviceTwin;
import com.microsoft.azure.sdk.iot.service.devicetwin.DeviceTwinDevice;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

Adicione as seguintes variáveis de nível de classe à classe Aplicação. Substitua {youriothubconnectionstring} pela cadeia de conexão do Hub IoT copiada anteriormente em Obter a cadeia de conexão do hub IoT:

public static final String iotHubConnectionString = "{youriothubconnectionstring}";
public static final String deviceId = "myDeviceId";

private static final String methodName = "reboot";
private static final Long responseTimeout = TimeUnit.SECONDS.toSeconds(30);
private static final Long connectTimeout = TimeUnit.SECONDS.toSeconds(5);

Para implementar um thread que lê as propriedades relatadas do gêmeo do dispositivo a cada 10 segundos, adicione a seguinte classe aninhada à classe App :

private static class ShowReportedProperties implements Runnable {
  public void run() {
    try {
      DeviceTwin deviceTwins = DeviceTwin.createFromConnectionString(iotHubConnectionString);
      DeviceTwinDevice twinDevice = new DeviceTwinDevice(deviceId);
      while (true) {
        System.out.println("Get reported properties from device twin");
        deviceTwins.getTwin(twinDevice);
        System.out.println(twinDevice.reportedPropertiesToString());
        Thread.sleep(10000);
      }
    } catch (Exception ex) {
      System.out.println("Exception reading reported properties: " + ex.getMessage());
    }
  }
}

Modifique a assinatura do método principal para lançar a seguinte exceção:
```
public static void main(String[] args) throws IOException
```

Para invocar o método direto de reinicialização no dispositivo simulado, substitua o código no método principal pelo seguinte código:

System.out.println("Starting sample...");
DeviceMethod methodClient = DeviceMethod.createFromConnectionString(iotHubConnectionString);

try
{
  System.out.println("Invoke reboot direct method");
  MethodResult result = methodClient.invoke(deviceId, methodName, responseTimeout, connectTimeout, null);

  if(result == null)
  {
    throw new IOException("Invoke direct method reboot returns null");
  }
  System.out.println("Invoked reboot on device");
  System.out.println("Status for device:   " + result.getStatus());
  System.out.println("Message from device: " + result.getPayload());
}
catch (IotHubException e)
{
    System.out.println(e.getMessage());
}

Para iniciar o thread para sondar as propriedades relatadas do dispositivo simulado, adicione o seguinte código ao método principal :

ShowReportedProperties showReportedProperties = new ShowReportedProperties();
ExecutorService executor = Executors.newFixedThreadPool(1);
executor.execute(showReportedProperties);

Para permitir que você pare o aplicativo, adicione o seguinte código ao método principal :

System.out.println("Press ENTER to exit.");
System.in.read();
executor.shutdownNow();
System.out.println("Shutting down sample...");

Salve e feche o arquivo trigger-reboot\src\main\java\com\mycompany\app\App.java .
Crie o aplicativo back-end trigger-reboot e corrija quaisquer erros. No prompt de comando, navegue até a pasta trigger-reboot e execute o seguinte comando:
```
mvn clean package -DskipTests
```

Executar as aplicações

Agora você está pronto para executar os aplicativos.

Em um prompt de comando na pasta simulated-device , execute o seguinte comando para começar a ouvir chamadas de método de reinicialização do seu hub IoT:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Em um prompt de comando na pasta trigger-reboot , execute o seguinte comando para chamar o método de reinicialização em seu dispositivo simulado a partir do hub IoT:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
O dispositivo simulado responde à chamada do método direto 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.

Para 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