Tutoriel : Développer des modules IoT Edge à l’aide de Visual Studio Code

• Kit de développement logiciel (SDK) .NET Core
• Extension C# de Visual Studio Code

• Extension Visual Studio Code C/C++
• L’installation du kit de développement logiciel (SDK) C Azure IoT n’est pas nécessaire pour ce didacticiel, mais elle peut fournir des fonctionnalités utiles, telles que IntelliSense et la lecture de définitions de programme. Pour plus d’informations sur l’installation, consultez les kits de développement logiciel (SDK) et bibliothèques C Azure IoT.

• Java SE Development Kit 11 et Maven. Vous devez définir la variable d'environnement JAVA_HOME de manière à ce qu'elle pointe vers votre installation JDK.
• Maven
• Pack d’extension Java pour Visual Studio Code

• Node.js.
• Yeoman
• Azure IoT Edge Node.js Module Generator.

Pour développer un module IoT Edge avec Python, installez les configurations requises supplémentaires suivantes sur votre machine de développement :

• Python et Pip.
• Cookiecutter.
• Extension Python pour Visual Studio Code.

L’exemple de code C# qui est fourni avec le modèle de projet utilise la classe ModuleClient du SDK du IoT Hub pour .NET.

1. Dans l’explorateur de Visual Studio Code, ouvrez modules>filtermodule>ModuleBackgroundService.cs.

2. Avant l’espace de noms du filtermodule, ajoutez trois instructions using pour les types utilisés ultérieurement :

   using System.Collections.Generic;     // For KeyValuePair<>
   using Microsoft.Azure.Devices.Shared; // For TwinCollection
   using Newtonsoft.Json;                // For JsonConvert
   

3. Ajoutez la variable temperatureThreshold à la classe ModuleBackgroundService. Cette variable définit la valeur que la température mesurée doit dépasser pour que les données soient envoyées à IoT Hub.

   static int temperatureThreshold { get; set; } = 25;
   

4. Ajoutez les classes MessageBody, Machine, et Ambient. Ces classes définissent le schéma attendu pour le corps des messages entrants.

   class MessageBody
   {
       public Machine machine {get;set;}
       public Ambient ambient {get; set;}
       public string timeCreated {get; set;}
   }
   class Machine
   {
       public double temperature {get; set;}
       public double pressure {get; set;}
   }
   class Ambient
   {
       public double temperature {get; set;}
       public int humidity {get; set;}
   }
   

5. Recherchez la fonction ExecuteAsync. Cette fonction crée et configurer un objet ModuleClient qui permet au module de se connecter au runtime Azure IoT Edge local pour envoyer et recevoir des messages. Après avoir créé le ModuleClient, le code lit la valeur temperatureThreshold à partir des propriétés souhaitées du jumeau de module. Le code enregistre un rappel pour recevoir des messages du hub IoT Edge via un point de terminaison appelé input1.

   Remplacez la méthode d’appel du ProcessMessageAsync par une nouvelle qui met à jour le nom du point de terminaison et la méthode appelée lorsqu’une entrée arrive. Ajoutez également une méthode SetDesiredPropertyUpdateCallbackAsync pour des mises à jour vers des propriétés désirées. Pour ce faire, remplacez la dernière ligne de la méthode ExecuteAsync par le code suivant :

   // Register a callback for messages that are received by the module.
   // await _moduleClient.SetInputMessageHandlerAsync("input1", PipeMessage, cancellationToken);
   
   // Read the TemperatureThreshold value from the module twin's desired properties
   var moduleTwin = await _moduleClient.GetTwinAsync();
   await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, _moduleClient);
   
   // Attach a callback for updates to the module twin's desired properties.
   await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
   
   // Register a callback for messages that are received by the module. Messages received on the inputFromSensor endpoint are sent to the FilterMessages method.
   await _moduleClient.SetInputMessageHandlerAsync("inputFromSensor", FilterMessages, _moduleClient);
   

6. Ajoutez la méthode onDesiredPropertiesUpdate à la classe ModuleBackgroundService. Cette méthode reçoit des mises à jour sur les propriétés souhaitées à partir du double de module et met à jour la variable temperatureThreshold en conséquence. Tous les modules ont leur propre module jumeau, ce qui vous permet de configurer le code exécuté à l’intérieur d’un module directement à partir du cloud.

   static Task OnDesiredPropertiesUpdate(TwinCollection desiredProperties, object userContext)
   {
       try
       {
           Console.WriteLine("Desired property change:");
           Console.WriteLine(JsonConvert.SerializeObject(desiredProperties));
   
           if (desiredProperties["TemperatureThreshold"]!=null)
               temperatureThreshold = desiredProperties["TemperatureThreshold"];
   
       }
       catch (AggregateException ex)
       {
           foreach (Exception exception in ex.InnerExceptions)
           {
               Console.WriteLine();
               Console.WriteLine("Error when receiving desired property: {0}", exception);
           }
       }
       catch (Exception ex)
       {
           Console.WriteLine();
           Console.WriteLine("Error when receiving desired property: {0}", ex.Message);
       }
       return Task.CompletedTask;
   }
   

7. Ajoutez la méthode FilterMessages. Cette méthode est appelée chaque fois que le module reçoit un message d’IoT Edge Hub. Il filtre les messages qui signalent des températures situées sous le seuil de température défini via le double de module. Il ajoute également la propriété MessageType au message avec la valeur définie sur Alerte.

   async Task<MessageResponse> FilterMessages(Message message, object userContext)
   {
       var counterValue = Interlocked.Increment(ref _counter);
       try
       {
           ModuleClient moduleClient = (ModuleClient)userContext;
           var messageBytes = message.GetBytes();
           var messageString = Encoding.UTF8.GetString(messageBytes);
           Console.WriteLine($"Received message {counterValue}: [{messageString}]");
   
           // Get the message body.
           var messageBody = JsonConvert.DeserializeObject<MessageBody>(messageString);
   
           if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
           {
               Console.WriteLine($"Machine temperature {messageBody.machine.temperature} " +
                   $"exceeds threshold {temperatureThreshold}");
               using (var filteredMessage = new Message(messageBytes))
               {
                   foreach (KeyValuePair<string, string> prop in message.Properties)
                   {
                       filteredMessage.Properties.Add(prop.Key, prop.Value);
                   }
   
                   filteredMessage.Properties.Add("MessageType", "Alert");
                   await moduleClient.SendEventAsync("output1", filteredMessage);
               }
           }
   
           // Indicate that the message treatment is completed.
           return MessageResponse.Completed;
       }
       catch (AggregateException ex)
       {
           foreach (Exception exception in ex.InnerExceptions)
           {
               Console.WriteLine();
               Console.WriteLine("Error in sample: {0}", exception);
           }
           // Indicate that the message treatment is not completed.
           var moduleClient = (ModuleClient)userContext;
           return MessageResponse.Abandoned;
       }
       catch (Exception ex)
       {
           Console.WriteLine();
           Console.WriteLine("Error in sample: {0}", ex.Message);
           // Indicate that the message treatment is not completed.
           ModuleClient moduleClient = (ModuleClient)userContext;
           return MessageResponse.Abandoned;
       }
   }
   

8. Enregistrez le fichier ModuleBackgroundService.cs.

9. Dans l’Explorateur Visual Studio Code, ouvrez le fichier deployment.template.json dans votre espace de travail de solution IoT Edge.

10. Étant donné que nous avons modifié le nom du point de terminaison sur lequel le module écoute, nous devons également mettre à jour les itinéraires dans le manifeste de déploiement afin que le edgeHub envoie des messages au nouveau point de terminaison.

    Recherchez la section Itinéraires dans le jumeau de module $edgeHub. Mettez à jour l’itinéraire sensorTofilterModule pour remplacer input1 par inputFromSensor :

    "sensorTofiltermodule": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/filtermodule/inputs/inputFromSensor\")"
    

11. Ajoutez le jumeau de module filtermodule au manifeste de déploiement. Insérez le contenu JSON suivant en bas de la section modulesContent, après le jumeau de module $edgeHub:

       "filtermodule": {
           "properties.desired":{
               "TemperatureThreshold":25
           }
       }
    

12. Enregistrez le fichier deployment.template.json.

1. Dans ce scénario, les données du capteur sont fournies au format JSON. Pour filtrer les messages au format JSON, importez une bibliothèque JSON pour C. Ce didacticiel utilise Parson.

   1. Téléchargez le référentiel GitHub Parson. Copiez les fichiers parson.c et parson.h dans le dossier filtermodule.

   2. Open modules>filtermodule>CMakeLists.txt. Au début du fichier, importez les fichiers Parson sous la forme d’une bibliothèque appelée my_parson.

      add_library(my_parson
          parson.c
          parson.h
      )
      

   3. Ajoutez my_parson à la liste des bibliothèques de la fonction target_link_libraries de CMakeLists.txt.

   4. Enregistrez le fichier CMakeLists.txt.

   5. Ouvrez modules>filtermodule>main.c. Au bas de la liste des instructions include, ajoutez une nouvelle instruction afin d’inclure parson.h pour la prise en charge de JSON :

      #include "parson.h"
      

2. Dans le fichier main.c, ajoutez une variable globale appelée temperatureThreshold après la section include. Cette variable définit la valeur que la température mesurée doit dépasser pour que les données soient envoyées à IoT Hub.

   static double temperatureThreshold = 25;
   

3. Recherchez la fonction CreateMessageInstance dans le fichier main.c. Remplacez l’instruction if-else interne par le code suivant qui ajoute quelques lignes de fonctionnalités :

       if ((messageInstance->messageHandle = IoTHubMessage_Clone(message)) == NULL)
       {
           free(messageInstance);
           messageInstance = NULL;
       }
       else
       {
           messageInstance->messageTrackingId = messagesReceivedByInput1Queue;
           MAP_HANDLE propMap = IoTHubMessage_Properties(messageInstance->messageHandle);
           if (Map_AddOrUpdate(propMap, "MessageType", "Alert") != MAP_OK)
           {
              printf("ERROR: Map_AddOrUpdate Failed!\r\n");
           }
       }
   

   Les nouvelles lignes de code de l’instruction else ajoutent une propriété au message qui lui attribue une étiquette d’alerte. Ce code attribue une étiquette d’alerte à tous les messages, car nous allons ajouter une fonctionnalité qui n’envoie des messages à IoT Hub que si ceux-ci signalent des températures élevées.

4. Remplacez la totalité de la fonction InputQueue1Callback par le code suivant. Cette fonction implémente le filtre de messagerie réel. Lorsqu’un message est reçu, il vérifie si la température signalée dépasse le seuil défini. Si c’est le cas, il transfère le message vers sa file d’attente de sortie. Si ce n’est pas le cas, il ignore le message.

   static unsigned char *bytearray_to_str(const unsigned char *buffer, size_t len)
   {
       unsigned char *ret = (unsigned char *)malloc(len + 1);
       memcpy(ret, buffer, len);
       ret[len] = '\0';
       return ret;
   }
   
   static IOTHUBMESSAGE_DISPOSITION_RESULT InputQueue1Callback(IOTHUB_MESSAGE_HANDLE message, void* userContextCallback)
   {
       IOTHUBMESSAGE_DISPOSITION_RESULT result;
       IOTHUB_CLIENT_RESULT clientResult;
       IOTHUB_MODULE_CLIENT_LL_HANDLE iotHubModuleClientHandle = (IOTHUB_MODULE_CLIENT_LL_HANDLE)userContextCallback;
   
       unsigned const char* messageBody;
       size_t contentSize;
   
       if (IoTHubMessage_GetByteArray(message, &messageBody, &contentSize) == IOTHUB_MESSAGE_OK)
       {
           messageBody = bytearray_to_str(messageBody, contentSize);
       } else
       {
           messageBody = "<null>";
       }
   
       printf("Received Message [%zu]\r\n Data: [%s]\r\n",
               messagesReceivedByInput1Queue, messageBody);
   
       // Check if the message reports temperatures higher than the threshold
       JSON_Value *root_value = json_parse_string(messageBody);
       JSON_Object *root_object = json_value_get_object(root_value);
       double temperature;
       if (json_object_dotget_value(root_object, "machine.temperature") != NULL && (temperature = json_object_dotget_number(root_object, "machine.temperature")) > temperatureThreshold)
       {
           printf("Machine temperature %f exceeds threshold %f\r\n", temperature, temperatureThreshold);
           // This message should be sent to next stop in the pipeline, namely "output1".  What happens at "outpu1" is determined
           // by the configuration of the Edge routing table setup.
           MESSAGE_INSTANCE *messageInstance = CreateMessageInstance(message);
           if (NULL == messageInstance)
           {
               result = IOTHUBMESSAGE_ABANDONED;
           }
           else
           {
               printf("Sending message (%zu) to the next stage in pipeline\n", messagesReceivedByInput1Queue);
   
               clientResult = IoTHubModuleClient_LL_SendEventToOutputAsync(iotHubModuleClientHandle, messageInstance->messageHandle, "output1", SendConfirmationCallback, (void *)messageInstance);
               if (clientResult != IOTHUB_CLIENT_OK)
               {
                   IoTHubMessage_Destroy(messageInstance->messageHandle);
                   free(messageInstance);
                   printf("IoTHubModuleClient_LL_SendEventToOutputAsync failed on sending msg#=%zu, err=%d\n", messagesReceivedByInput1Queue, clientResult);
                   result = IOTHUBMESSAGE_ABANDONED;
               }
               else
               {
                   result = IOTHUBMESSAGE_ACCEPTED;
               }
           }
       }
       else
       {
           printf("Not sending message (%zu) to the next stage in pipeline.\r\n", messagesReceivedByInput1Queue);
           result = IOTHUBMESSAGE_ACCEPTED;
       }
   
       messagesReceivedByInput1Queue++;
       return result;
   }
   

5. Ajoutez une fonction moduleTwinCallback. Cette méthode reçoit des mises à jour sur les propriétés souhaitées à partir du double de module et met à jour la variable temperatureThreshold en conséquence. Tous les modules ont leur propre double, ce qui vous permet de configurer le code exécuté à l’intérieur d’un module directement à partir du cloud.

   static void moduleTwinCallback(DEVICE_TWIN_UPDATE_STATE update_state, const unsigned char* payLoad, size_t size, void* userContextCallback)
   {
       printf("\r\nTwin callback called with (state=%s, size=%zu):\r\n%s\r\n",
           MU_ENUM_TO_STRING(DEVICE_TWIN_UPDATE_STATE, update_state), size, payLoad);
       JSON_Value *root_value = json_parse_string(payLoad);
       JSON_Object *root_object = json_value_get_object(root_value);
       if (json_object_dotget_value(root_object, "desired.TemperatureThreshold") != NULL) {
           temperatureThreshold = json_object_dotget_number(root_object, "desired.TemperatureThreshold");
       }
       if (json_object_get_value(root_object, "TemperatureThreshold") != NULL) {
           temperatureThreshold = json_object_get_number(root_object, "TemperatureThreshold");
       }
   }
   

6. Recherchez la fonction SetupCallbacksForModule. Remplacez la fonction par le code suivant, qui ajoute une instruction if else pour vérifier si le jumeau de module est mis à jour.

   static int SetupCallbacksForModule(IOTHUB_MODULE_CLIENT_LL_HANDLE iotHubModuleClientHandle)
   {
       int ret;
   
       if (IoTHubModuleClient_LL_SetInputMessageCallback(iotHubModuleClientHandle, "input1", InputQueue1Callback, (void*)iotHubModuleClientHandle) != IOTHUB_CLIENT_OK)
       {
           printf("ERROR: IoTHubModuleClient_LL_SetInputMessageCallback(\"input1\")..........FAILED!\r\n");
           ret = MU_FAILURE;
       }
       else if (IoTHubModuleClient_LL_SetModuleTwinCallback(iotHubModuleClientHandle, moduleTwinCallback, (void*)iotHubModuleClientHandle) != IOTHUB_CLIENT_OK)
       {
           printf("ERROR: IoTHubModuleClient_LL_SetModuleTwinCallback(default)..........FAILED!\r\n");
           ret = MU_FAILURE;
       }
       else
       {
           ret = 0;
       }
   
       return ret;
   }
   

7. Enregistrez le fichier main.c.

8. Dans l’Explorateur Visual Studio Code, ouvrez le fichier deployment.template.json dans votre espace de travail de solution IoT Edge.

9. Ajoutez le jumeau de module filtermodule au manifeste de déploiement. Insérez le contenu JSON suivant en bas de la section moduleContent, après le jumeau de module $edgeHub :

   "filtermodule": {
       "properties.desired":{
           "TemperatureThreshold":25
       }
   }
   

10. Enregistrez le fichier deployment.template.json.

1. Dans l’Explorateur Visual Studio Code, ouvrez modules>filtermodule>src>main>java>com>edgemodule>App.java.

2. Ajoutez le code suivant au début du fichier pour importer de nouvelles classes référencées.

   import java.io.StringReader;
   import java.util.concurrent.atomic.AtomicLong;
   import java.util.HashMap;
   import java.util.Map;
   
   import javax.json.Json;
   import javax.json.JsonObject;
   import javax.json.JsonReader;
   
   import com.microsoft.azure.sdk.iot.device.DeviceTwin.Pair;
   import com.microsoft.azure.sdk.iot.device.DeviceTwin.Property;
   import com.microsoft.azure.sdk.iot.device.DeviceTwin.TwinPropertyCallBack;
   

3. Ajoutez la définition suivante dans la classe App. Cette variable définit un seuil de température. La température de machine mesurée n’est pas signalée à IoT Hub tant qu’elle ne dépasse pas cette valeur.

   private static final String TEMP_THRESHOLD = "TemperatureThreshold";
   private static AtomicLong tempThreshold = new AtomicLong(25);
   

4. Remplacez la méthode d’exécution de MessageCallbackMqtt par le code suivant. Cette méthode est appelée chaque fois que le module reçoit un message MQTT d’IoT Edge Hub. Il filtre les messages qui signalent des températures situées sous le seuil de température défini via le double de module.

   protected static class MessageCallbackMqtt implements MessageCallback {
       private int counter = 0;
       @Override
       public IotHubMessageResult execute(Message msg, Object context) {
           this.counter += 1;
   
           String msgString = new String(msg.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET);
           System.out.println(
                  String.format("Received message %d: %s",
                           this.counter, msgString));
           if (context instanceof ModuleClient) {
               try (JsonReader jsonReader = Json.createReader(new StringReader(msgString))) {
                   final JsonObject msgObject = jsonReader.readObject();
                   double temperature = msgObject.getJsonObject("machine").getJsonNumber("temperature").doubleValue();
                   long threshold = App.tempThreshold.get();
                   if (temperature >= threshold) {
                       ModuleClient client = (ModuleClient) context;
                       System.out.println(
                           String.format("Temperature above threshold %d. Sending message: %s",
                           threshold, msgString));
                       client.sendEventAsync(msg, eventCallback, msg, App.OUTPUT_NAME);
                   }
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
           return IotHubMessageResult.COMPLETE;
       }
   }
   

5. Ajoutez les deux classes internes statiques suivantes dans la classe App. Ces classes mettent à jour la variable tempThreshold quand la propriété souhaitée du jumeau de module change. Tous les modules ont leur propre module jumeau, ce qui vous permet de configurer le code exécuté à l’intérieur d’un module directement à partir du cloud.

   protected static class DeviceTwinStatusCallBack implements IotHubEventCallback {
       @Override
       public void execute(IotHubStatusCode status, Object context) {
           System.out.println("IoT Hub responded to device twin operation with status " + status.name());
       }
   }
   
   protected static class OnProperty implements TwinPropertyCallBack {
       @Override
       public void TwinPropertyCallBack(Property property, Object context) {
           if (!property.getIsReported()) {
               if (property.getKey().equals(App.TEMP_THRESHOLD)) {
                   try {
                       long threshold = Math.round((double) property.getValue());
                       App.tempThreshold.set(threshold);
                   } catch (Exception e) {
                       System.out.println("Faile to set TemperatureThread with exception");
                       e.printStackTrace();
                   }
               }
           }
       }
   }
   

6. Ajoutez les lignes suivantes à la méthode main après client.open() pour vous abonner aux mises à jour du jumeau de module.

   client.startTwin(new DeviceTwinStatusCallBack(), null, new OnProperty(), null);
   Map<Property, Pair<TwinPropertyCallBack, Object>> onDesiredPropertyChange = new HashMap<Property, Pair<TwinPropertyCallBack, Object>>() {
       {
           put(new Property(App.TEMP_THRESHOLD, null), new Pair<TwinPropertyCallBack, Object>(new OnProperty(), null));
       }
   };
   client.subscribeToTwinDesiredProperties(onDesiredPropertyChange);
   client.getTwin();
   

7. Enregistrez le fichier App.java.

8. Dans l’Explorateur Visual Studio Code, ouvrez le fichier deployment.template.json dans votre espace de travail de solution IoT Edge.

9. Ajoutez le jumeau de module filtermodule au manifeste de déploiement. Insérez le contenu JSON suivant en bas de la section moduleContent, après le jumeau de module $edgeHub :

     "filtermodule": {
         "properties.desired":{
             "TemperatureThreshold":25
         }
     }
   

10. Enregistrez le fichier deployment.template.json.

1. Dans l’Explorateur Visual Studio Code, ouvrez modules>filtermodule>app.js.

2. Ajoutez une variable de seuil de température au début de app.js. Le seuil de température définit la valeur que la température mesurée doit dépasser pour que les données soient envoyées à IoT Hub.

   var temperatureThreshold = 25;
   

3. Remplacer la fonction PipeMessage entièrement par la fonction FilterMessage.

   // This function filters out messages that report temperatures below the temperature threshold.
   // It also adds the MessageType property to the message with the value set to Alert.
   function filterMessage(client, inputName, msg) {
       client.complete(msg, printResultFor('Receiving message'));
       if (inputName === 'input1') {
           var message = msg.getBytes().toString('utf8');
           var messageBody = JSON.parse(message);
           if (messageBody && messageBody.machine && messageBody.machine.temperature && messageBody.machine.temperature > temperatureThreshold) {
               console.log(`Machine temperature ${messageBody.machine.temperature} exceeds threshold ${temperatureThreshold}`);
               var outputMsg = new Message(message);
               outputMsg.properties.add('MessageType', 'Alert');
               client.sendOutputEvent('output1', outputMsg, printResultFor('Sending received message'));
           }
       }
   }
   
   

4. Remplacez le nom de fonction pipeMessage avec filterMessage dans l’appel client.on().

   client.on('inputMessage', function (inputName, msg) {
       filterMessage(client, inputName, msg);
       });
   

5. Copiez l’extrait de code suivant dans le fonction de rappel client.open(), une fois client.on() à l’intérieur de l’instruction else. Cette fonction sera appelée après la mise à jour des propriétés souhaitées.

   client.getTwin(function (err, twin) {
       if (err) {
           console.error('Error getting twin: ' + err.message);
       } else {
           twin.on('properties.desired', function(delta) {
               if (delta.TemperatureThreshold) {
                   temperatureThreshold = delta.TemperatureThreshold;
               }
           });
       }
   });
   

6. Enregistrez le fichier app.js.

7. Dans l’Explorateur Visual Studio Code, ouvrez le fichier deployment.template.json dans votre espace de travail de solution IoT Edge.

8. Ajoutez le jumeau de module filtermodule au manifeste de déploiement. Insérez le contenu JSON suivant en bas de la section moduleContent, après le jumeau de module $edgeHub :

     "filtermodule": {
         "properties.desired":{
             "TemperatureThreshold":25
         }
     }
   

9. Enregistrez le fichier deployment.template.json.

Dans cette section, ajoutez le code qui développe le module filtermodule pour analyser les messages avant de les envoyer. Vous ajoutez du code qui filtre les messages dont la température de machine signalée se situe dans les limites acceptables.

1. Dans l’Explorateur Visual Studio Code, ouvrez modules>filtermodule>main.py.

2. En haut du fichier main.py, importez la bibliothèque json :

   import json
   

3. Ajoutez des définitions globales pour les variables TEMPERATURE_THRESHOLD, RECEIVED_MESSAGES et TWIN_CALLBACKS. Le seuil de température définit la valeur que la température de la machine mesurée doit dépasser pour que les données soient envoyées au hub IoT.

   # global counters
   TEMPERATURE_THRESHOLD = 25
   TWIN_CALLBACKS = 0
   RECEIVED_MESSAGES = 0
   

4. Remplacez la fonction create_client par le code suivant :

   def create_client():
       client = IoTHubModuleClient.create_from_edge_environment()
   
       # Define function for handling received messages
       async def receive_message_handler(message):
           global RECEIVED_MESSAGES
           print("Message received")
           size = len(message.data)
           message_text = message.data.decode('utf-8')
           print("    Data: <<<{data}>>> & Size={size}".format(data=message.data, size=size))
           print("    Properties: {}".format(message.custom_properties))
           RECEIVED_MESSAGES += 1
           print("Total messages received: {}".format(RECEIVED_MESSAGES))
   
           if message.input_name == "input1":
               message_json = json.loads(message_text)
               if "machine" in message_json and "temperature" in message_json["machine"] and message_json["machine"]["temperature"] > TEMPERATURE_THRESHOLD:
                   message.custom_properties["MessageType"] = "Alert"
                   print("ALERT: Machine temperature {temp} exceeds threshold {threshold}".format(
                       temp=message_json["machine"]["temperature"], threshold=TEMPERATURE_THRESHOLD
                   ))
                   await client.send_message_to_output(message, "output1")
   
       # Define function for handling received twin patches
       async def receive_twin_patch_handler(twin_patch):
           global TEMPERATURE_THRESHOLD
           global TWIN_CALLBACKS
           print("Twin Patch received")
           print("     {}".format(twin_patch))
           if "TemperatureThreshold" in twin_patch:
               TEMPERATURE_THRESHOLD = twin_patch["TemperatureThreshold"]
           TWIN_CALLBACKS += 1
           print("Total calls confirmed: {}".format(TWIN_CALLBACKS))
   
       try:
           # Set handler on the client
           client.on_message_received = receive_message_handler
           client.on_twin_desired_properties_patch_received = receive_twin_patch_handler
       except:
           # Cleanup if failure occurs
           client.shutdown()
           raise
   
       return client
   

5. Enregistrez le fichier main.py.

6. Dans l’Explorateur Visual Studio Code, ouvrez le fichier deployment.template.json dans votre espace de travail de solution IoT Edge.

7. Ajoutez le jumeau de module filtermodule au manifeste de déploiement. Insérez le contenu JSON suivant en bas de la section modulesContent, après le jumeau de module $edgeHub:

       "filtermodule": {
           "properties.desired":{
               "TemperatureThreshold":25
           }
       }
   

8. Enregistrez le fichier deployment.template.json.