Share via

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

  • Článek

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

Poznámka

Funkce popsané v tomto článku jsou dostupné jenom na standardní úrovni IoT Hub. Další informace o IoT Hub úrovně Basic a Standard/Free najdete v tématu Volba správné IoT Hub úrovně pro vaše řešení.

Použijte přímou metodu k zahájení akcí správy zařízení (jako je 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 z 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í IoT Hub.

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 volají z cloudu.

  • trigger-reboot: Aplikace v Javě, která volá přímou metodu v aplikaci simulovaného zařízení prostřednictvím služby IoT Hub. Zobrazí odpověď a aktualizuje 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 řešení, najdete v tématu Sady SDK Azure IoT.

Požadavky

  • IoT Hub. Vytvořte ho pomocí rozhraní příkazového řádku nebo Azure Portal.

  • Registrované zařízení. Zaregistrujte si ho v Azure Portal.

  • Java SE Development Kit 8. Ujistěte se, že jste v části Dlouhodobá podpora vybrali Java 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 v některých podnikových a vzdělávacích síťových prostředích blokovaný. Další informace a způsoby, jak tento problém obejít, najdete v tématu Připojení k 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 vašeho centra IoT a okamžitě na toto volání reaguje. Aplikace pak na chvíli přejde do režimu spánku, aby si simulovala proces restartování, než použije ohlášenou vlastnost k oznámení back-endové aplikaci trigger-reboot , že restartování bylo dokončeno.

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

  2. Na příkazovém řádku přejděte do složky simulated-device .

  3. Pomocí textového editoru otevřete souborpom.xml ve složce simulated-device a přidejte do uzlu dependencies následující závislost. Tato závislost umožňuje použít balíček iot-service-client ve vaší aplikaci ke komunikaci se službou IoT Hub:

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

  4. Do uzlu závislostí přidejte následující závislost. Tato závislost konfiguruje NOP pro fasádu protokolování Apache SLF4J , kterou používá klientská sada 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 sadě SDK klienta zařízení najdete v tématu Protokolování v ukázkách souboru Readme sady SDK pro zařízení Azure IoT pro Javu .

    <dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>

  5. Přidejte následující uzel sestavení za uzel závislostí . 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>

  6. Uložte a zavřete soubor pom.xml.

  7. V textovém editoru otevřete zdrojový soubor simulated-device\src\main\java\com\mycompany\app\App.java .

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

  9. Do třídy App přidejte následující proměnné na úrovni třídy. Nahraďte {yourdeviceconnectionstring} připojovacím řetězcem zařízení, který jste viděli při registraci zařízení v 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. Pokud chcete implementovat obslužnou rutinu zpětného volání pro události stavu přímé metody, přidejte do třídy App 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());
  }
}

  11. Pokud chcete implementovat obslužnou rutinu zpětného volání pro události stavu dvojčete zařízení, přidejte do třídy App 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());
    }
}

  12. Pokud chcete implementovat obslužnou rutinu zpětného volání pro události vlastností, přidejte do třídy App 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);
  }
}

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

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

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

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

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

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

  17. Pokud chcete začít naslouchat voláním přímých metod, přidejte do metody main 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...");
}

  18. Simulátor zařízení vypnete tak, že do metody main přidáte 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...");

  19. Uložte a zavřete soubor simulated-device\src\main\java\com\mycompany\app\App.java.

  20. 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ího řetězce služby IoT Hub

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

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

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

  2. V levém podokně centra IoT vyberte Zásady sdíleného přístupu.

  3. V seznamu zásad vyberte zásadu služby .

  4. Zkopírujte primární připojovací řetězec a uložte hodnotu .

Snímek obrazovky, který ukazuje, jak načíst připojovací řetězec z IoT Hub v Azure Portal

Další informace o IoT Hub zásadách a oprávněních sdíleného přístupu najdete v tématu Řízení přístupu a oprávnění.

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

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

  1. Vyvolá přímou metodu restartování v aplikaci simulovaného zařízení.

  2. Zobrazí odpověď.

  3. Dotazuje ohlášené vlastnosti odeslané ze zařízení a určí, kdy se restartování dokončí.

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

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

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

  3. Na příkazovém řádku přejděte do složky trigger-reboot .

  4. V textovém editoru otevřete souborpom.xml ve složce trigger-reboot a do uzlu závislostí přidejte následující závislost. Tato závislost umožňuje použít balíček iot-service-client ve vaší aplikaci ke komunikaci se službou IoT Hub:

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

  5. Přidejte následující uzel sestavení za uzel závislostí . 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>

  6. Uložte a zavřete soubor pom.xml.

  7. V textovém editoru otevřete zdrojový soubor trigger-reboot\src\main\java\com\mycompany\app\App.java .

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

  9. Do třídy App přidejte následující proměnné na úrovni třídy. Nahraďte {youriothubconnectionstring} připojovacím řetězcem IoT Hub, který jste zkopírovali dříve v části Získání připojovacího řetězce služby 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);

  10. Pokud chcete implementovat vlákno, které každých 10 sekund čte hlášené vlastnosti z dvojčete zařízení, přidejte do třídy App 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());
    }
  }
}

  11. Upravte podpis metody main tak, aby vyvolal následující výjimku:

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

  12. Pokud chcete vyvolat přímou metodu restartování na simulovaném zařízení, nahraďte kód v metodě main 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());
}

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

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

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

  15. Uložte a zavřete soubor trigger-reboot\src\main\java\com\mycompany\app\App.java .

  16. Sestavte back-endovou aplikaci trigger-restart 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.

  1. Na příkazovém řádku ve složce simulated-device spusťte následující příkaz, který začne naslouchat voláním metody restartování ze služby IoT Hub:

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

    Java IoT Hub aplikaci simulovaného zařízení, aby naslouchala voláním přímé metody restartování

  2. Na příkazovém řádku ve složce trigger-reboot spusťte následující příkaz, který zavolá metodu reboot na simulovaném zařízení ze služby IoT Hub:

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

    Aplikace služby Java IoT Hub pro volání přímé metody restartování

  3. Simulované zařízení reaguje na volání přímé metody restartování:

    Aplikace simulovaného zařízení IoT Hub Javě reaguje na volání přímé metody.

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í primitiv dvojčat zařízení a metod typu 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 se zařízení konfigurují tak, aby prováděla akce v době, která minimalizuje přerušení a výpadky. Časová období údržby zařízení se běžně používají k definování času, kdy má zařízení aktualizovat svou konfiguraci. Vaše back-endová řešení můžou pomocí požadovaných vlastností dvojčete zařízení definovat a aktivovat zásadu, která umožňuje časové období údržby. Když zařízení obdrží zásady časového období údržby, může pomocí ohlášené vlastnosti dvojčete zařízení nahlásit stav zásad. Back-endová aplikace pak může pomocí dotazů na dvojčete zařízení osvědčovat 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í zařízení a dotazovali jste 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 Hub a zařízení, jako je například kompletní aktualizace na základě obrázků ve službě Device Update pro Azure IoT Hub článek s využitím 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 Plánování a vysílání úloh.