Aan de slag met apparaatbeheer (Java)

Artikel
05/30/2023

Back-end-apps kunnen gebruikmaken van Azure IoT Hub primitieven, zoals apparaatdubbels en directe methoden, om apparaatbeheeracties op apparaten op afstand te starten en te bewaken. In dit artikel wordt beschreven hoe een back-end-app en een apparaat-app kunnen samenwerken om het opnieuw opstarten van een extern apparaat te starten en te bewaken met behulp van IoT Hub.

Notitie

De functies die in dit artikel worden beschreven, zijn alleen beschikbaar in de standaardlaag van de IoT Hub. Zie Choose the right IoT Hub tier for your solution (De juiste IoT Hub laag voor uw oplossing kiezen) voor meer informatie over de lagen Basic en Standard/free IoT Hub.

Gebruik een directe methode om acties voor apparaatbeheer (zoals opnieuw opstarten, fabrieksinstellingen en firmware-update) te initiëren vanuit een back-end-app in de cloud. Het apparaat is verantwoordelijk voor:

De methodeaanvraag verwerken die is verzonden vanaf IoT Hub.
De bijbehorende apparaatspecifieke actie op het apparaat initiëren.
Het verstrekken van statusupdates via gerapporteerde eigenschappen aan IoT Hub.

U kunt een back-end-app in de cloud gebruiken om query's op apparaatdubbels uit te voeren om de voortgang van uw apparaatbeheeracties te rapporteren.

In dit artikel wordt beschreven hoe u het volgende maakt:

simulated-device: een gesimuleerde apparaat-app met een directe methode waarmee het apparaat opnieuw wordt opgestart en de laatste keer dat het apparaat opnieuw wordt opgestart. Directe methoden worden aangeroepen vanuit de cloud.
trigger-reboot: een Java-app die de directe methode in de gesimuleerde apparaat-app aanroept via uw IoT-hub. Het antwoord en bijgewerkte gerapporteerde eigenschappen worden weergegeven.

Notitie

Zie Azure IoT SDK's voor meer informatie over de SDK's die u kunt gebruiken om toepassingen te bouwen voor uitvoering op apparaten en de back-end van uw oplossing.

Vereisten

Een IoT-hub. Maak er een met de CLI of de Azure Portal.
Een geregistreerd apparaat. Registreer er een in de Azure Portal.
Java SE Development Kit 8. Zorg ervoor dat u Java 8 selecteert onder Langetermijnondersteuning om naar downloads voor JDK 8 te gaan.
Maven 3
Zorg ervoor dat de poort 8883 is geopend in de firewall. Het apparaatvoorbeeld in dit artikel maakt gebruik van het MQTT-protocol, dat communiceert via poort 8883. Deze poort is in sommige netwerkomgevingen van bedrijven en onderwijsinstellingen mogelijk geblokkeerd. Zie Verbinding maken met IoT Hub (MQTT) voor meer informatie en manieren om dit probleem te omzeilen.

Een apparaat-app maken met een directe methode

In deze sectie maakt u een Java-console-app waarmee een apparaat wordt gesimuleerd. De app luistert naar de aanroep van de directe methode voor opnieuw opstarten vanuit uw IoT-hub en reageert onmiddellijk op die oproep. De app wordt vervolgens een tijdje in de slaapstand gezet om het herstartproces te simuleren voordat een gerapporteerde eigenschap wordt gebruikt om de back-end-app trigger-reboot te melden dat het opnieuw opstarten is voltooid.

Maak in de map dm-get-started een Maven-project met de naam simulated-device met behulp van de volgende opdracht bij de opdrachtprompt:

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

Navigeer bij de opdrachtprompt naar de map simulated-device .
Open met behulp van een teksteditor het pom.xml-bestand in de map simulated-device en voeg de volgende afhankelijkheid toe aan het knooppunt afhankelijkheden . Met deze afhankelijkheid kunt u het pakket iot-service-client in uw app gebruiken om te communiceren met uw IoT-hub:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-device-client</artifactId>
  <version>1.17.5</version>
</dependency>
```
Notitie

U vindt de meest recente versie van iot-device-client met Maven zoeken.
Voeg de volgende afhankelijkheid toe aan het knooppunt afhankelijkheden . Met deze afhankelijkheid wordt een NOP geconfigureerd voor de apache SLF4J-logboekregistratiefaçade , die wordt gebruikt door de SDK van de apparaatclient om logboekregistratie te implementeren. Deze configuratie is optioneel, maar als u deze weglaat, ziet u mogelijk een waarschuwing in de console wanneer u de app uitvoert. Zie Logboekregistratie in het leesmij-bestand Voorbeelden voor de Azure IoT-apparaat-SDK voor Java voor meer informatie over logboekregistratie in de client-SDK voor het apparaat.
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>
```

Voeg het volgende build-knooppunt toe na het knooppunt afhankelijkheden . Deze configuratie geeft Maven de opdracht om Java 1.8 te gebruiken om de app te bouwen:

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

Sla het bestand pom.xml op en sluit het.
Open met een teksteditor het bronbestand simulated-device\src\main\java\com\mycompany\app\App.java .

Voeg de volgende importinstructies toe aan het bestand:

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;

Voeg de volgende variabelen op klasseniveau toe aan de App-klasse. Vervang door {yourdeviceconnectionstring} het apparaat connection string u hebt gezien toen u een apparaat in de IoT Hub hebt geregistreerd:

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;

Als u een callback-handler wilt implementeren voor statusgebeurtenissen van de directe methode, voegt u de volgende geneste klasse toe aan de app-klasse :

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

Als u een callback-handler wilt implementeren voor statusgebeurtenissen van apparaatdubbels, voegt u de volgende geneste klasse toe aan de app-klasse :

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

Als u een callback-handler wilt implementeren voor eigenschapsgebeurtenissen, voegt u de volgende geneste klasse toe aan de app-klasse :

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

Als u een thread wilt implementeren om het opnieuw opstarten van het apparaat te simuleren, voegt u de volgende geneste klasse toe aan de app-klasse . De thread wordt vijf seconden in de slaapstand gezet en stelt vervolgens de gerapporteerde eigenschap lastReboot in:

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

Als u de directe methode op het apparaat wilt implementeren, voegt u de volgende geneste klasse toe aan de app-klasse . Wanneer de gesimuleerde app een aanroep van de directe methode voor opnieuw opstarten ontvangt, retourneert deze een bevestiging naar de aanroeper en wordt vervolgens een thread gestart om het opnieuw opstarten te verwerken:

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

Wijzig de handtekening van de main-methode om de volgende uitzonderingen te genereren:
```
public static void main(String[] args) throws IOException, URISyntaxException
```

Als u een DeviceClient wilt instantiëren, vervangt u de code in de methode main door de volgende code:

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

Als u wilt luisteren naar aanroepen van directe methoden, voegt u de volgende code toe aan de main-methode :

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

Als u de apparaatsimulator wilt afsluiten, voegt u de volgende code toe aan de hoofdmethode :

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

Sla het bestand simulated-device\src\main\java\com\mycompany\app\App.java op en sluit het.
Bouw de gesimuleerde apparaat-app en corrigeer eventuele fouten. Navigeer bij de opdrachtprompt naar de map simulated-device en voer de volgende opdracht uit:
```
mvn clean package -DskipTests
```

De IoT Hub-connection string ophalen

In dit artikel maakt u een back-endservice die een directe methode op een apparaat aanroept. Als u een directe methode op een apparaat wilt aanroepen via IoT Hub, heeft uw service de machtiging serviceverbinding nodig. Standaard wordt elke IoT Hub gemaakt met een gedeeld toegangsbeleid met de naam service die deze machtiging verleent.

Volg deze stappen om de IoT Hub connection string voor het servicebeleid op te halen:

Selecteer Resourcegroepenin de Azure Portal. Selecteer de resourcegroep waar uw hub zich bevindt en selecteer vervolgens uw hub in de lijst met resources.
Selecteer in het linkerdeelvenster van uw IoT-hub beleid voor gedeelde toegang.
Selecteer het servicebeleid in de lijst met beleidsregels.
Kopieer de Primaire connection string en sla de waarde op.

Zie Toegangsbeheer en machtigingen voor meer informatie over IoT Hub gedeelde toegangsbeleid en -machtigingen.

Een service-app maken om opnieuw opstarten te activeren

In deze sectie maakt u een Java-console-app die:

Roept de directe methode voor opnieuw opstarten aan in de app voor het gesimuleerde apparaat.
Geeft het antwoord weer.
Peilt de gerapporteerde eigenschappen die vanaf het apparaat zijn verzonden om te bepalen wanneer het opnieuw opstarten is voltooid.

Deze console-app maakt verbinding met uw IoT Hub om de directe methode aan te roepen en de gerapporteerde eigenschappen te lezen.

Maak een lege map met de naam dm-get-started.

Maak in de map dm-get-started een Maven-project met de naam trigger-reboot met behulp van de volgende opdracht bij de opdrachtprompt:

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

Navigeer bij de opdrachtprompt naar de map trigger-reboot .
Open met een teksteditor het pom.xml-bestand in de map trigger-reboot en voeg de volgende afhankelijkheid toe aan het knooppunt Afhankelijkheden . Met deze afhankelijkheid kunt u het pakket iot-service-client in uw app gebruiken om te communiceren met uw IoT-hub:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.17.1</version>
  <type>jar</type>
</dependency>
```
Notitie

U vindt de meest recente versie van iot-service-client met Maven zoeken.

Voeg het volgende build-knooppunt toe na het knooppunt afhankelijkheden . Deze configuratie geeft Maven de opdracht om Java 1.8 te gebruiken om de app te bouwen:

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

Sla het bestand pom.xml op en sluit het.
Open met behulp van een teksteditor het bronbestand trigger-reboot\src\main\java\com\mycompany\app\App.java .

Voeg de volgende importinstructies toe aan het bestand:

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;

Voeg de volgende variabelen op klasseniveau toe aan de App-klasse. Vervang door {youriothubconnectionstring} de IoT Hub connection string die u eerder hebt gekopieerd in De IoT-hub ophalen connection string:

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

Als u een thread wilt implementeren die elke 10 seconden de gerapporteerde eigenschappen van de apparaatdubbel leest, voegt u de volgende geneste klasse toe aan de app-klasse :

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

Wijzig de handtekening van de main-methode om de volgende uitzondering te genereren:
```
public static void main(String[] args) throws IOException
```

Als u de directe methode voor opnieuw opstarten wilt aanroepen op het gesimuleerde apparaat, vervangt u de code in de hoofdmethode door de volgende code:

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

Als u de thread wilt starten om de gerapporteerde eigenschappen van het gesimuleerde apparaat te peilen, voegt u de volgende code toe aan de hoofdmethode :

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

Als u de app wilt stoppen, voegt u de volgende code toe aan de hoofdmethode :

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

Sla het bestand trigger-reboot\src\main\java\com\mycompany\app\App.java op en sluit het.
Bouw de back-end-app trigger-reboot en corrigeer eventuele fouten. Navigeer bij de opdrachtprompt naar de map trigger-reboot en voer de volgende opdracht uit:
```
mvn clean package -DskipTests
```

De apps uitvoeren

U bent nu klaar om de apps uit te voeren.

Voer bij een opdrachtprompt in de map simulated-device de volgende opdracht uit om te luisteren naar aanroepen van de methode voor opnieuw opstarten vanuit uw IoT-hub:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Voer bij een opdrachtprompt in de map trigger-reboot de volgende opdracht uit om de methode voor opnieuw opstarten op uw gesimuleerde apparaat aan te roepen vanuit uw IoT-hub:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Het gesimuleerde apparaat reageert op de aanroep van de directe methode voor opnieuw opstarten:

De acties voor apparaatbeheer aanpassen en uitbreiden

Uw IoT-oplossingen kunnen de gedefinieerde set apparaatbeheerpatronen uitbreiden of aangepaste patronen inschakelen met behulp van de primitieven van de apparaatdubbel en de cloud-naar-apparaat-methode. Andere voorbeelden van acties voor apparaatbeheer zijn fabrieksinstellingen herstellen, firmware-update, software-update, energiebeheer, netwerk- en connectiviteitsbeheer en gegevensversleuteling.

Onderhoudsvensters voor apparaten

Normaal gesproken configureert u apparaten om acties uit te voeren op een moment dat onderbrekingen en downtime tot een minimum worden beperkt. Onderhoudsvensters voor apparaten zijn een veelgebruikt patroon om het tijdstip te definiëren waarop een apparaat de configuratie moet bijwerken. Uw back-endoplossingen kunnen de gewenste eigenschappen van de apparaatdubbel gebruiken om een beleid op uw apparaat te definiëren en activeren waarmee een onderhoudsvenster mogelijk wordt. Wanneer een apparaat het onderhoudsvensterbeleid ontvangt, kan het de gerapporteerde eigenschap van de apparaatdubbel gebruiken om de status van het beleid te rapporteren. De back-end-app kan vervolgens apparaatdubbelquery's gebruiken om te bevestigen dat apparaten en elk beleid voldoen.

Volgende stappen

In dit artikel hebt u een directe methode gebruikt om extern opnieuw opstarten op een apparaat te activeren. U hebt de gerapporteerde eigenschappen gebruikt om de laatste keer dat het apparaat opnieuw is opgestart te rapporteren en de apparaatdubbel opgevraagd om de laatste keer dat het apparaat opnieuw is opgestart vanuit de cloud te detecteren.

ToOm aan de slag te gaan met IoT Hub- en apparaatbeheerpatronen, zoals end-to-end update op basis van afbeeldingen in Device Update voor Azure IoT Hub artikel met behulp van de Raspberry Pi 3 B+-referentieafbeelding.

Zie Taken plannen en uitzenden voor meer informatie over het uitbreiden van uw IoT-oplossing en het plannen van methode-aanroepen op meerdere apparaten.

Delen via