Prise en main de la gestion d’appareils (Java)

Article
05/30/2023

Les applications back-end peuvent utiliser des primitives Azure IoT Hub, par exemple les jumeaux d’appareil et les méthodes directes, pour effectuer le démarrage et le monitoring à distance des actions de gestion des appareils sur les appareils. Cet article illustre la manière dont une application back-end et une application pour périphérique fonctionnent conjointement afin de lancer et d’analyser le redémarrage à distance d’un appareil à l’aide de IoT Hub.

Notes

Les fonctionnalités décrites dans cet article sont uniquement disponibles au niveau Standard d’IoT Hub. Pour plus d’informations sur les niveaux de base et standard/gratuit d’IoT Hub, consultez Choisir le niveau IoT Hub correspondant à votre solution.

Utilisez une méthode directe pour lancer des actions de gestion d’appareils (redémarrage, réinitialisation des paramètres d’usine et mise à jour du microprogramme) à partir d’une application principale dans le cloud. L’appareil est chargé de :

Gérer la requête de méthode envoyée à partir d’IoT Hub.
Démarrer l’action correspondante spécifique à l’appareil sur l’appareil.
Fournir à IoT Hub des mises à jour de l’état via des propriétés signalées.

Vous pouvez utiliser une application principale dans le cloud pour exécuter des requêtes sur la représentation d’appareil afin d’indiquer la progression des actions de gestion de votre appareil.

Cet article explique comment créer :

Simuler un appareil : une application d’appareil simulée avec une méthode directe qui redémarre l’appareil et signale la dernière heure de redémarrage. Les méthodes directes sont appelées à partir du cloud.
trigger-reboot : une application Java appelle une méthode directe de redémarrage sur l’application d’appareil simulé via votre IoT Hub. Il affiche la réponse et les propriétés signalées mises à jour.

Notes

Pour plus d’informations sur les SDK que vous pouvez utiliser pour générer des applications qui s’exécutent sur les appareils et sur le back-end de solution, consultez Kits SDK Azure IoT.

Prérequis

Un IoT Hub. Créez-en un avec l’interface CLI ou le portail Azure.
Appareil inscrit. Inscrivez-en un dans le portail Azure.
Java SE Development Kit 8. Veillez à sélectionner Java 8 sous Prise en charge à long terme pour accéder aux téléchargements du kit JDK 8.
Maven 3
Vérifiez que le port 8883 est ouvert dans votre pare-feu. L’exemple d’appareil décrit dans cet article utilise le protocole MQTT, qui communique via le port 8883. Ce port peut être bloqué dans certains environnements réseau professionnels et scolaires. Pour plus d’informations sur les différentes façons de contourner ce problème, consultez Connexion à IoT Hub (MQTT).

Créer une application d’appareil avec une méthode directe

Dans cette section, vous créez une application console Java qui simule un appareil. L’application écoute l’appel de méthode directe de redémarrage à partir de votre hub IoT et répond immédiatement à cet appel. L’application se met ensuite en veille pendant un certain temps pour simuler le processus de redémarrage, puis utilise une propriété signalée pour indiquer à l’application principale trigger-reboot que le redémarrage est terminé.

Dans le dossier dm-get-started, créez un projet Maven nommé simulated-device en entrant la commande suivante à l’invite de commandes :

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

À l'invite de commandes, accédez au dossier simulated-device.
Dans un éditeur de texte, ouvrez le fichier pom.xml dans le dossier simulated-device et ajoutez la dépendance suivante au nœud dependencies. Cette dépendance vous permet d’utiliser le package iot-device-client dans votre application pour communiquer avec votre IoT Hub :
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-device-client</artifactId>
  <version>1.17.5</version>
</dependency>
```
Notes

Vous pouvez rechercher la dernière version de iot-device-client avec la recherche Maven.
Ajoutez la dépendance suivante au nœud dependencies. Cette dépendance configure un NOP pour la façade de journalisation Apache SLF4J utilisée par le kit de développement logiciel (SDK) du client d'appareil afin d'implémenter la journalisation. Cette configuration est facultative, mais si vous l’omettez, un avertissement peut s’afficher sur la console lorsque vous lancez l’application. Pour plus d’informations sur la journalisation dans le SDK du client d’appareil, consultez Journalisation dans le fichier Readme Exemples relatifs à Azure IoT device SDK pour Java.
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>
```

Ajoutez le nœud build suivant après le nœud dependencies. Cette configuration ordonne à Maven d’utiliser Java 1.8 pour générer l’application :

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

Enregistrez et fermez le fichier pom.xml.
À l’aide d’un éditeur de texte, ouvrez le fichier source simulated-device\src\main\java\com\mycompany\app\App.java.

Ajoutez les instructions import suivantes au fichier :

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;

Ajoutez les variables de niveau classe suivantes à la classe App . Remplacez {yourdeviceconnectionstring} par la chaîne de connexion de l’appareil que vous avez vu au moment de l’inscription d’un appareil dans 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;

Pour implémenter un gestionnaire de rappel pour les événements d’état de méthode directe, ajoutez la classe imbriquée suivante à la classe 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());
  }
}

Pour implémenter un gestionnaire de rappel pour les événements d’état de jumeau d’appareil, ajoutez la classe imbriquée suivante à la classe 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());
    }
}

Pour implémenter un gestionnaire de rappel pour les événements de propriété, ajoutez la classe imbriquée suivante à la classe 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);
  }
}

Pour implémenter un thread afin de simuler le redémarrage de l’appareil, ajoutez la classe imbriquée suivante à la classe App. Le thread se met en veille pendant cinq secondes, puis définit la propriété signalée lastReboot :

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

Pour implémenter la méthode directe sur l’appareil, ajoutez la classe imbriquée suivante à la classe App. Quand l’application simulée reçoit un appel à la méthode directe reboot, elle retourne un accusé de réception à l’appelant, puis démarre un thread pour traiter le redémarrage :

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

Modifiez la signature de la méthode main pour déclencher les exceptions suivantes :
```
public static void main(String[] args) throws IOException, URISyntaxException
```

Pour instancier un DeviceClient, remplacez le code dans la méthode main par le code suivant :

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

Pour commencer à écouter les appels de méthode directe, ajoutez le code suivant à la méthode 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...");
}

Pour arrêter le simulateur d’appareil, ajoutez le code suivant à la méthode 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...");

Enregistrez et fermez le fichier simulated-device\src\main\java\com\mycompany\app\App.java.
Générez l’application simulated-device et corrigez les erreurs. À l'invite de commandes, accédez au dossier simulated-device et exécutez la commande suivante :
```
mvn clean package -DskipTests
```

Obtenir la chaîne de connexion du hub IoT

Dans cet article, vous créez un service principal qui invoque une méthode directe sur un appareil. Pour invoquer une méthode directe sur un appareil via l’IoT Hub, votre service a besoin de l'autorisation de connexion de service. Par défaut, chaque IoT Hub est créé avec une stratégie d’accès partagé nommée service qui accorde cette autorisation.

Pour obtenir la chaîne de connexion IoT Hub pour la stratégie service, procédez comme suit :

Dans le portail Azure, sélectionnez Groupes de ressources. Sélectionnez le groupe de ressources dans lequel se trouve votre hub, puis sélectionnez votre hub dans la liste des ressources.
Dans le volet de gauche de votre IoT Hub, sélectionnez Stratégies d’accès partagé.
Dans la liste des stratégies, sélectionnez la stratégie service.
Copiez la Chaîne de connexion principale, puis enregistrez la valeur.

Pour plus d’informations sur les autorisations et les stratégies d’accès partagé IoT Hub, consultez Contrôle d’accès et autorisations.

Créer une application de service pour déclencher un redémarrage

Dans cette section, vous allez créer une application console Java qui :

Appelle la méthode directe de redémarrage dans l’application d’appareil simulé
Affiche la réponse
Interroge les propriétés signalées envoyées par l’appareil pour déterminer si le redémarrage est terminé

Cette application console se connecte à votre hub IoT pour appeler la méthode directe et lire les propriétés signalées.

Créez un dossier vide appelé dm-get-started.

Dans le dossier dm-get-started, créez un projet Maven nommé trigger-reboot en entrant la commande suivante à l’invite de commandes :

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

À l’invite de commandes, accédez au dossier trigger-reboot.
Dans un éditeur de texte, ouvrez le fichier pom.xml dans le dossier trigger-reboot et ajoutez la dépendance suivante au nœud dependencies. Cette dépendance vous permet d’utiliser le package iot-device-client dans votre application pour communiquer avec votre IoT Hub :
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.17.1</version>
  <type>jar</type>
</dependency>
```
Notes

Vous pouvez rechercher la dernière version de iot-service-client avec la recherche Maven.

Ajoutez le nœud build suivant après le nœud dependencies. Cette configuration ordonne à Maven d’utiliser Java 1.8 pour générer l’application :

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

Enregistrez et fermez le fichier pom.xml.
À l’aide d’un éditeur de texte, ouvrez le fichier source trigger-reboot\src\main\java\com\mycompany\app\App.java.

Ajoutez les instructions import suivantes au fichier :

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;

Ajoutez les variables de niveau classe suivantes à la classe App . Remplacez {youriothubconnectionstring} par la chaîne de connexion de l’IoT Hub que vous avez copiée précédemment dans Obtention de la chaîne de connexion de l’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);

Pour implémenter un thread qui lit les propriétés signalées à partir du jumeau d’appareil toutes les 10 secondes, ajoutez la classe imbriquée suivante à la classe 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());
    }
  }
}

Modifiez la signature de la méthode main pour déclencher l’exception suivante :
```
public static void main(String[] args) throws IOException
```

Pour appeler la méthode directe de redémarrage sur l’appareil simulé, remplacez le code dans la méthode main par le code suivant :

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

Pour démarrer le thread afin d’interroger les propriétés signalées à partir de l’appareil simulé, ajoutez le code suivant à la méthode main :

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

Pour être en mesure d’arrêter l’application, ajoutez le code suivant à la méthode main :

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

Enregistrez et fermez le fichier trigger-reboot\src\main\java\com\mycompany\app\App.java.
Générez l’application principale trigger-reboot et corrigez les erreurs éventuelles. À l’invite de commandes, accédez au dossier trigger-reboot et exécutez la commande suivante :
```
mvn clean package -DskipTests
```

Exécuter les applications

Vous êtes maintenant prêt à exécuter les applications.

À l’invite de commandes, dans le dossier simulated-device, exécutez la commande suivante pour commencer à écouter les appels de méthode de redémarrage à partir de votre IoT Hub :
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
À l’invite de commandes, dans le dossier trigger-reboot, exécutez la commande suivante pour appeler la méthode de redémarrage sur votre appareil simulé à partir de votre IoT Hub :
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
L’appareil simulé répond à l’appel de méthode directe de redémarrage :

Personnaliser et étendre les actions de gestion d’appareils

Vos solutions IoT peuvent étendre l’ensemble défini de modèles de gestion d’appareils ou activer des modèles personnalisés en utilisant les primitives de la méthode cloud-à-appareil et du jumeau d’appareil. La réinitialisation des paramètres d’usine, la mise à jour du microprogramme, la mise à jour logicielle, la gestion de l’alimentation, la gestion du réseau et de la connectivité, et le chiffrement des données sont d’autres exemples d’actions de gestion des appareils.

Fenêtres de maintenance d’appareil

En règle générale, vous configurez des appareils pour effectuer des actions à un moment qui minimise les interruptions et les temps d’arrêt. Les fenêtres de maintenance d’appareil constituent un modèle couramment utilisé pour définir l’heure à laquelle un appareil doit mettre à jour sa configuration. Vos solutions principales peuvent utiliser les propriétés souhaitées de la représentation d’appareil pour définir et activer une stratégie sur votre appareil qui permet d’obtenir une fenêtre de maintenance. Lorsqu’un appareil reçoit la stratégie de fenêtre de maintenance, il peut utiliser la propriété signalée de la représentation d’appareil pour indiquer l’état de la stratégie. L’application principale peut ensuite utiliser des requêtes de représentation d’appareil pour certifier la conformité des appareils et de chaque stratégie.

Étapes suivantes

Dans cet article, vous avez utilisé une méthode directe pour déclencher un redémarrage à distance sur un appareil. Vous avez utilisé les propriétés signalées pour indiquer le moment du dernier redémarrage de l’appareil et vous avez interrogé le jumeau d’appareil pour découvrir l’heure du dernier redémarrage de l’appareil à partir du cloud.

Pour approfondir vos connaissances sur IoT Hub et les modèles de gestion des appareils, comme la mise à jour de bout en bout basée sur une image, consultez l’article relatif à la mise à jour des appareils pour Azure IoT Hub à l’aide de l’image de référence Raspberry Pi 3 B+.

Pour savoir comment étendre votre solution IoT et planifier des appels de méthode sur plusieurs appareils, consultez Planifier et diffuser des travaux.

Share via