Wprowadzenie do zarządzania urządzeniami (Java)

Artykuł
06/20/2024

Aplikacje zaplecza mogą używać elementów pierwotnych usługi Azure IoT Hub, takich jak bliźniacze reprezentacje urządzeń i metody bezpośrednie, do zdalnego uruchamiania i monitorowania akcji zarządzania urządzeniami na urządzeniach. W tym artykule pokazano, jak aplikacja zaplecza i aplikacja urządzenia mogą współpracować w celu zainicjowania i monitorowania ponownego uruchomienia urządzenia zdalnego przy użyciu usługi IoT Hub.

Uwaga

Funkcje opisane w tym artykule są dostępne tylko w warstwie Standardowa usługi IoT Hub. Aby uzyskać więcej informacji na temat warstw podstawowej i standardowej/bezpłatnej usługi IoT Hub, zobacz Wybieranie odpowiedniej warstwy usługi IoT Hub dla rozwiązania.

Użyj metody bezpośredniej, aby zainicjować akcje zarządzania urządzeniami (takie jak ponowny rozruch, resetowanie do ustawień fabrycznych i aktualizacja oprogramowania układowego) z poziomu aplikacji zaplecza w chmurze. Urządzenie jest odpowiedzialne za:

Obsługa żądania metody wysłanego z usługi IoT Hub.
Inicjowanie odpowiedniej akcji specyficznej dla urządzenia na urządzeniu.
Dostarczanie aktualizacji stanu za pośrednictwem zgłoszonych właściwości do usługi IoT Hub.

Aplikację zaplecza w chmurze można użyć do uruchamiania zapytań bliźniaczych reprezentacji urządzenia w celu raportowania postępu akcji zarządzania urządzeniami.

W tym artykule pokazano, jak utworzyć:

simulated-device: symulowana aplikacja urządzenia z metodą bezpośrednią, która ponownie uruchamia urządzenie i zgłasza czas ostatniego ponownego rozruchu. Metody bezpośrednie są wywoływane z chmury.
trigger-reboot: aplikacja Java, która wywołuje metodę bezpośrednią w aplikacji urządzenia symulowanego za pośrednictwem centrum IoT. Wyświetla on odpowiedź i zaktualizowane zgłoszone właściwości.

Uwaga

Aby uzyskać informacje o zestawach SDK, których można użyć do tworzenia aplikacji do uruchamiania na urządzeniach i zapleczu rozwiązania, zobacz Zestawy SDK usługi Azure IoT.

Wymagania wstępne

Centrum IoT. Utwórz go za pomocą interfejsu wiersza polecenia lub witryny Azure Portal.
Urządzenie zarejestrowane w centrum IoT Hub. Jeśli nie masz urządzenia w centrum IoT Hub, wykonaj kroki opisane w temacie Rejestrowanie urządzenia.
Java SE Development Kit 8. Upewnij się, że wybrano środowisko Java 8 w obszarze Obsługa długoterminowa , aby pobrać plik JDK 8.
Maven 3
Upewnij się, że port 8883 jest otwarty w zaporze. Przykład urządzenia w tym artykule używa protokołu MQTT, który komunikuje się za pośrednictwem portu 8883. Ten port może zostać zablokowany w niektórych środowiskach sieci firmowych i edukacyjnych. Aby uzyskać więcej informacji i sposobów obejścia tego problemu, zobacz Nawiązywanie połączenia z usługą IoT Hub (MQTT).

Tworzenie aplikacji urządzenia przy użyciu metody bezpośredniej

W tej sekcji utworzysz aplikację konsolową Java, która symuluje urządzenie. Aplikacja nasłuchuje wywołania metody bezpośredniej ponownego rozruchu z centrum IoT i natychmiast odpowiada na to wywołanie. Następnie aplikacja jest w stanie uśpienia przez pewien czas, aby zasymulować proces ponownego uruchamiania przed użyciem zgłaszanej właściwości w celu powiadomienia aplikacji zaplecza wyzwalacza ponownego rozruchu o zakończeniu ponownego rozruchu .

W folderze dm-get-started utwórz projekt Maven o nazwie simulated-device przy użyciu następującego polecenia w wierszu polecenia:

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

W wierszu polecenia przejdź do folderu simulated-device .
Za pomocą edytora tekstów otwórz plik pom.xml w folderze simulated-device i dodaj następującą zależność do węzła zależności . Ta zależność umożliwia używanie pakietu iot-service-client w aplikacji do komunikowania się z centrum IoT:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-device-client</artifactId>
  <version>1.17.5</version>
</dependency>
```
Uwaga

Możesz sprawdzić dostępność najnowszej wersji pakietu iot-device-client za pomocą funkcji wyszukiwania narzędzia Maven.
Dodaj następującą zależność do węzła zależności . Ta zależność konfiguruje NOP dla fasady rejestrowania Apache SLF4J , która jest używana przez zestaw SDK klienta urządzenia do implementowania rejestrowania. Ta konfiguracja jest opcjonalna, ale jeśli ją pominięto, po uruchomieniu aplikacji może zostać wyświetlone ostrzeżenie w konsoli programu . Aby uzyskać więcej informacji na temat rejestrowania w zestawie SDK klienta urządzenia, zobacz Rejestrowanie w przykładach dla zestawu SDK urządzenia Azure IoT dla pliku readme języka Java .
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>
```

Dodaj następujący węzeł kompilacji po węźle zależności . Ta konfiguracja nakazuje narzędziu Maven użycie środowiska Java 1.8 do skompilowania aplikacji:

<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>

Zapisz i zamknij plik pom.xml.
Za pomocą edytora tekstów otwórz plik źródłowy simulated-device\src\main\java\com\mycompany\app\App.java .

Dodaj do pliku następujące instrukcje importowania:

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;

Dodaj następujące zmienne na poziomie klasy do klasy App. Zastąp {yourdeviceconnectionstring} element urządzeniem parametry połączenia, który został wyświetlony podczas rejestrowania urządzenia w usłudze IoT Hub:

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;

Aby zaimplementować procedurę obsługi wywołania zwrotnego dla zdarzeń stanu metody bezpośredniej, dodaj następującą klasę zagnieżdżoną do klasy 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());
  }
}

Aby zaimplementować procedurę obsługi wywołania zwrotnego dla zdarzeń stanu bliźniaczej reprezentacji urządzenia, dodaj następującą klasę zagnieżdżoną do klasy 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());
    }
}

Aby zaimplementować procedurę obsługi wywołania zwrotnego dla zdarzeń właściwości, dodaj następującą klasę zagnieżdżoną do klasy 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);
  }
}

Aby zaimplementować wątek w celu symulowania ponownego uruchomienia urządzenia, dodaj następującą klasę zagnieżdżonych do klasy App . Wątek jest w trybie uśpienia przez pięć sekund, a następnie ustawia ostatnią zgłoszoną właściwośćReboot :

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

Aby zaimplementować metodę bezpośrednią na urządzeniu, dodaj następującą klasę zagnieżdżonych do klasy App . Gdy symulowana aplikacja odbiera wywołanie metody bezpośredniej ponownego rozruchu, zwraca potwierdzenie do wywołującego, a następnie uruchamia wątek w celu przetworzenia ponownego uruchomienia:

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

Zmodyfikuj podpis metody main , aby zgłosić następujące wyjątki:

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

Aby utworzyć wystąpienie klasy DeviceClient, zastąp kod w metodzie main następującym kodem:

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

Aby rozpocząć nasłuchiwanie wywołań metod bezpośrednich, dodaj następujący kod do metody main :

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

Aby zamknąć symulator urządzenia, dodaj następujący kod do metody main :

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

Zapisz i zamknij plik simulated-device\src\main\java\com\mycompany\app\App.java.
Skompiluj aplikację symulowanego urządzenia i popraw wszelkie błędy. W wierszu polecenia przejdź do folderu simulated-device i uruchom następujące polecenie:
```
mvn clean package -DskipTests
```

Pobieranie parametry połączenia centrum IoT

W tym artykule utworzysz usługę zaplecza, która wywołuje metodę bezpośrednią na urządzeniu. Aby wywołać metodę bezpośrednią na urządzeniu za pośrednictwem usługi IoT Hub, usługa wymaga uprawnień połączenia z usługą. Domyślnie każde centrum IoT Hub jest tworzone przy użyciu zasad dostępu współdzielonego o nazwie usługa , która przyznaje to uprawnienie.

Aby uzyskać parametry połączenia usługi IoT Hub dla zasad usługi, wykonaj następujące kroki:

W witrynie Azure Portal wybierz pozycję Grupy zasobów. Wybierz grupę zasobów, w której znajduje się centrum, a następnie wybierz centrum z listy zasobów.
W okienku po lewej stronie centrum IoT hub wybierz pozycję Zasady dostępu współdzielonego.
Z listy zasad wybierz zasady usługi .
Skopiuj parametry połączenia podstawową i zapisz wartość.

Aby uzyskać więcej informacji na temat zasad dostępu współdzielonego i uprawnień usługi IoT Hub, zobacz Kontrola dostępu i uprawnienia.

Tworzenie aplikacji usługi w celu wyzwolenia ponownego uruchomienia

W tej sekcji utworzysz aplikację konsolową Java, która:

Wywołuje metodę bezpośrednią ponownego rozruchu w aplikacji urządzenia symulowanego.
Wyświetla odpowiedź.
Sonduje zgłoszone właściwości wysyłane z urządzenia, aby określić, kiedy ponowny rozruch zostanie ukończony.

Ta aplikacja konsolowa łączy się z usługą IoT Hub w celu wywołania metody bezpośredniej i odczytania zgłoszonych właściwości.

Utwórz pusty folder o nazwie dm-get-started.

W folderze dm-get-started utwórz projekt Maven o nazwie trigger-reboot przy użyciu następującego polecenia w wierszu polecenia:

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

W wierszu polecenia przejdź do folderu trigger-reboot .
Za pomocą edytora tekstów otwórz plik pom.xml w folderze trigger-reboot i dodaj następującą zależność do węzła zależności . Ta zależność umożliwia używanie pakietu iot-service-client w aplikacji do komunikowania się z centrum IoT:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.17.1</version>
  <type>jar</type>
</dependency>
```
Uwaga

Możesz sprawdzić dostępność najnowszej wersji pakietu iot-service-client za pomocą funkcji wyszukiwania narzędzia Maven.

Dodaj następujący węzeł kompilacji po węźle zależności . Ta konfiguracja nakazuje narzędziu Maven użycie środowiska Java 1.8 do skompilowania aplikacji:

<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>

Zapisz i zamknij plik pom.xml.
Za pomocą edytora tekstów otwórz plik źródłowy trigger-reboot\src\main\java\com\mycompany\app\App.java .

Dodaj do pliku następujące instrukcje importowania:

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;

Dodaj następujące zmienne na poziomie klasy do klasy App. Zastąp element {youriothubconnectionstring} parametry połączenia usługi IoT Hub skopiowanym wcześniej w sekcji Pobieranie parametry połączenia centrum 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);

Aby zaimplementować wątek odczytujący zgłoszone właściwości z bliźniaczej reprezentacji urządzenia co 10 sekund, dodaj następującą klasę zagnieżdżoną do klasy 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());
    }
  }
}

Zmodyfikuj podpis metody main , aby zgłosić następujący wyjątek:
```
public static void main(String[] args) throws IOException
```

Aby wywołać metodę bezpośrednią ponownego rozruchu na symulowanym urządzeniu, zastąp kod w metodzie main następującym kodem:

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

Aby rozpocząć wątek sondowania zgłoszonych właściwości z symulowanego urządzenia, dodaj następujący kod do metody main :

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

Aby umożliwić zatrzymanie aplikacji, dodaj następujący kod do metody main :

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

Zapisz i zamknij plik trigger-reboot\src\main\java\com\mycompany\app\App.java .
Skompiluj aplikację zaplecza wyzwalacza ponownego rozruchu i popraw wszelkie błędy. W wierszu polecenia przejdź do folderu trigger-reboot i uruchom następujące polecenie:
```
mvn clean package -DskipTests
```

Uruchamianie aplikacji

Teraz możesz przystąpić do uruchamiania aplikacji.

W wierszu polecenia w folderze simulated-device uruchom następujące polecenie, aby rozpocząć nasłuchiwanie wywołań metody ponownego rozruchu z centrum IoT:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
W wierszu polecenia w folderze trigger-reboot uruchom następujące polecenie, aby wywołać metodę ponownego rozruchu na urządzeniu symulowanym z centrum IoT:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Symulowane urządzenie reaguje na wywołanie metody bezpośredniej ponownego rozruchu:

Dostosowywanie i rozszerzanie akcji zarządzania urządzeniami

Twoje rozwiązania IoT mogą rozszerzać zdefiniowany zestaw wzorców zarządzania urządzeniami lub włączać wzorce niestandardowe przy użyciu bliźniaczej reprezentacji urządzenia i typów pierwotnych metody chmury do urządzenia. Inne przykłady akcji zarządzania urządzeniami obejmują resetowanie do ustawień fabrycznych, aktualizację oprogramowania, aktualizację oprogramowania, zarządzanie energią, zarządzanie siecią i łącznością oraz szyfrowanie danych.

Okna obsługi urządzenia

Zazwyczaj urządzenia są konfigurowane do wykonywania akcji w czasie, co minimalizuje przerwy i przestoje. Okna obsługi urządzeń są często używanym wzorcem do definiowania czasu aktualizacji konfiguracji urządzenia. Rozwiązania zaplecza mogą używać żądanych właściwości bliźniaczej reprezentacji urządzenia do definiowania i aktywowania zasad na urządzeniu, które umożliwiają okno obsługi. Gdy urządzenie odbiera zasady okna obsługi, może użyć zgłaszanej właściwości bliźniaczej reprezentacji urządzenia, aby zgłosić stan zasad. Aplikacja zaplecza może następnie używać zapytań bliźniaczych reprezentacji urządzenia, aby potwierdzić zgodność urządzeń i poszczególnych zasad.

Następne kroki

W tym artykule użyto metody bezpośredniej do wyzwolenia zdalnego ponownego rozruchu na urządzeniu. Użyto zgłoszonych właściwości, aby zgłosić ostatni czas ponownego rozruchu z urządzenia i wykonano zapytanie dotyczące bliźniaczej reprezentacji urządzenia w celu odnalezienia czasu ostatniego ponownego uruchomienia urządzenia z chmury.

Aby kontynuować rozpoczynanie pracy z usługą IoT Hub i wzorcami zarządzania urządzeniami, takimi jak kompleksowa aktualizacja obrazu oparta na obrazach w artykule Device Update for Azure IoT Hub using the Raspberry Pi 3 B+ Reference Image (Aktualizacja urządzenia dla usługi Azure IoT Hub przy użyciu obrazu referencyjnego urządzenia Raspberry Pi 3 B+).

Aby dowiedzieć się, jak rozszerzyć rozwiązanie IoT i zaplanować wywołania metod na wielu urządzeniach, zobacz Planowanie i emisja zadań.

Udostępnij za pośrednictwem