Wprowadzenie do zarządzania urządzeniami (Java)

• Interfejs wiersza polecenia
• Node.js
• .NET
• Java
• Python

Aplikacje zaplecza mogą używać Azure IoT Hub elementów pierwotnych, 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 IoT Hub.

Uwaga

Funkcje opisane w tym artykule są dostępne tylko w warstwie Standardowa IoT Hub. Aby uzyskać więcej informacji o warstwach podstawowa i Standardowa/Bezpłatna IoT Hub, zobacz Wybieranie odpowiedniej warstwy 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 wysyłanego z 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 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ć następujące elementy:

• simulated-device: symulowana aplikacja urządzenia z metodą bezpośrednią, która ponownie uruchamia urządzenie i zgłasza czas ostatniego ponownego uruchomienia. 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 odpowiedź i zaktualizowane zgłoszone właściwości.

Uwaga

Aby uzyskać informacje na temat zestawów 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 przy użyciu interfejsu wiersza polecenia lub Azure Portal.

• Zarejestrowane urządzenie. Zarejestruj go w Azure Portal.

• Java SE Development Kit 8. Upewnij się, że wybrano środowisko Java 8 w obszarze Długoterminowa pomoc techniczna , aby pobrać zestaw 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 być zablokowany w niektórych środowiskach sieci firmowych i edukacyjnych. Aby uzyskać więcej informacji i sposobów obejścia tego problemu, zobacz Connecting to IoT Hub (MQTT) (Nawiązywanie połączenia z 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 zostanie uśpiona na chwilę, 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.

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

2. W wierszu polecenia przejdź do folderu simulated-device .

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

4. 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 w przypadku pominięcia jej w konsoli może zostać wyświetlone ostrzeżenie podczas uruchamiania aplikacji. Aby uzyskać więcej informacji na temat rejestrowania w zestawie SDK klienta urządzenia, zobacz Rejestrowanie w przykładach 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>
   

5. Dodaj następujący węzeł kompilacji po węźle zależności . Ta konfiguracja instruuje narzędzie Maven, aby skompilował aplikację przy użyciu środowiska Java 1.8:

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

6. Zapisz i zamknij plik pom.xml.

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

8. 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;
   

9. Dodaj następujące zmienne na poziomie klasy do klasy App. Zastąp {yourdeviceconnectionstring} ciąg parametrami połączenia urządzenia, które zostały wyświetlone podczas rejestrowania urządzenia w 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;
   

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

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

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

13. Aby zaimplementować wątek do symulacji ponownego uruchomienia urządzenia, dodaj następującą klasę zagnieżdżonych do klasy App . Wątek śpi 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());
        }
      }
    }
    

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

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

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

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

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

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

19. Zapisz i zamknij plik simulated-device\src\main\java\com\mycompany\app\App.java.

20. Skompiluj aplikację simulated-device i popraw wszelkie błędy. W wierszu polecenia przejdź do folderu simulated-device i uruchom następujące polecenie:

    mvn clean package -DskipTests
    

Pobieranie parametrów 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 IoT Hub, usługa wymaga uprawnienia połączenia z usługą. Domyślnie każda IoT Hub jest tworzona przy użyciu zasad dostępu współdzielonego o nazwie usługa, która przyznaje to uprawnienie.

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

1. W 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.

2. W okienku po lewej stronie centrum IoT hub wybierz pozycję Zasady dostępu współdzielonego.

3. Z listy zasad wybierz zasady usługi .

4. Skopiuj podstawowe parametry połączenia i zapisz wartość.

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

Tworzenie aplikacji usługi w celu wyzwolenia ponownego uruchomienia

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

1. Wywołuje metodę bezpośrednią ponownego rozruchu w aplikacji urządzenia symulowanego.

2. Wyświetla odpowiedź.

3. 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 IoT Hub w celu wywołania metody bezpośredniej i odczytania zgłoszonych właściwości.

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

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

3. W wierszu polecenia przejdź do folderu trigger-reboot .

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

5. Dodaj następujący węzeł kompilacji po węźle zależności . Ta konfiguracja instruuje narzędzie Maven, aby skompilował aplikację przy użyciu środowiska Java 1.8:

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

6. Zapisz i zamknij plik pom.xml.

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

8. 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;
   

9. Dodaj następujące zmienne na poziomie klasy do klasy App. Zastąp wartość {youriothubconnectionstring} parametrami połączenia IoT Hub skopiowanymi wcześniej w sekcji Pobieranie parametrów 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);
   

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

11. Zmodyfikuj podpis metody main , aby zgłosić następujący wyjątek:

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

12. Aby wywołać metodę bezpośrednią ponownego rozruchu na urządzeniu symulowanym, 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());
    }
    

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

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

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

15. Zapisz i zamknij plik trigger-reboot\src\main\java\com\mycompany\app\App.java .

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

1. 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"
   

   

2. W wierszu polecenia w folderze trigger-reboot uruchom następujące polecenie, aby wywołać metodę reboot na symulowanym urządzeniu z centrum IoT:

   mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
   

   

3. Symulowane urządzenie reaguje na wywołanie metody bezpośredniej ponownego rozruchu:

   

Dostosowywanie i rozszerzanie akcji zarządzania urządzeniami

Rozwiązania IoT mogą rozszerzać zdefiniowany zestaw wzorców zarządzania urządzeniami lub włączać niestandardowe wzorce przy użyciu bliźniaczej reprezentacji urządzenia i typów pierwotnych metody chmura-urządzenie. 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 odbierze 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 do potwierdzania zgodności 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ć czas ostatniego ponownego uruchomienia urządzenia z urządzenia i wykonano zapytanie dotyczące bliźniaczej reprezentacji urządzenia w celu odnalezienia czasu ostatniego ponownego uruchomienia urządzenia z chmury.

ToTo continue getting started with IoT Hub and device management patterns such as end-to-end image-based update in Device Update for Azure IoT Hub article using the Raspberry Pi 3 B+ Reference Image (Aby kontynuować rozpoczęcie pracy z wzorcami IoT Hub i zarządzania urządzeniami, takimi jak kompleksowa aktualizacja obrazu opartego na obrazie w usłudze Device Update dla 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ń.