Tutorial: Desenvolver módulos IoT Edge usando Visual Studio Code

• .NET Core SDK
• Extensão do Visual Studio Code C#

• Extensão C/C++ para Visual Studio Code
• A instalação do SDK do Azure IoT C não é necessária para este tutorial, mas pode fornecer funcionalidades úteis, como IntelliSense e definições de programa de leitura. Para obter informações de instalação, consulte Azure IoT SDKs e Bibliotecas C.

• Java SE Development Kit 11 e Maven. Você precisará definir a JAVA_HOME variável de ambiente para apontar para a sua instalação do JDK.
• Maven
• Java Extension Pack para Visual Studio Code

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

Para desenvolver um módulo IoT Edge no Python, instale estes pré-requisitos extras em seu computador de desenvolvimento:

• Python e Pip.
• Cookiecutter.
• extensão Python para Visual Studio Code.

O código C# de exemplo que vem com o modelo de projeto usa a classe ModuleClient do SDK do IoT Hub para .NET.

1. No Visual Studio Code Explorer, abra modules > filtermodule > ModuleBackgroundService.cs.

2. Antes do filtermodule namespace, adicione três using instruções para tipos usados posteriormente:

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

3. Adicione a temperatureThreshold variável à ModuleBackgroundService classe. Essa variável define o valor que a temperatura medida deve exceder para que os dados sejam enviados para o IoT Hub.

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

4. Adicione as classes MessageBody, Machine e Ambient. Essas classes definem o esquema esperado para o corpo de mensagens de entrada.

   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. Localize a função ExecuteAsync. Essa função cria e configura um objeto ModuleClient que permite que o módulo se conecte ao runtime de Azure IoT Edge local para enviar e receber mensagens. Depois de criar o ModuleClient, o código lê o valor temperatureThreshold das propriedades desejadas do módulo gêmeo. O código registra um callback para receber mensagens de um hub IoT Edge via um endpoint chamado input1.

   Substitua a chamada para o método ProcessMessageAsync por uma nova que atualize o nome do ponto de extremidade e o método chamado quando a entrada chega. Além disso, adicione um SetDesiredPropertyUpdateCallbackAsync método para atualizações às propriedades desejadas. Para fazer essa alteração, substitua a última linha do ExecuteAsync método pelo seguinte código:

   // 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. Adicione o OnDesiredPropertiesUpdate método à ModuleBackgroundService classe. Esse método recebe atualizações nas propriedades desejadas do módulo gêmeo e atualiza a temperatureThreshold variável para corresponder. Todos os módulos possuem seu próprio módulo gêmeo, o que permite configurar o código em execução dentro de um módulo diretamente da nuvem.

   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. Adicione o método FilterMessages. Esse método é chamado sempre que o módulo recebe uma mensagem do hub IoT Edge. Ele filtra as mensagens que reportam temperaturas abaixo do limite de temperatura definido através do módulo gêmeo. Ele também adiciona a MessageType propriedade à mensagem com o valor definido como Alert:

   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. Salve o arquivo ModuleBackgroundService.cs.

9. No Visual Studio Code Explorer, abra o arquivo deployment.template.json no workspace da solução IoT Edge.

10. Como alteramos o nome do ponto de extremidade que o módulo escuta, também precisamos atualizar as rotas no manifesto de implantação para que o edgeHub envie mensagens para o novo ponto de extremidade.

    Localize a routes seção no módulo gêmeo $edgeHub . Atualize a rota sensorTofiltermodule para substituir input1 por inputFromSensor:

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

11. Adicione o módulo gêmeo filtermodule ao manifesto de implantação. Insira o seguinte conteúdo JSON na parte inferior da modulesContent seção, após o módulo gêmeo $edgeHub:

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

12. Salve o arquivo deployment.template.json.

1. Os dados do sensor nesse cenário são fornecidos no formato JSON. Para filtrar as mensagens no formato JSON, importe uma biblioteca JSON para C. Este tutorial utiliza Parson.

   1. Baixe o repositório GitHub Parson. Copie os arquivos parson.c e parson.h para a pasta filtermodule.

   2. Abrir módulos > filtermodule > CMakeLists.txt. Na parte superior do arquivo, importe os arquivos Parson como uma biblioteca chamada my_parson:

      add_library(my_parson
          parson.c
          parson.h
      )
      

   3. Adicione my_parson à lista de bibliotecas na target_link_libraries função de CMakeLists.txt.

   4. Salve o arquivo CMakeLists.txt.

   5. Abra módulos > filtermodule > main.c. Na parte inferior da lista de include declarações, adicione uma nova para incluir parson.h suporte JSON.

      #include "parson.h"
      

2. No arquivo main.c , adicione uma variável global chamada temperatureThreshold após a include seção. Essa variável define o valor que a temperatura medida deve exceder para que os dados sejam enviados para IoT Hub:

   static double temperatureThreshold = 25;
   

3. Localize a CreateMessageInstance função em main.c. Substitua a instrução interna if-else pelo código a seguir que adiciona algumas linhas de funcionalidade:

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

   As novas linhas de código na else instrução adicionam uma nova propriedade à mensagem, que rotula a mensagem como um alerta. Esse código rotula todas as mensagens como alertas, pois adicionaremos funcionalidades que só enviam mensagens para IoT Hub se relatarem altas temperaturas.

4. Substitua toda a função InputQueue1Callback pelo seguinte código. Essa função implementa o filtro de mensagens real. Quando uma mensagem é recebida, ela verifica se a temperatura relatada excede o limite. Caso isso aconteça, ele encaminha a mensagem através de sua fila de saída. Caso contrário, ignorará a mensagem:

   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 "output1" 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. Adicione uma função moduleTwinCallback. Esse método recebe atualizações nas propriedades desejadas do módulo gêmeo e atualiza a temperatureThreshold variável para corresponder. Todos os módulos têm seu próprio módulo gêmeo, o que permite configurar o código em execução dentro de um módulo diretamente da nuvem:

   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. Localize a função SetupCallbacksForModule. Substitua a função pelo código a seguir que adiciona uma instrução else if para verificar se o módulo gêmeo está atualizado:

   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. Salve o arquivo main.c.

8. No Visual Studio Code Explorer, abra o arquivo deployment.template.json no workspace da solução IoT Edge.

9. Adicione o módulo gêmeo filtermodule ao manifesto de implantação. Insira o seguinte conteúdo JSON na parte inferior da seção moduleContent, após o módulo gêmeo do $edgeHub:

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

10. Salve o arquivo deployment.template.json.

1. No Visual Studio Code Explorador, abra modules > filtermodule > src > main > java > com > edgemodule > App.java.

2. Adicione o seguinte código na parte superior do arquivo para importar novas classes referenciadas.

   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. Adicione a definição a seguir à App classe. Essa variável define um limite de temperatura. A temperatura medida do computador não é relatada para IoT Hub até exceder esse valor:

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

4. Substitua o método execute de MessageCallbackMqtt pelo código a seguir. Esse método é chamado sempre que o módulo recebe uma mensagem MQTT do hub IoT Edge. Ele filtra mensagens que relatam temperaturas abaixo do limite de temperatura definido por meio do módulo gêmeo:

   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. Adicione as duas classes internas estáticas a seguir à App classe. Essas classes atualizam a tempThreshold variável quando a propriedade desejada do módulo gêmeo é alterada. Todos os módulos têm seu próprio módulo gêmeo, o que permite configurar o código em execução dentro de um módulo diretamente da nuvem:

   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("Failed to set TemperatureThread with exception");
                       e.printStackTrace();
                   }
               }
           }
       }
   }
   

6. Adicione as seguintes linhas ao método main depois de client.open() para se inscrever nas atualizações do módulo gêmeo:

   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. Salve o arquivo App.java.

8. No Visual Studio Code Explorer, abra o arquivo deployment.template.json no workspace da solução IoT Edge.

9. Adicione o módulo gêmeo filtermodule ao manifesto de implantação. Insira o seguinte conteúdo JSON na parte inferior da moduleContent seção, após o módulo gêmeo $edgeHub:

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

10. Salve o arquivo deployment.template.json.

1. No explorador do Visual Studio Code, abra modules > filtermodule > app.js.

2. Adicione uma variável de limite de temperatura ao início de app.js. O limite de temperatura define o valor que a temperatura medida deve exceder para que os dados sejam enviados para IoT Hub:

   var temperatureThreshold = 25;
   

3. Substitua a função PipeMessage pela função 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. Substitua o nome da função pipeMessage por filterMessage na chamada client.on().

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

5. Copie o código a seguir para a função de retorno de chamada client.open(), depois de client.on() na instrução else. Essa função é invocada quando as propriedades desejadas são atualizadas:

   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. Salve o arquivo app.js .

7. No Visual Studio Code Explorer, abra o arquivo deployment.template.json no workspace da solução IoT Edge.

8. Adicione o módulo gêmeo filtermodule ao manifesto de implantação. Insira o seguinte conteúdo JSON na parte inferior da seção moduleContent, após o módulo gêmeo do $edgeHub:

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

9. Salve o arquivo deployment.template.json.

Nesta seção, adicione o código que expande o filtermodule para analisar as mensagens antes de enviá-las. Você adicionará código que filtra as mensagens em que a temperatura do computador reportada está dentro dos limites aceitáveis.

1. No explorador do Visual Studio Code, abra modules > filtermodule > main.py.

2. No início do arquivo main.py, importe a biblioteca json:

   import json
   

3. Adicione definições globais para as variáveis TEMPERATURE_THRESHOLD, RECEIVED_MESSAGES e TWIN_CALLBACKS . O limite de temperatura define o valor que a temperatura medida do computador deve exceder para que os dados sejam enviados para o IoT Hub:

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

4. Substitua a create_client função pelo seguinte código:

   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. Salve o arquivo main.py.

6. No Visual Studio Code Explorer, abra o arquivo deployment.template.json no workspace da solução IoT Edge.

7. Adicione o módulo gêmeo filtermodule ao manifesto de implantação. Insira o seguinte conteúdo JSON na parte inferior da modulesContent seção, após o módulo gêmeo $edgeHub:

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

8. Salve o arquivo deployment.template.json.