Začínáme se správou zařízení (Java)

Článek
10/01/2024

Back-endové aplikace můžou používat primitiva služby Azure IoT Hub, jako jsou dvojčata zařízení a přímé metody, ke vzdálenému spuštění a monitorování akcí správy zařízení na zařízeních. V tomto článku se dozvíte, jak může back-endová aplikace a aplikace zařízení spolupracovat na zahájení a monitorování vzdáleného restartování zařízení pomocí IoT Hubu.

Poznámka:

Funkce popsané v tomto článku jsou k dispozici pouze na úrovni Standard služby IoT Hub. Další informace o úrovních Služby IoT Hub úrovně Basic a Standard/Free najdete v tématu Volba správné úrovně IoT Hubu pro vaše řešení.

Pomocí přímé metody iniciujte akce správy zařízení (například restartování, obnovení továrního nastavení a aktualizace firmwaru) z back-endové aplikace v cloudu. Zařízení zodpovídá za:

Zpracování požadavku metody odeslaného ze služby IoT Hub
Inicializování odpovídající akce specifické pro zařízení na zařízení
Poskytování aktualizací stavu prostřednictvím ohlášených vlastností do IoT Hubu

Pomocí back-endové aplikace v cloudu můžete spouštět dotazy dvojčete zařízení a hlásit průběh akcí správy zařízení.

V tomto článku se dozvíte, jak vytvořit:

simulated-device: aplikace simulovaného zařízení s přímou metodou, která zařízení restartuje a hlásí čas posledního restartování. Přímé metody se vyvolávají z cloudu.
trigger-reboot: aplikace v Javě, která volá přímou metodu v aplikaci simulovaného zařízení prostřednictvím centra IoT. Zobrazí odpověď a aktualizované ohlášené vlastnosti.

Poznámka:

Informace o sadách SDK, které můžete použít k vytváření aplikací pro spouštění na zařízeních a back-endu vašeho řešení, najdete v sadách SDK Azure IoT.

Požadavky

Centrum IoT ve vašem předplatném Azure Pokud centrum ještě nemáte, můžete postupovat podle kroků v tématu Vytvoření centra IoT.
Zařízení zaregistrované ve službě IoT Hub. Pokud ve službě IoT Hub nemáte zařízení, postupujte podle pokynů v části Registrace zařízení.
Java SE Development Kit 8. Ujistěte se, že v části Dlouhodobá podpora vyberete Javu 8, abyste se dostali ke stažení sady JDK 8.
Maven 3
Ujistěte se, že je v bráně firewall otevřený port 8883. Ukázka zařízení v tomto článku používá protokol MQTT, který komunikuje přes port 8883. Tento port může být blokovaný v některých podnikových a vzdělávacích síťových prostředích. Další informace a způsoby řešení tohoto problému najdete v tématu Připojení ke službě IoT Hub (MQTT).

Vytvoření aplikace zařízení pomocí přímé metody

V této části vytvoříte konzolovou aplikaci Java, která simuluje zařízení. Aplikace naslouchá volání přímé metody restartování z centra IoT a okamžitě odpoví na toto volání. Aplikace pak chvíli přejde do režimu spánku, aby simulovala proces restartování předtím, než použije ohlášenou vlastnost k upozornění back-endové aplikace trigger-reboot , že je restartování dokončeno.

Důležité

Tento článek obsahuje postup připojení zařízení pomocí sdíleného přístupového podpisu, označovaného také jako ověřování symetrického klíče. Tato metoda ověřování je vhodná pro testování a vyhodnocení, ale ověřování zařízení pomocí certifikátů X.509 je bezpečnější přístup. Další informace najdete v tématu Zabezpečení osvědčených postupů > zabezpečení připojení.

Ve složce dm-get-started vytvořte projekt Maven s názvem simulated-device pomocí následujícího příkazu na příkazovém řádku:

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

Na příkazovém řádku přejděte do složky simulated-device .
Pomocí textového editoru otevřete soubor pom.xml ve složce simulovaného zařízení a přidejte do uzlu závislostí následující závislost. Tato závislost umožňuje používat balíček iot-service-client ve vaší aplikaci ke komunikaci s centrem IoT:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-device-client</artifactId>
  <version>1.17.5</version>
</dependency>
```
Poznámka:

Můžete vyhledat nejnovější verzi iot-device-client pomocí vyhledávání Maven.
Do uzlu závislostí přidejte následující závislost. Tato závislost nakonfiguruje NOP pro fasádu protokolování Apache SLF4J , která se používá klientskou sadou SDK zařízení k implementaci protokolování. Tato konfigurace je volitelná, ale pokud ji vynecháte, může se při spuštění aplikace v konzole zobrazit upozornění. Další informace o protokolování v klientské sadě SDK pro zařízení najdete v části Protokolování v ukázkách sady SDK pro zařízení Azure IoT pro soubor Readme v Javě .
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>
```

Za uzel závislostí přidejte následující uzel sestavení. Tato konfigurace dává Mavenu pokyn, aby k sestavení aplikace použil Javu 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>

Uložte a zavřete soubor pom.xml.
Pomocí textového editoru otevřete soubor simulated-device\src\main\java\com\mycompany\app\App.java zdrojový soubor.

Do souboru přidejte následující příkazy pro import:

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;

Do třídy App přidejte následující proměnné na úrovni třídy. Nahraďte {yourdeviceconnectionstring} připojovací řetězec zařízení, které jste viděli při registraci zařízení ve službě 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;

Pokud chcete implementovat obslužnou rutinu zpětného volání pro události stavu přímé metody, přidejte do třídy aplikace následující vnořenou třídu:

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

Pokud chcete implementovat obslužnou rutinu zpětného volání pro události stavu dvojčete zařízení, přidejte do třídy aplikace následující vnořenou třídu:

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

Pokud chcete implementovat obslužnou rutinu zpětného volání pro události vlastností, přidejte do třídy Aplikace následující vnořenou třídu:

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

Pokud chcete implementovat vlákno pro simulaci restartování zařízení, přidejte do třídy Aplikace následující vnořenou třídu. Vlákno přejde do režimu spánku po dobu pěti sekund a pak nastaví poslední hlášenou vlastnost:

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

Pokud chcete na zařízení implementovat přímou metodu, přidejte do třídy App následující vnořenou třídu. Když simulovaná aplikace přijme volání přímé metody restartování , vrátí volajícímu potvrzení a pak spustí vlákno pro zpracování restartování:

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

Upravte podpis hlavní metody tak, aby vyvolal následující výjimky:

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

Pokud chcete vytvořit instanci DeviceClient, nahraďte kód v hlavní metodě následujícím kódem:

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

Pokud chcete začít naslouchat voláním přímé metody, přidejte do hlavní metody následující kód:

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

Pokud chcete simulátor zařízení vypnout, přidejte do hlavní metody následující kód:

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

Uložte a zavřete soubor simulated-device\src\main\java\com\mycompany\app\App.java.
Sestavte aplikaci simulovaného zařízení a opravte případné chyby. Na příkazovém řádku přejděte do složky simulated-device a spusťte následující příkaz:
```
mvn clean package -DskipTests
```

Získání připojovací řetězec centra IoT

V tomto článku vytvoříte back-endovou službu, která vyvolá přímou metodu na zařízení. K vyvolání přímé metody na zařízení prostřednictvím IoT Hubu potřebuje vaše služba oprávnění k připojení ke službě. Ve výchozím nastavení se každá služba IoT Hub vytvoří pomocí zásady sdíleného přístupu s názvem služby , která toto oprávnění uděluje.

Pokud chcete získat připojovací řetězec ioT Hubu pro zásady služby, postupujte takto:

Na webu Azure Portal vyberte skupiny prostředků. Vyberte skupinu prostředků, ve které se nachází vaše centrum, a pak vyberte centrum ze seznamu prostředků.
V levém podokně centra IoT vyberte zásady sdíleného přístupu.
V seznamu zásad vyberte zásadu služby .
Zkopírujte primární připojovací řetězec a uložte hodnotu.

Další informace ozásadách

Vytvoření aplikace služby pro aktivaci restartování

V této části vytvoříte konzolovou aplikaci Java, která:

Vyvolá přímou metodu restartování v aplikaci simulovaného zařízení.
Zobrazí odpověď.
Dotazuje ohlášené vlastnosti odeslané ze zařízení a určí, kdy je restartování dokončeno.

Důležité

Tento článek obsahuje postup připojení ke službě pomocí sdíleného přístupového podpisu. Tato metoda ověřování je vhodná pro testování a vyhodnocení, ale ověřování ve službě pomocí MICROSOFT Entra ID nebo spravovaných identit je bezpečnější přístup. Další informace najdete v tématu Osvědčené postupy > zabezpečení cloudu.

Tato konzolová aplikace se připojí k ioT Hubu, aby vyvolala přímou metodu a přečetla ohlášené vlastnosti.

Vytvořte prázdnou složku s názvem dm-get-started.

Ve složce dm-get-started vytvořte projekt Maven s názvem trigger-reboot pomocí následujícího příkazu na příkazovém řádku:

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

Na příkazovém řádku přejděte do složky trigger-reboot .
Pomocí textového editoru otevřete soubor pom.xml ve složce trigger-reboot a přidejte do uzlu závislostí následující závislost. Tato závislost umožňuje používat balíček iot-service-client ve vaší aplikaci ke komunikaci s centrem IoT:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.17.1</version>
  <type>jar</type>
</dependency>
```
Poznámka:

Můžete vyhledat nejnovější verzi iot-service-client pomocí vyhledávání Maven.

Za uzel závislostí přidejte následující uzel sestavení. Tato konfigurace dává Mavenu pokyn, aby k sestavení aplikace použil Javu 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>

Uložte a zavřete soubor pom.xml.
V textovém editoru otevřete soubor trigger-reboot\src\main\java\com\mycompany\app\App.java zdrojový soubor.

Do souboru přidejte následující příkazy pro import:

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;

Do třídy App přidejte následující proměnné na úrovni třídy. Nahraďte {youriothubconnectionstring} připojovací řetězec IoT Hub, který jste zkopírovali dříve v připojovací řetězec Get the IoT Hub:

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

Pokud chcete implementovat vlákno, které čte ohlášené vlastnosti z dvojčete zařízení každých 10 sekund, přidejte do třídy aplikace následující vnořenou třídu:

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

Upravte podpis hlavní metody tak, aby vyvolal následující výjimku:
```
public static void main(String[] args) throws IOException
```

Pokud chcete vyvolat přímou metodu restartování na simulovaném zařízení, nahraďte kód v hlavní metodě následujícím kódem:

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

Pokud chcete spustit vlákno pro dotazování ohlášených vlastností ze simulovaného zařízení, přidejte do hlavní metody následující kód:

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

Pokud chcete aplikaci zastavit, přidejte do hlavní metody následující kód:

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

Uložte a zavřete soubor trigger-reboot\src\main\java\com\mycompany\app\App.java .
Sestavte back-endovou aplikaci triggeru a opravte případné chyby. Na příkazovém řádku přejděte do složky trigger-reboot a spusťte následující příkaz:
```
mvn clean package -DskipTests
```

Spouštění aplikací

Teď jste připraveni spustit aplikace.

Na příkazovém řádku ve složce simulated-device spusťte následující příkaz, který začne naslouchat volání metod restartování z vašeho IoT Hubu:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Na příkazovém řádku ve složce trigger-reboot spusťte následující příkaz, který zavolá metodu restartování na simulovaném zařízení ze služby IoT Hub:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Simulované zařízení reaguje na volání přímé metody restartování:

Přizpůsobení a rozšíření akcí správy zařízení

Vaše řešení IoT můžou rozšířit definovanou sadu vzorů správy zařízení nebo povolit vlastní vzory pomocí dvojčat zařízení a primitiv metod cloud-zařízení. Mezi další příklady akcí správy zařízení patří obnovení továrního nastavení, aktualizace firmwaru, aktualizace softwaru, řízení spotřeby, správa sítě a připojení a šifrování dat.

Časové období údržby zařízení

Obvykle konfigurujete zařízení tak, aby prováděla akce, které minimalizují přerušení a výpadky. Časové intervaly údržby zařízení se běžně používají k definování času, kdy má zařízení aktualizovat konfiguraci. Back-endová řešení můžou pomocí požadovaných vlastností dvojčete zařízení definovat a aktivovat zásadu na vašem zařízení, která umožňuje časové období údržby. Když zařízení obdrží zásadu časového období údržby, může pomocí ohlášené vlastnosti dvojčete zařízení nahlásit stav zásady. Back-endová aplikace pak může pomocí dotazů dvojčete zařízení otestovat dodržování předpisů u zařízení a jednotlivých zásad.

Další kroky

V tomto článku jste použili přímou metodu k aktivaci vzdáleného restartování zařízení. Pomocí ohlášených vlastností jste nahlásili čas posledního restartování ze zařízení a dotazovali jste se na dvojče zařízení, abyste zjistili čas posledního restartování zařízení z cloudu.

Pokud chcete pokračovat v začátcích se vzory správy ioT Hubu a zařízení, jako jsou kompletní aktualizace založené na imagích ve službě Device Update pro Azure IoT Hub, použijte referenční image Raspberry Pi 3 B+.

Informace o rozšíření řešení IoT a plánování volání metod na více zařízeních najdete v tématu Úlohy plánování a vysílání.

Sdílet prostřednictvím