Ismerkedés az eszközkezeléssel (Java)

Cikk
10/01/2024

A háttéralkalmazások az Azure IoT Hub primitívjei, például az ikereszközök és a közvetlen metódusok használatával távolról indíthatják el és figyelhetik az eszközfelügyeleti műveleteket az eszközökön. Ez a cikk bemutatja, hogyan működhet együtt egy háttéralkalmazás és egy eszközalkalmazás egy távoli eszköz újraindításának kezdeményezéséhez és figyeléséhez az IoT Hub használatával.

Feljegyzés

A cikkben ismertetett funkciók csak az IoT Hub standard szintjén érhetők el. Az alapszintű és standard/ingyenes IoT Hub-szintekről további információt a megoldáshoz megfelelő IoT Hub-szint kiválasztása című témakörben talál.

Közvetlen módszerrel kezdeményezhet eszközfelügyeleti műveleteket (például újraindítást, gyári alaphelyzetbe állítást és belső vezérlőprogram-frissítést) egy háttéralkalmazásból a felhőben. Az eszköz felelős a következőért:

Az IoT Hubról küldött metóduskérés kezelése.
A megfelelő eszközspecifikus művelet kezdeményezése az eszközön.
Állapotfrissítések biztosítása jelentett tulajdonságokon keresztül az IoT Hubnak.

A felhőben futó háttéralkalmazással ikereszköz-lekérdezéseket futtathat az eszközfelügyeleti műveletek előrehaladásának jelentéséhez.

Ez a cikk bemutatja, hogyan hozhat létre:

simulated-device: egy szimulált eszközalkalmazás közvetlen módszerrel, amely újraindítja az eszközt, és jelenti az utolsó újraindítás időpontját. A közvetlen metódusok a felhőből lesznek meghívva.
trigger-reboot: egy Java-alkalmazás, amely meghívja a szimulált eszközalkalmazás közvetlen metódusát az IoT Hubon keresztül. Megjeleníti a választ és a frissített jelentett tulajdonságokat.

Feljegyzés

Az eszközökre és a megoldás háttérrendszerére futó alkalmazások létrehozásához használható SDK-kkal kapcsolatos információkért tekintse meg az Azure IoT SDK-jait.

Előfeltételek

IoT Hub az Azure-előfizetésben. Ha még nem rendelkezik központokkal, kövesse az IoT Hub létrehozása című témakörben leírt lépéseket.
Az IoT Hubon regisztrált eszköz. Ha nincs eszköze az IoT Hubon, kövesse az eszköz regisztrálása című témakörben leírt lépéseket.
Java SE Fejlesztői készlet 8. A JDK 8 letöltéséhez győződjön meg arról, hogy a Hosszú távú támogatás alatt a Java 8-at választja.
Maven 3
Győződjön meg arról, hogy a 8883-as port nyitva van a tűzfalon. A cikkben szereplő eszközminta MQTT protokollt használ, amely a 8883-es porton keresztül kommunikál. Ez a port néhány vállalati és oktatási hálózati környezetben blokkolható. További információkért és a probléma megoldásának módjaiért lásd: Csatlakozás az IoT Hubhoz (MQTT).

Eszközalkalmazás létrehozása közvetlen módszerrel

Ebben a szakaszban egy eszközt szimuláló Java-konzolalkalmazást hoz létre. Az alkalmazás figyeli a közvetlen újraindítási metódushívást az IoT Hubról, és azonnal válaszol a hívásra. Az alkalmazás ezután egy ideig alvó állapotban van, hogy szimulálja az újraindítási folyamatot, mielőtt egy jelentett tulajdonság használatával értesíti az eseményindító-újraindítás háttéralkalmazást az újraindítás befejezéséről.

Fontos

Ez a cikk az eszközök közös hozzáférésű jogosultságkóddal, más néven szimmetrikus kulcshitelesítéssel való csatlakoztatásának lépéseit tartalmazza. Ez a hitelesítési módszer alkalmas tesztelésre és kiértékeléshez, de az eszköz hitelesítése X.509-tanúsítványokkal biztonságosabb módszer. További információkért tekintse meg a kapcsolatbiztonság ajánlott biztonsági eljárásait>.

A dm-get-started mappában hozzon létre egy Szimulált eszköz nevű Maven-projektet a parancssor következő parancsával:

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

A parancssorban keresse meg a szimulált eszköz mappát.
Szövegszerkesztővel nyissa meg a pom.xml fájlt a szimulált eszköz mappában, és adja hozzá a következő függőséget a függőségi csomóponthoz. Ez a függőség lehetővé teszi, hogy az alkalmazás iot-service-client csomagjával kommunikáljon az IoT Hubbal:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-device-client</artifactId>
  <version>1.17.5</version>
</dependency>
```
Feljegyzés

Az iot-device-client legújabb verzióját a Maven keresési funkciójával tekintheti meg.
Adja hozzá a következő függőséget a függőségi csomóponthoz . Ez a függőség egy NOP-t konfigurál az Apache SLF4J naplózási homlokzatához, amelyet az eszközügyfél SDK használ a naplózás implementálásához. Ez a konfiguráció nem kötelező, de ha kihagyja, figyelmeztetés jelenhet meg a konzolon az alkalmazás futtatásakor. Az eszközügyfél SDK-jában való naplózásról további információt az Azure IoT-eszköz SDK for Java-olvasási fájljának mintáiban talál.
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>
```

Adja hozzá a következő buildcsomópontot a függőségi csomópont után. Ez a konfiguráció arra utasítja a Mavent, hogy a Java 1.8-at használja az alkalmazás létrehozásához:

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

Mentse és zárja be a pom.xml fájlt.
Szövegszerkesztővel nyissa meg a simulated-device\src\main\java\com\mycompany\app\App.java forrásfájlt.

Adja hozzá a következő importálási utasításokat a fájlhoz:

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;

Adja hozzá a következő osztályszintű változókat az App osztályhoz. Cserélje le {yourdeviceconnectionstring} azt az eszközt, kapcsolati sztring, amikor regisztrált egy eszközt az IoT Hubon:

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;

Ha visszahíváskezelőt szeretne implementálni a közvetlen metódusállapot-eseményekhez, adja hozzá a következő beágyazott osztályt az alkalmazásosztályhoz :

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

Ha visszahíváskezelőt szeretne implementálni az ikereszköz állapoteseményeihez, adja hozzá a következő beágyazott osztályt az alkalmazásosztályhoz :

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

Ha visszahíváskezelőt szeretne implementálni a tulajdonságeseményekhez, adja hozzá a következő beágyazott osztályt az alkalmazásosztályhoz :

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

Ha egy szálat szeretne implementálni az eszköz újraindításának szimulálásához, adja hozzá a következő beágyazott osztályt az alkalmazásosztályhoz . A szál öt másodpercig alszik, majd beállítja a lastReboot jelentett tulajdonságot :

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

A közvetlen metódus eszközre való implementálásához adja hozzá a következő beágyazott osztályt az alkalmazásosztályhoz . Amikor a szimulált alkalmazás hívást kap a közvetlen újraindítási metódusra, visszaigazolást ad vissza a hívónak, majd elindít egy szálat az újraindítás feldolgozásához:

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

Módosítsa a fő metódus aláírását a következő kivételekkel:

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

A DeviceClient példányosításához cserélje le a fő metódus kódját a következő kódra:

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

A közvetlen metódushívások figyeléséhez adja hozzá a következő kódot a fő metódushoz:

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

Az eszközszimulátor leállításához adja hozzá a következő kódot a fő módszerhez:

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

Mentse és zárja be a simulated-device\src\main\java\com\mycompany\app\App.java fájlt.
Hozza létre a szimulált eszköz alkalmazást, és javítsa ki a hibákat. A parancssorban keresse meg a szimulált eszköz mappát, és futtassa a következő parancsot:
```
mvn clean package -DskipTests
```

Az IoT Hub kapcsolati sztring lekérése

Ebben a cikkben egy olyan háttérszolgáltatást hoz létre, amely közvetlen metódust hív meg egy eszközön. Ha közvetlen metódust szeretne meghívni egy eszközön az IoT Hubon keresztül, a szolgáltatásnak szolgáltatáscsatlakozási engedélyre van szüksége. Alapértelmezés szerint minden IoT Hub egy megosztott hozzáférési szabályzattal jön létre, amely ezt az engedélyt biztosítja.

Az IoT Hub kapcsolati sztring szolgáltatásszabályzathoz való lekéréséhez kövesse az alábbi lépéseket:

Az Azure Portalon válassza ki az Erőforráscsoportokat. Válassza ki azt az erőforráscsoportot, ahol a központ található, majd válassza ki a központot az erőforrások listájából.
Az IoT Hub bal oldali ablaktábláján válassza a Megosztott hozzáférési szabályzatok lehetőséget.
A szabályzatok listájában válassza ki a szolgáltatásházirendet.
Másolja ki az elsődleges kapcsolati sztring, és mentse az értéket.

További információ az IoT Hub megosztott hozzáférési szabályzatairól és engedélyeiről: Hozzáférés-vezérlés és engedélyek.

Szolgáltatásalkalmazás létrehozása újraindítás indításához

Ebben a szakaszban egy Java-konzolalkalmazást hoz létre, amely:

Meghívja a közvetlen újraindítási metódust a szimulált eszközalkalmazásban.
Megjeleníti a választ.
Lekérdezi az eszközről küldött jelentett tulajdonságokat, hogy megállapítsa, mikor fejeződik be az újraindítás.

Fontos

Ez a cikk a szolgáltatáshoz való csatlakozás lépéseit tartalmazza közös hozzáférésű jogosultságkód használatával. Ez a hitelesítési módszer a teszteléshez és a kiértékeléshez kényelmes, de biztonságosabb módszer a Microsoft Entra-azonosítóval vagy felügyelt identitásokkal történő hitelesítés egy szolgáltatáshoz. További információkért tekintse meg a felhőbiztonság ajánlott biztonsági eljárásait>.

Ez a konzolalkalmazás csatlakozik az IoT Hubhoz a közvetlen metódus meghívásához és a jelentett tulajdonságok olvasásához.

Hozzon létre egy dm-get-started nevű üres mappát.

A dm-get-started mappában hozzon létre egy Maven-projektet trigger-reboot néven a következő paranccsal a parancssorban:

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

A parancssorban keresse meg az eseményindító-újraindítás mappát.
Szövegszerkesztővel nyissa meg a pom.xml fájlt az eseményindító-újraindítás mappában, és adja hozzá a következő függőséget a függőségi csomóponthoz. Ez a függőség lehetővé teszi, hogy az alkalmazás iot-service-client csomagjával kommunikáljon az IoT Hubbal:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.17.1</version>
  <type>jar</type>
</dependency>
```
Feljegyzés

Az iot-service-client legújabb verzióját a Maven keresési funkciójával tekintheti meg.

Adja hozzá a következő buildcsomópontot a függőségi csomópont után. Ez a konfiguráció arra utasítja a Mavent, hogy a Java 1.8-at használja az alkalmazás létrehozásához:

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

Mentse és zárja be a pom.xml fájlt.
Szövegszerkesztővel nyissa meg a trigger-reboot\src\main\java\com\mycompany\app\App.java forrásfájlt.

Adja hozzá a következő importálási utasításokat a fájlhoz:

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;

Adja hozzá a következő osztályszintű változókat az App osztályhoz. Cserélje le {youriothubconnectionstring} a korábban másolt IoT Hub kapcsolati sztring az IoT Hub lekérése kapcsolati sztring:

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

Ha olyan szálat szeretne implementálni, amely 10 másodpercenként olvassa be az ikereszköz jelentett tulajdonságait, adja hozzá a következő beágyazott osztályt az alkalmazásosztályhoz :

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

Módosítsa a fő metódus aláírását a következő kivétel kijelzéséhez:
```
public static void main(String[] args) throws IOException
```

A közvetlen újraindítási metódus szimulált eszközön való meghívásához cserélje le a fő metódus kódját a következő kódra:

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

A szál szimulált eszközről történő lekérdezéséhez a szál elindításához adja hozzá a következő kódot a fő metódushoz:

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

Az alkalmazás leállításához adja hozzá a következő kódot a fő módszerhez:

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

Mentse és zárja be a trigger-reboot\src\main\java\com\mycompany\app\App.java fájlt.
Hozza létre az eseményindító-újraindítás háttéralkalmazást, és javítsa ki a hibákat. A parancssorban lépjen az eseményindító-újraindítás mappára, és futtassa a következő parancsot:
```
mvn clean package -DskipTests
```

Az alkalmazások futtatása

Most már készen áll az alkalmazások futtatására.

A szimulált eszköz mappában lévő parancssorban futtassa a következő parancsot az IoT Hub újraindítási metódushívásainak figyeléséhez:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Az eseményindító-újraindítás mappában található parancssorban futtassa a következő parancsot a szimulált eszköz újraindítási metódusának meghívásához az IoT Hubról:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
A szimulált eszköz válaszol a közvetlen újraindítási metódushívásra:

Az eszközfelügyeleti műveletek testreszabása és kiterjesztése

Az IoT-megoldások kibővíthetik az eszközfelügyeleti minták definiált készletét, vagy engedélyezhetik az egyéni mintákat az ikereszköz és a felhőből az eszközre módszer primitívjeinek használatával. Az eszközfelügyeleti műveletekre további példák a gyári beállítások visszaállítása, a belső vezérlőprogram frissítése, a szoftverfrissítés, az energiagazdálkodás, a hálózat- és kapcsolatkezelés, valamint az adattitkosítás.

Eszközkarbantartási ablakok

Az eszközöket általában olyan műveletek végrehajtására konfigurálja, amelyek minimalizálják a megszakításokat és az állásidőt. Az eszközkarbantartási ablakokat gyakran használják annak meghatározására, hogy az eszköz mikor frissítse a konfigurációját. A háttérmegoldások az ikereszköz kívánt tulajdonságaival definiálhatnak és aktiválhatnak egy szabályzatot az eszközön, amely lehetővé teszi a karbantartási időszakot. Amikor egy eszköz megkapja a karbantartási időszak szabályzatát, az ikereszköz jelentett tulajdonságával jelentheti a szabályzat állapotát. A háttéralkalmazás ezután ikereszköz-lekérdezésekkel igazolja az eszközök és az egyes szabályzatok megfelelőségét.

Következő lépések

Ebben a cikkben egy közvetlen módszerrel aktivált távoli újraindítást egy eszközön. A jelentett tulajdonságok használatával jelentette az eszköz legutóbbi újraindítási idejét, és lekérdezte az ikereszközt, hogy felderítse az eszköz utolsó újraindítási idejét a felhőből.

Az IoT Hub és az olyan eszközfelügyeleti minták használatának folytatása, mint például az Azure IoT Hub eszközfrissítésének teljes körű képalapú frissítése a Raspberry Pi 3 B+ referenciarendszerkép használatával.

Az IoT-megoldás és a metódushívások több eszközön való ütemezéséről további információt a Feladatok ütemezése és közvetítése című témakörben talál.

Megosztás a következőn keresztül: