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

Article
03/18/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 :

dmpatterns_getstarted_device.py : 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.
dmpatterns_getstarted_service.py :une application console Python qui appelle la méthode directe 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 outils SDK disponibles pour créer des applications back-end et d’appareil, consultez Kits SDK Azure IoT.

Prérequis

Un compte Azure actif. (Si vous ne possédez pas de compte, vous pouvez créer un compte gratuit en quelques minutes seulement.)
Un IoT Hub. Créez-en un avec l’interface CLI ou le portail Azure.
Appareil inscrit. Inscrivez-en un dans le portail Azure.
Python version 3.7 ou ultérieure est recommandé. Veillez à utiliser l’installation 32 bits ou 64 bits comme requis par votre programme d’installation. Lorsque vous y êtes invité pendant l’installation, veillez à ajouter Python à votre variable d’environnement propre à la plateforme.
Assurez-vous 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).

Inscrire un nouvel appareil dans le hub IoT

Dans cette section, vous utilisez Azure CLI pour créer une identité d’appareil pour cet article. Les ID d’appareil respectent la casse.

Ouvrez Azure Cloud Shell.
Dans Azure Cloud Shell, exécutez la commande suivante pour installer l’extension IoT Microsoft Azure pour Azure CLI :
```
az extension add --name azure-iot
```
Créez une nouvelle identité d’appareil nommée myDeviceId et récupérez la chaîne de connexion d’appareil à l’aide des commandes suivantes :
```
az iot hub device-identity create --device-id myDeviceId --hub-name {Your IoT Hub name} --resource-group {Resource group of the Hub}
az iot hub device-identity connection-string show --device-id myDeviceId --hub-name {Your IoT Hub name} --resource-group {Resource group of the Hub} -o table
```
Important

L’ID d’appareil étant potentiellement visible dans les journaux d’activité collectés à des fins de support technique et de dépannage, assurez-vous de ne pas utiliser d’informations sensibles en attribuant un nom à votre appareil.

Prenez note de la chaîne de connexion de l’appareil à partir du résultat. Cette chaîne de connexion est utilisée par l’application d’appareil pour se connecter à votre IoT Hub en tant qu’appareil.

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

Dans cette section, vous allez :

Créer une application console Python qui répond à une méthode directe appelée par le cloud.
Simuler un redémarrage d’appareil.
Utiliser les propriétés signalées pour activer les requêtes sur le jumeau d’appareil afin d’identifier les appareils et l’heure de leur dernier redémarrage.

Dans Azure Cloud Shell ou tout autre environnement avec Python que vous avez utilisé précédemment, créez le code de l’appareil.

À partir de votre invite de commandes, exécutez la commande suivante pour installer le package azure-iot-device :
```
pip install azure-iot-device
```
À l’aide d’un éditeur de texte, dans votre répertoire de travail, créez un fichier nommé dmpatterns_getstarted_device.py.

Ajoutez les instructions import suivantes au début du fichier dmpatterns_getstarted_device.py.

import time
import datetime
from azure.iot.device import IoTHubDeviceClient, MethodResponse

Ajoutez la variable CONNECTION_STRING. Remplacez la valeur de l’espace réservé {deviceConnectionString} par la chaîne de connexion de votre appareil. Vous avez copié cette chaîne de connexion précédemment à l’étape Inscrire un nouvel appareil dans le hub IoT.
```
CONNECTION_STRING = "{deviceConnectionString}"
```

Ajoutez la fonction suivante pour instancier un client configuré pour des méthodes directes sur l’appareil.

def create_client():
    # Instantiate the client
    client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)

    # Define the handler for method requests
    def method_request_handler(method_request):
        if method_request.name == "rebootDevice":
            # Act on the method by rebooting the device
            print("Rebooting device")
            time.sleep(20)
            print("Device rebooted")

            # ...and patching the reported properties
            current_time = str(datetime.datetime.now())
            reported_props = {"rebootTime": current_time}
            client.patch_twin_reported_properties(reported_props)
            print( "Device twins updated with latest rebootTime")

            # Create a method response indicating the method request was resolved
            resp_status = 200
            resp_payload = {"Response": "This is the response from the device"}
            method_response = MethodResponse(method_request.request_id, resp_status, resp_payload)

        else:
            # Create a method response indicating the method request was for an unknown method
            resp_status = 404
            resp_payload = {"Response": "Unknown method"}
            method_response = MethodResponse(method_request.request_id, resp_status, resp_payload)

        # Send the method response
        client.send_method_response(method_response)

    try:
        # Attach the handler to the client
        client.on_method_request_received = method_request_handler
    except:
        # In the event of failure, clean up
        client.shutdown()

    return client

Démarrez l’exemple de méthode directe et attendez.

def main():
    print ("Starting the IoT Hub Python sample...")
    client = create_client()

    print ("Waiting for commands, press Ctrl-C to exit")
    try:
        # Wait for program exit
        while True:
            time.sleep(1000)
    except KeyboardInterrupt:
        print("IoTHubDeviceClient sample stopped")
    finally:
        # Graceful exit
        print("Shutting down IoT Hub Client")
        client.shutdown()

if __name__ == '__main__':
    main()

Enregistrez et fermez le fichier dmpatterns_getstarted_device.py.

Notes

Pour simplifier les choses, ce didacticiel n’implémente aucune stratégie de nouvelle tentative. Dans le code de production, vous devez implémenter des stratégies de nouvelle tentative (par exemple, une interruption exponentielle), comme indiqué dans l’article Gestion des erreurs temporaires.

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 créez une application console Python qui lance un redémarrage à distance sur un appareil avec une méthode directe. L’application utilise des requêtes du jumeau d’appareil pour déterminer l’heure du dernier redémarrage de cet appareil.

Dans Azure Cloud Shell ou tout autre environnement avec Python, créez le code de la console.

À partir de votre invite de commandes, exécutez la commande suivante pour installer le package azure-iot-hub :
```
pip install azure-iot-hub
```
À l’aide d’un éditeur de texte, dans votre répertoire de travail, créez un fichier nommé dmpatterns_getstarted_service.py.

Ajoutez les instructions import suivantes au début du fichier dmpatterns_getstarted_service.py.

import sys, time

from azure.iot.hub import IoTHubRegistryManager
from azure.iot.hub.models import CloudToDeviceMethod, CloudToDeviceMethodResult, Twin

Ajoutez les déclarations de variable suivantes. Remplacez la valeur de l’espace réservé {IoTHubConnectionString} par la chaîne de connexion du hub IoT que vous avez copiée dans Obtenir la chaîne de connexion du hub IoT. Remplacez la valeur de l’espace réservé {deviceId} par l’ID d’appareil que vous avez inscrit à l’étape Inscrire un nouvel appareil dans le hub IoT.
```
CONNECTION_STRING = "{IoTHubConnectionString}"
DEVICE_ID = "{deviceId}"

METHOD_NAME = "rebootDevice"
METHOD_PAYLOAD = "{\"method_number\":\"42\"}"
TIMEOUT = 60
WAIT_COUNT = 10
```

Ajoutez la fonction suivante pour appeler la méthode d’appareil afin de redémarrer l’appareil cible, puis interrogez les jumeaux de l’appareil et obtenez l’heure du dernier redémarrage.

def iothub_devicemethod_sample_run():
    try:
        # Create IoTHubRegistryManager
        registry_manager = IoTHubRegistryManager(CONNECTION_STRING)

        print ( "" )
        print ( "Invoking device to reboot..." )

        # Call the direct method.
        deviceMethod = CloudToDeviceMethod(method_name=METHOD_NAME, payload=METHOD_PAYLOAD)
        response = registry_manager.invoke_device_method(DEVICE_ID, deviceMethod)

        print ( "" )
        print ( "Successfully invoked the device to reboot." )

        print ( "" )
        print ( response.payload )

        while True:
            print ( "" )
            print ( "IoTHubClient waiting for commands, press Ctrl-C to exit" )

            status_counter = 0
            while status_counter <= WAIT_COUNT:
                twin_info = registry_manager.get_twin(DEVICE_ID)

                if twin_info.properties.reported.get("rebootTime") != None :
                    print ("Last reboot time: " + twin_info.properties.reported.get("rebootTime"))
                else:
                    print ("Waiting for device to report last reboot time...")

                time.sleep(5)
                status_counter += 1

    except Exception as ex:
        print ( "" )
        print ( "Unexpected error {0}".format(ex) )
        return
    except KeyboardInterrupt:
        print ( "" )
        print ( "IoTHubDeviceMethod sample stopped" )

if __name__ == '__main__':
    print ( "Starting the IoT Hub Service Client DeviceManagement Python sample..." )
    print ( "    Connection string = {0}".format(CONNECTION_STRING) )
    print ( "    Device ID         = {0}".format(DEVICE_ID) )

    iothub_devicemethod_sample_run()

Enregistrez et fermez le fichier dmpatterns_getstarted_service.py.

Exécuter les applications

Vous êtes maintenant prêt à exécuter le code de l’appareil et le code de service qui lance un redémarrage de l’appareil.

À l’invite de commandes où vous avez créé l’appareil, exécutez la commande suivante pour commencer à écouter la méthode directe de redémarrage.
```
python dmpatterns_getstarted_device.py
```
À l’invite de commandes où vous avez créé l’appareil, exécutez la commande suivante pour déclencher le redémarrage à distance et interroger le jumeau d’appareil afin de déterminer le moment du dernier redémarrage.
```
python dmpatterns_getstarted_service.py
```
La réponse de l’appareil à la méthode directe s’affiche dans la console.

La réponse de l’appareil à la méthode directe de redémarrage est affichée ci-dessous :

Le code suivant montre le service appelant la méthode directe de redémarrage et interrogeant le jumeau d’appareil pour connaître son état :

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.

Partager via

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

Prérequis

Inscrire un nouvel appareil dans le hub IoT

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

Obtenir la chaîne de connexion du hub IoT

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

Exécuter les applications

Personnaliser et étendre les actions de gestion d’appareils

Fenêtres de maintenance d’appareil

Étapes suivantes

Commentaires

Commentaires

Ressources supplémentaires