Introdução à gestão de dispositivos (Java)

Artigo
05/30/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 as ações de gestão de dispositivos nos dispositivos. Este artigo mostra-lhe como uma aplicação de back-end e uma aplicação de dispositivo podem trabalhar 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 de Hub IoT. Para obter mais informações sobre as camadas de Hub IoT básicas e padrão/gratuitas, consulte Escolher o escalão de Hub IoT adequado 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 comunicadas 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:

simulated-device: uma aplicação de dispositivo simulada com um método direto que reinicia o dispositivo e reporta a última hora de reinício. Os métodos diretos são invocados a partir da cloud.
trigger-reboot: uma aplicação Java que chama o método direto na aplicação de dispositivo simulado através do hub IoT. Apresenta a resposta e as propriedades comunicadas atualizadas.

Nota

Para obter informações sobre os SDKs que pode utilizar para criar aplicações para serem executadas em dispositivos e o back-end da solução, veja SDKs do Azure IoT.

Pré-requisitos

Um hub IoT. Crie uma com a CLI ou a portal do Azure.
Um dispositivo registado. Registe um no portal do Azure.
Java SE Development Kit 8. Certifique-se de que seleciona Java 8 em Suporte de longo prazo para aceder às transferências do JDK 8.
Maven 3
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 resolver este problema, veja Ligar ao Hub IoT (MQTT).

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

Nesta secção, vai criar uma aplicação de consola Java que simula um dispositivo. A aplicação escuta a chamada do método direto de reinício a partir do hub IoT e responde imediatamente a essa chamada. Em seguida, a aplicação fica em suspensão durante algum tempo para simular o processo de reinício antes de utilizar uma propriedade reportada para notificar a aplicação de back-end de reinício do acionador de que o reinício está concluído.

Na pasta dm-get-started , crie um projeto maven denominado simulated-device com o seguinte comando na linha de comandos:

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

Na linha de comandos, navegue para a pasta simulated-device .
Com um editor de texto, abra o ficheiro pom.xml na pasta simulated-device e adicione a seguinte dependência ao nó de dependências . Esta dependência permite-lhe utilizar o pacote iot-service-client na sua aplicação para comunicar com o 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ó de dependências . Esta dependência configura um NOP para a fachada de registo do Apache SLF4J , que é utilizada pelo SDK do cliente do dispositivo para implementar o registo. Esta configuração é opcional, mas, se a omitir, poderá ver um aviso na consola quando executar a aplicação. Para obter mais informações sobre o registo no SDK do cliente do dispositivo, veja Registo nos Exemplos do SDK do dispositivo IoT do Azure para o ficheiro de readme 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ó dependências . Esta configuração instrui o Maven a utilizar o Java 1.8 para criar a aplicação:

<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.
Com um editor de texto, abra o ficheiro 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 ligação do dispositivo que viu quando registou 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 processador de chamadas de retorno para eventos de estado do 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 processador de chamada de retorno para eventos de estado de dispositivo duplo, 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 processador de chamadas de retorno para eventos de propriedades, adicione a seguinte classe aninhada à classe Aplicação :

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 o reinício do dispositivo, adicione a seguinte classe aninhada à classe Aplicação . O thread permanece suspenso durante cinco segundos e, em seguida, define a propriedade reportada lastReboot :

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 direto no dispositivo, adicione a seguinte classe aninhada à classe Aplicação . Quando a aplicação simulada recebe uma chamada para o método direto de reinício , devolve uma confirmação ao autor da chamada e, em seguida, inicia um thread para processar o reinício:

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 pelo seguinte código:

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

Para começar a escutar chamadas de método direto, 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 encerrar o simulador do 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...");

Guarde e feche o ficheiro simulated-device\src\main\java\com\mycompany\app\App.java.
Crie a aplicação simulated-device e corrija quaisquer erros. Na linha de comandos, navegue para a pasta simulated-device e execute o seguinte comando:
```
mvn clean package -DskipTests
```

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, todas as Hub IoT são criadas 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 seu hub na lista de recursos.
No painel do lado 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 políticas e permissões 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 Java que:

Invoca o método direto de reinício na aplicação de dispositivo simulado.
Apresenta a resposta.
Consulta as propriedades comunicadas enviadas a partir do dispositivo para determinar quando o reinício está concluído.

Esta aplicação de consola liga-se ao seu Hub IoT para invocar o método direto e ler as propriedades comunicadas.

Crie uma pasta vazia denominada dm-get-started.

Na pasta dm-get-started , crie um projeto maven chamado trigger-reboot com o seguinte comando na linha de comandos:

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

Na linha de comandos, navegue para a pasta trigger-reboot .
Com um editor de texto, abra o ficheiro pom.xml na pasta trigger-reboot e adicione a seguinte dependência ao nó de dependências . Esta dependência permite-lhe utilizar o pacote iot-service-client na sua aplicação para comunicar com o 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ó dependências . Esta configuração instrui o Maven a utilizar o Java 1.8 para criar a aplicação:

<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.
Com um editor de texto, abra o ficheiro 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 pela {youriothubconnectionstring} cadeia de ligação Hub IoT que copiou anteriormente em Obter a cadeia de ligaçã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 reportadas do dispositivo duplo a cada 10 segundos, adicione a seguinte classe aninhada à classe Aplicação :

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 gerar a seguinte exceção:
```
public static void main(String[] args) throws IOException
```

Para invocar o método direto de reinício 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 consultar as propriedades comunicadas a partir 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 pare a aplicação, 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...");

Guarde e feche o ficheiro trigger-reboot\src\main\java\com\mycompany\app\App.java .
Crie a aplicação back-end trigger-reboot e corrija quaisquer erros. Na linha de comandos, navegue para a pasta trigger-reboot e execute o seguinte comando:
```
mvn clean package -DskipTests
```

Executar as aplicações

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

Numa linha de comandos na pasta simulated-device , execute o seguinte comando para começar a escutar chamadas do método de reinício a partir do seu hub IoT:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Numa linha de comandos na pasta trigger-reboot , execute o seguinte comando para chamar o método de reinício no seu dispositivo simulado a partir do seu hub IoT:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
O dispositivo simulado responde à chamada do método direto 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.

Partilhar via