Skip to content

tutorial-develop-for-linux.md

Latest commit

 

History

History
1312 lines (956 loc) · 65.1 KB

tutorial-develop-for-linux.md

File metadata and controls

1312 lines (956 loc) · 65.1 KB
title Develop Azure IoT Edge modules using Visual Studio Code tutorial
description Develop IoT Edge modules with Visual Studio Code: Follow step-by-step instructions to create, build, and deploy modules using Azure IoT Edge tools.
author sethmanheim
ms.author sethm
ms.date 02/26/2026
ms.topic tutorial
ms.service azure-iot-edge
services iot-edge
zone_pivot_groups iotedge-dev
content_well_notification
AI-contribution
ai-usage ai-assisted
ms.custom
linux-related-content
ai-gen-docs-bap
ai-gen-description
ai-seo-date:05/16/2025
build-2025
sfi-image-nochange
sfi-ropc-nochange

Tutorial: Develop IoT Edge modules using Visual Studio Code

[!INCLUDE iot-edge-version-all-supported]

This tutorial shows how to develop and deploy your code to an IoT Edge device. Azure IoT Edge modules enable you to deploy code that runs your business logic directly on your IoT Edge device. In the Deploy code to a Linux device quickstart, you set up an IoT Edge device and deployed a module from the Azure Marketplace.

This article describes the steps for two IoT Edge development tools:

  • Azure IoT Edge Dev Tool command-line (CLI), which is preferred for development.
  • Azure IoT Edge tools for Visual Studio Code extension, which is in maintenance mode.

Use the tool selector button at the beginning of this article to choose your tool.

In this tutorial, you learn how to:

[!div class="checklist"]

  • Set up your development machine
  • Use the IoT Edge tools to create a new project
  • Build your project as a Docker container and store it in an Azure container registry
  • Deploy your code to an IoT Edge device

The IoT Edge module you create in this tutorial filters the temperature data your device generates. It sends messages upstream only if the temperature is above a set threshold. This kind of analysis at the edge helps reduce the amount of data sent to and stored in the cloud.

Prerequisites

A development machine:

  • Use your own computer or a virtual machine.
  • Make sure your development machine supports nested virtualization to run a container engine.
  • You can use most operating systems that run a container engine to develop IoT Edge modules for Linux devices. This tutorial uses a Windows computer, but it also points out known differences on macOS or Linux.
  • Install Visual Studio Code
  • Install the Azure CLI.

An Azure IoT Edge device:

Cloud resources:

[!INCLUDE quickstarts-free-trial-note]

Tip

For guidance on interactive debugging in Visual Studio Code or Visual Studio 2022:

This tutorial covers development steps for Visual Studio Code.

Key concepts

This tutorial walks through developing an IoT Edge module. An IoT Edge module is a container with executable code. You can deploy one or more modules to an IoT Edge device. Modules do specific tasks like ingesting data from sensors, cleaning and analyzing data, or sending messages to an IoT Hub. For more information, see Understand Azure IoT Edge modules.

When you develop IoT Edge modules, you should understand the difference between the development machine and the target IoT Edge device where the module deploys. The container you build to hold your module code must match the operating system (OS) of the target device. For example, the most common scenario is developing a module on a Windows computer to target a Linux device running IoT Edge. In that case, the container operating system is Linux. As you go through this tutorial, keep in mind the difference between the development machine OS and the container OS.

Tip

If you're using IoT Edge for Linux on Windows, the target device in your scenario is the Linux virtual machine, not the Windows host.

This tutorial targets devices running IoT Edge with Linux containers. Use your preferred operating system as long as your development machine runs Linux containers. Visual Studio Code is recommended for developing with Linux containers, so this tutorial uses it. You can use Visual Studio as well, although there are differences in support between the two tools.

The following table lists supported development scenarios for Linux containers in Visual Studio Code and Visual Studio.

Visual Studio Code Visual Studio 2019/2022
Linux device architecture Linux AMD64
Linux ARM32v7
Linux ARM64		 Linux AMD64
Linux ARM32
Linux ARM64
Azure services Azure Functions
Azure Stream Analytics
Azure Machine Learning
Languages C
C#
Java
Node.js
Python		 C
C#
More information Azure IoT Edge for Visual Studio Code Azure IoT Edge Tools for Visual Studio 2019
Azure IoT Edge Tools for Visual Studio 2022

Install container engine

IoT Edge modules are packaged as containers, so you need a Docker compatible container management system on your development machine to build and manage them. Docker Desktop is a popular choice for development because it has strong feature support. Docker Desktop on Windows lets you switch between Linux containers and Windows containers, so you can develop modules for different types of IoT Edge devices.

Use the Docker documentation to install Docker on your development machine:

Set up tools

::: zone pivot="iotedge-dev-cli"

Install the Python-based Azure IoT Edge Dev Tool to create your IoT Edge solution. You have two options:

::: zone-end

::: zone pivot="iotedge-dev-ext"

Important

The Azure IoT Edge tools for Visual Studio Code extension is in maintenance mode. The preferred development tool is the command-line (CLI) Azure IoT Edge Dev Tool.

Use the IoT extensions for Visual Studio Code to develop IoT Edge modules. These extensions offer project templates, automate the creation of the deployment manifest, and let you monitor and manage IoT Edge devices. In this section, you install Visual Studio Code and the IoT extension, then set up your Azure account to manage IoT Hub resources from within Visual Studio Code.

  1. Install Azure IoT Edge extension.
  2. Install Azure IoT Hub extension.
  3. After you install the extensions, open the command palette by selecting View > Command Palette.
  4. In the command palette, search for and select Azure IoT Hub: Select IoT Hub. Follow the prompts to select your Azure subscription and IoT Hub.
  5. Open the explorer section of Visual Studio Code by selecting the icon in the activity bar or by selecting View > Explorer.
  6. At the bottom of the explorer section, expand the collapsed Azure IoT Hub / Devices menu. You see the devices and IoT Edge devices associated with the IoT Hub that you selected through the command palette.

::: zone-end

Install language specific tools

Install tools specific to the language you're developing in:

C#

C

Java

Tip

The Java and Maven installation processes add environment variables to your system. Restart any open Visual Studio Code terminal, PowerShell, or command prompt instances after you finish installation. This step makes sure these utilities recognize the Java and Maven commands.

Node.js

Python

To develop an IoT Edge module in Python, install these extra prerequisites on your development machine:

Note

Make sure your bin folder is on your path for your platform. Typically, it's ~/.local/ for UNIX and macOS, or %APPDATA%\Python on Windows.

[!INCLUDE iot-edge-create-container-registry]

Create a new module project

The Azure IoT Edge extension offers project templates for all supported IoT Edge module languages in Visual Studio Code. These templates include all the files and code you need to deploy a working module to test IoT Edge, or give you a starting point to customize the template with your own business logic.

Create a project template

::: zone pivot="iotedge-dev-cli"

The IoT Edge Dev Tool simplifies Azure IoT Edge development, with commands driven by environment variables. It helps you get started with IoT Edge development using the IoT Edge Dev Container and IoT Edge solution scaffolding that includes a default module and all the required configuration files.

  1. Create a directory for your solution at the path you want. Change to your iotedgesolution directory.

    mkdir c:\dev\iotedgesolution
cd c:\dev\iotedgesolution

  2. Use the iotedgedev solution init command to create a solution and set up your Azure IoT Hub in the development language of your choice:

    C#

    iotedgedev solution init --template csharp

    C

    iotedgedev solution init --template c

    Java

    iotedgedev solution init --template java

    Node.js

    iotedgedev solution init --template nodejs

    Python

    iotedgedev solution init --template python

The iotedgedev solution init command prompts you to complete several steps, including:

  • Authenticate to Azure
  • Choose an Azure subscription
  • Choose or create a resource group
  • Choose or create an Azure IoT Hub
  • Choose or create an Azure IoT Edge device

::: zone-end

::: zone pivot="iotedge-dev-ext"

Use Visual Studio Code and the Azure IoT Edge extension. Start by creating a solution, then generate the first module in that solution. Each solution can include multiple modules.

  1. Select View > Command Palette.
  2. In the command palette, enter and run the command Azure IoT Edge: New IoT Edge Solution.
  3. Browse to the folder where you want to create the new solution, then select Select folder.
  4. Enter a name for your solution.
  5. Select a module template for your preferred development language to be the first module in the solution.
  6. Enter a name for your module. Choose a name that's unique within your container registry.
  7. Enter the name of the module's image repository. Visual Studio Code autopopulates the module name with localhost:5000/<your module name>. Replace it with your own registry information. Use localhost if you use a local Docker registry for testing. If you use Azure Container Registry, use Login server from your registry's settings. The sign-in server looks like <registry name>.azurecr.io. Only replace the localhost:5000 part of the string, so that the final result looks like <registry name>.azurecr.io/<your module name>.

Visual Studio Code takes the information you provided, creates an IoT Edge solution, and then loads it in a new window.

::: zone-end

After you create the solution, these main files are in the solution:

  • The .vscode folder includes the configuration file launch.json.

  • The modules folder has subfolders for each module. In each subfolder, the module.json file controls how modules are built and deployed.

  • The .env file lists your environment variables. The environment variable for the container registry is localhost:5000 by default.

  • Two module deployment files, deployment.template.json and deployment.debug.template.json, list the modules to deploy to your device. By default, the list includes the IoT Edge system modules (edgeAgent and edgeHub) and sample modules such as:

    [!NOTE] The exact modules installed can depend on your language of choice.

::: zone pivot="iotedge-dev-cli"

Set IoT Edge runtime version

The latest stable IoT Edge system module version is 1.5. Set your system modules to version 1.5.

  1. In Visual Studio Code, open the deployment.template.json deployment manifest file. The deployment manifest is a JSON document that describes the modules to be configured on the targeted IoT Edge device.

  2. Change the runtime version for the system runtime module images edgeAgent and edgeHub. For example, if you want to use the IoT Edge runtime version 1.5, change the following lines in the deployment manifest file:

    "systemModules": {
    "edgeAgent": {

        "image": "mcr.microsoft.com/azureiotedge-agent:1.5",

    "edgeHub": {

        "image": "mcr.microsoft.com/azureiotedge-hub:1.5",

::: zone-end

::: zone pivot="iotedge-dev-ext"

Provide your registry credentials to the IoT Edge agent

The environment file stores the credentials for your container registry and shares them with the IoT Edge runtime. The runtime needs these credentials to pull your container images to the IoT Edge device.

The IoT Edge extension tries to pull your container registry credentials from Azure and populate them in the environment file.

Note

The environment file is only created if you provide an image repository for the module. If you accepted the localhost defaults to test and debug locally, then you don't need to declare environment variables.

Check if your credentials exist. If not, add them now:

  1. If Azure Container Registry is your registry, set an Azure Container Registry username and password. Get these values from your container registry's Settings > Access keys menu in the Azure portal.

  2. Open the .env file in your module solution.

  3. Add the username and password values that you copied from your Azure container registry. For example:

    CONTAINER_REGISTRY_SERVER="myacr.azurecr.io"
CONTAINER_REGISTRY_USERNAME="myacr"
CONTAINER_REGISTRY_PASSWORD="<registry_password>"

  4. Save your changes to the .env file.

Note

This tutorial uses administrator credentials for Azure Container Registry that are convenient for development and test scenarios. When you're ready for production scenarios, we recommend a least-privileged authentication option like service principals or repository-scoped tokens. For more information, see Manage access to your container registry.

::: zone-end

Target architecture

Select the architecture you're targeting with each solution, because that affects how the container is built and runs. The default is Linux AMD64. For this tutorial, use an Ubuntu virtual machine as the IoT Edge device and keep the default amd64.

If you need to change the target architecture for your solution, follow these steps.

::: zone pivot="iotedge-dev-ext"

  1. Open the command palette and search for Azure IoT Edge: Set Default Target Platform for Edge Solution, or select the shortcut icon in the sidebar at the bottom of the window.
  2. In the command palette, select the target architecture from the list of options.

::: zone-end

::: zone pivot="iotedge-dev-cli"

C#

The target architecture is set when you create the container image in a later step.

C, Java, Node.js, Python

  1. Open or create settings.json in the .vscode directory of your solution.

  2. Change the platform value to amd64, arm32v7, arm64v8, or windows-amd64. For example:

    {
    "azure-iot-edge.defaultPlatform": {
        "platform": "amd64",
        "alias": null
    }
}

::: zone-end

Update module with custom code

Each template includes sample code that takes simulated sensor data from the SimulatedTemperatureSensor module and routes it to the IoT Hub. The sample module receives messages and passes them on. The pipeline functionality shows an important concept in IoT Edge: how modules communicate with each other.

Each module can have multiple input and output queues declared in its code. The IoT Edge hub running on the device routes messages from the output of one module to the input of one or more modules. The specific code for declaring inputs and outputs varies between languages, but the concept is the same for all modules. For more information about routing between modules, see Declare routes.

C#

The sample C# code that comes with the project template uses the ModuleClient class from the IoT Hub SDK for .NET.

  1. In the Visual Studio Code explorer, open modules > filtermodule > ModuleBackgroundService.cs.

  2. Before the filtermodule namespace, add three using statements for types that are used later:

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

  3. Add the temperatureThreshold variable to the ModuleBackgroundService class. This variable sets the value that the measured temperature must exceed for the data to be sent to the IoT Hub.

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

  4. Add the MessageBody, Machine, and Ambient classes. These classes define the expected schema for the body of incoming messages.

    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. Find the ExecuteAsync function. This function creates and configures a ModuleClient object that allows the module to connect to the local Azure IoT Edge runtime to send and receive messages. After creating the ModuleClient, the code reads the temperatureThreshold value from the module twin's desired properties. The code registers a callback to receive messages from an IoT Edge hub via an endpoint called input1.

    Replace the call to the ProcessMessageAsync method with a new one that updates the name of the endpoint and the method that's called when input arrives. Also, add a SetDesiredPropertyUpdateCallbackAsync method for updates to the desired properties. To make this change, replace the last line of the ExecuteAsync method with the following code:

    // 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. Add the OnDesiredPropertiesUpdate method to the ModuleBackgroundService class. This method receives updates on the desired properties from the module twin, and updates the temperatureThreshold variable to match. All modules have their own module twin, which lets you configure the code that's running inside a module directly from the 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. Add the FilterMessages method. This method is called whenever the module receives a message from the IoT Edge hub. It filters out messages that report temperatures below the temperature threshold set via the module twin. It also adds the MessageType property to the message with the value set to 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. Save the ModuleBackgroundService.cs file.

  9. In the Visual Studio Code explorer, open the deployment.template.json file in your IoT Edge solution workspace.

  10. Since we changed the name of the endpoint that the module listens on, we also need to update the routes in the deployment manifest so that the edgeHub sends messages to the new endpoint.

    Find the routes section in the $edgeHub module twin. Update the sensorTofiltermodule route to replace input1 with inputFromSensor:

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

  11. Add the filtermodule module twin to the deployment manifest. Insert the following JSON content at the bottom of the modulesContent section, after the $edgeHub module twin:

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

  12. Save the deployment.template.json file.

C

  1. The data from the sensor in this scenario comes in JSON format. To filter messages in JSON format, import a JSON library for C. This tutorial uses Parson.

    1. Download the Parson GitHub repository. Copy the parson.c and parson.h files into the filtermodule folder.

    2. Open modules > filtermodule > CMakeLists.txt. At the top of the file, import the Parson files as a library called my_parson:

      add_library(my_parson
    parson.c
    parson.h
)

    3. Add my_parson to the list of libraries in the target_link_libraries function of CMakeLists.txt.

    4. Save the CMakeLists.txt file.

    5. Open modules > filtermodule > main.c. At the bottom of the list of include statements, add a new one to include parson.h for JSON support:

      #include "parson.h"

  2. In the main.c file, add a global variable called temperatureThreshold after the include section. This variable sets the value that the measured temperature must exceed in order for the data to be sent to IoT Hub:

    static double temperatureThreshold = 25;

  3. Find the CreateMessageInstance function in main.c. Replace the inner if-else statement with the following code that adds a few lines of functionality:

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

    The new lines of code in the else statement add a new property to the message, which labels the message as an alert. This code labels all messages as alerts, because we'll add functionality that only sends messages to IoT Hub if they report high temperatures.

  4. Replace the entire InputQueue1Callback function with the following code. This function implements the actual messaging filter. When a message is received, it checks whether the reported temperature exceeds the threshold. If it does, then it forwards the message through its output queue. If not, then it ignores the 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 "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. Add a moduleTwinCallback function. This method receives updates on the desired properties from the module twin, and updates the temperatureThreshold variable to match. All modules have their own module twin, which lets you configure the code running inside a module directly from the 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. Find the SetupCallbacksForModule function. Replace the function with the following code that adds an else if statement to check if the module twin is updated:

    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. Save the main.c file.

  8. In the Visual Studio Code explorer, open the deployment.template.json file in your IoT Edge solution workspace.

  9. Add the filtermodule module twin to the deployment manifest. Insert the following JSON content at the bottom of the moduleContent section, after the $edgeHub module twin:

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

  10. Save the deployment.template.json file.

Java

  1. In the Visual Studio Code explorer, open modules > filtermodule > src > main > java > com > edgemodule > App.java.

  2. Add the following code at the top of the file to import new referenced classes.

    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. Add the following definition into the App class. This variable sets a temperature threshold. The measured machine temperature isn't reported to IoT Hub until it exceeds this value:

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

  4. Replace the execute method of MessageCallbackMqtt with the following code. This method is called whenever the module receives an MQTT message from the IoT Edge hub. It filters out messages that report temperatures below the temperature threshold set via the module twin:

    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. Add the following two static inner classes into the App class. These classes update the tempThreshold variable when the module twin's desired property changes. All modules have their own module twin, which lets you configure the code that's running inside a module directly from the 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("Failed to set TemperatureThread with exception");
                    e.printStackTrace();
                }
            }
        }
    }
}

  6. Add the following lines to the main method after client.open() to subscribe the module twin updates:

    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. Save the App.java file.

  8. In the Visual Studio Code explorer, open the deployment.template.json file in your IoT Edge solution workspace.

  9. Add the filtermodule module twin to the deployment manifest. Insert the following JSON content at the bottom of the moduleContent section, after the $edgeHub module twin:

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

  10. Save the deployment.template.json file.

Node.js

  1. In the Visual Studio Code explorer, open modules > filtermodule > app.js.

  2. Add a temperature threshold variable to the beginning of app.js. The temperature threshold sets the value that the measured temperature must exceed in order for the data to be sent to IoT Hub:

    var temperatureThreshold = 25;

  3. Replace the entire PipeMessage function with the FilterMessage function.

    // 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. Replace the function name pipeMessage with filterMessage in the client.on() call:

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

  5. Copy the following code into the client.open() function callback, after client.on() inside the else statement. This function is invoked when the desired properties are updated:

    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. Save the app.js file.

  7. In the Visual Studio Code explorer, open the deployment.template.json file in your IoT Edge solution workspace.

  8. Add the filtermodule module twin to the deployment manifest. Insert the following JSON content at the bottom of the moduleContent section, after the $edgeHub module twin:

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

  9. Save the deployment.template.json file.

Python

In this section, add the code that expands the filtermodule to analyze the messages before sending them. You add code that filters messages where the reported machine temperature is within the acceptable limits.

  1. In the Visual Studio Code explorer, open modules > filtermodule > main.py.

  2. At the top of the main.py file, import the json library:

    import json

  3. Add global definitions for the TEMPERATURE_THRESHOLD, RECEIVED_MESSAGES and TWIN_CALLBACKS variables. The temperature threshold sets the value that the measured machine temperature must exceed for the data to be sent to the IoT Hub:

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

  4. Replace the create_client function with the following code:

    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. Save the main.py file.

  6. In the Visual Studio Code explorer, open the deployment.template.json file in your IoT Edge solution workspace.

  7. Add the filtermodule module twin to the deployment manifest. Insert the following JSON content at the bottom of the modulesContent section, after the $edgeHub module twin:

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

  8. Save the deployment.template.json file.

Build and push your solution

You updated the module code and the deployment template to help understand some key deployment concepts. Now, you're ready to build your module container image and push it to your container registry.

In Visual Studio Code, open the deployment.template.json deployment manifest file. The deployment manifest describes the modules to be configured on the targeted IoT Edge device. Before deployment, you must update your Azure Container Registry credentials and your module images with the proper createOptions values. For more information about createOptions values, see How to configure container create options for IoT Edge modules.

::: zone pivot="iotedge-dev-cli"

If you use an Azure Container Registry to store your module image, add your credentials to the modulesContent > edgeAgent > settings > registryCredentials section in deployment.template.json. Replace myacr with your own registry name and provide your password and login server address. For example:

"registryCredentials": {
    "myacr": {
        "username": "myacr",
        "password": "<your_acr_password>",
        "address": "myacr.azurecr.io"
    }
}

Add or replace the following stringified content to the createOptions value for each system (edgeHub and *edgeAgent) and custom module (filtermodule and tempSensor) listed. Change the values if necessary:

"createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"

For example, the filtermodule configuration should be similar to:

"filtermodule": {
"version": "1.0",
"type": "docker",
"status": "running",
"restartPolicy": "always",
"settings": {
   "image": "myacr.azurecr.io/filtermodule:0.0.1-amd64",
   "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
}

Build module Docker image

Open the Visual Studio Code integrated terminal by selecting Terminal > New Terminal.

C#

Use the dotnet publish command to build the container image for Linux and amd64 architecture. Change directory to the filtermodule directory in your project and run the dotnet publish command.

dotnet publish --os linux --arch x64 /t:PublishContainer

Currently, the iotedgedev tool template targets .NET 7.0, which reached end of support in May 2024. Update the project to target .NET 8.0 (LTS, supported through November 2026) by editing the filtermodule.csproj file and changing the TargetFramework and PackageReference values. Your filtermodule.csproj file should look like this:

<Project Sdk="Microsoft.NET.Sdk.Worker">
    <PropertyGroup>
        <TargetFramework>net8.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Azure.Devices.Client" Version="1.42.0" />
        <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
    </ItemGroup>
</Project>

Tag the docker image with your container registry information, version, and architecture. Replace myacr with your own registry name:

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.1-amd64

C, Java, Node.js, Python

Use the module's Dockerfile to build and tag the module Docker image:

docker build --rm -f "<DockerFilePath>" -t <ImageNameAndTag> "<ContextPath>"

For example, to build the image for the local registry or an Azure container registry, run the following commands:

# Build and tag the image for the local registry

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t localhost:5000/filtermodule:0.0.1-amd64 "./modules/filtermodule"

# Or build and tag the image for an Azure Container Registry. Replace myacr with your own registry name.

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t myacr.azurecr.io/filtermodule:0.0.1-amd64 "./modules/filtermodule"

Push module Docker image

Provide your container registry credentials to Docker so that it can push your container image to storage in the registry.

  1. Sign in to Docker with the Azure Container Registry (ACR) credentials:

    docker login -u <ACR username> -p <ACR password> <ACR login server>

    You might receive a security warning recommending the use of --password-stdin. While that's a recommended best practice for production scenarios, it's outside the scope of this tutorial. For production container registry authentication, use a service principal or repository-scoped tokens instead of admin credentials. For more information, see Manage access to your container registry and the docker login reference.

  2. Sign in to the Azure Container Registry. You must install Azure CLI to use the az command. This command asks for your user name and password found in your container registry in Settings > Access keys:

    az acr login -n <ACR registry name>

    [!TIP] If you are logged out at any point in this tutorial, repeat the Docker and Azure Container Registry sign-in steps to continue.

  3. Push your module image to the local registry or a container registry:

    docker push <ImageName>

    For example:

    # Push the Docker image to the local registry
 
docker push localhost:5000/filtermodule:0.0.1-amd64
 
# Or push the Docker image to an Azure Container Registry. Replace myacr with your Azure Container Registry name.

az acr login --name myacr
docker push myacr.azurecr.io/filtermodule:0.0.1-amd64

Update the deployment template

Update the deployment template deployment.template.json with the container registry image location. For example, if you're using an Azure Container Registry myacr.azurecr.io and your image is filtermodule:0.0.1-amd64, update the filtermodule configuration to:

"filtermodule": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
        "image": "myacr.azurecr.io/filtermodule:0.0.1-amd64",
        "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
    }
}

::: zone-end

::: zone pivot="iotedge-dev-ext"

In the Visual Studio Code explorer, right-click the deployment.template.json file and select Build and Push IoT Edge Solution.

The build and push command starts three operations. First, it creates a new folder in the solution called config that holds the full deployment manifest, built out of information in the deployment template and other solution files. Second, it runs docker build to build the container image based on the appropriate dockerfile for your target architecture. Then, it runs docker push to push the image repository to your container registry.

This process might take several minutes the first time, but it's faster the next time you run the commands.

::: zone-end

Optional: Update the module and image

If you make changes to your module code, you must rebuild and push the module image to your container registry. Use the steps in this section to update the build and container image. You can skip this section if you didn't make any changes to your module code.

::: zone pivot="iotedge-dev-ext"

Open the deployment.amd64.json file in newly created config folder. The filename reflects the target architecture, so it's different if you chose a different architecture.

Notice that the two parameters that had placeholders now contain their proper values. The registryCredentials section has your registry username and password pulled from the .env file. The filtermodule has the full image repository with the name, version, and architecture tag from the module.json file.

::: zone-end

  1. Open the module.json file in the filtermodule folder.

  2. Change the version number for the module image. For example, increment the patch version number to "version": "0.0.2" as if you made a small fix in the module code.

    [!TIP] Module versions enable version control, and allow you to test changes on a small set of devices before you deploy updates to production. If you don't increment the module version before building and pushing, then you overwrite the repository in your container registry.

  3. Save your changes to the module.json file.

::: zone pivot="iotedge-dev-cli"

Build and push the updated image with a 0.0.2 version tag. For example, to build and push the image for the local registry or an Azure container registry, use the following commands:

C#

# Build the container image for Linux and amd64 architecture.

dotnet publish --os linux --arch x64

# For local registry:
# Tag the image with version 0.0.2, x64 architecture, and the local registry.

docker tag filtermodule localhost:5000/filtermodule:0.0.2-amd64

# For Azure Container Registry:
# Tag the image with version 0.0.2, x64 architecture, and your container registry information. Replace **myacr** with your own registry name.

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.2-amd64

C, Java, Node.js, Python

# Build and push the 0.0.2 image for the local registry

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t localhost:5000/filtermodule:0.0.2-amd64 "./modules/filtermodule"

docker push localhost:5000/filtermodule:0.0.2-amd64

# Or build and push the 0.0.2 image for an Azure Container Registry. Replace myacr with your own registry name.

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t myacr.azurecr.io/filtermodule:0.0.2-amd64 "./modules/filtermodule"

docker push myacr.azurecr.io/filtermodule:0.0.2-amd64

::: zone-end

::: zone pivot="iotedge-dev-ext"

Right-click the deployment.template.json file again, and select Build and Push IoT Edge Solution again.

::: zone-end

Open the deployment.amd64.json file again. Notice the build system doesn't create a new file when you run the build and push command again. Rather, the same file updates to reflect the changes. The filtermodule image now points to the 0.0.2 version of the container.

To further verify what the build and push command did, go to the Azure portal and navigate to your container registry. In your container registry, select Repositories then filtermodule. Verify that both versions of the image push to the registry.

:::image type="content" source="./media/tutorial-develop-for-linux/view-repository-versions.png" alt-text="Screenshot of where to view both image versions in your container registry." lightbox="./media/tutorial-develop-for-linux/view-repository-versions.png":::

Troubleshoot

If you encounter errors when building and pushing your module image, it often has to do with Docker configuration on your development machine. Use the following checks to review your configuration:

  • Did you run the docker login command using the credentials that you copied from your container registry? These credentials are different than the ones that you use to sign in to Azure.
  • Is your container repository correct? Does it have your correct container registry name and your correct module name? Open the module.json file in the filtermodule folder to check. The repository value should be similar to <registry name>.azurecr.io/filtermodule.
  • If you used a different name than filtermodule for your module, is that name consistent throughout the solution?
  • Is your machine running the same type of containers that you're building? This tutorial is for Linux IoT Edge devices, so Visual Studio Code should say amd64 or arm32v7 in the side bar, and Docker Desktop should be running Linux containers.

Deploy modules to device

You verified that there are built container images stored in your container registry, so it's time to deploy them to a device. Make sure that your IoT Edge device is up and running.

::: zone pivot="iotedge-dev-cli"

Use the IoT Edge Azure CLI set-modules command to deploy the modules to the Azure IoT Hub. For example, to deploy the modules defined in the deployment.template.json file to the IoT Hub my-iot-hub for the IoT Edge device my-device, use the following command. Replace the hub-name, device-id, and login IoT Hub connection string values with your own.

az iot edge set-modules --hub-name my-iot-hub --device-id my-device --content ./deployment.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

Tip

Find your IoT Hub connection string, including the shared access key, in the Azure portal. Go to your IoT Hub, and select Security settings > Shared access policies > iothubowner.

::: zone-end

::: zone pivot="iotedge-dev-ext"

  1. In the Visual Studio Code explorer, under the Azure IoT Hub section, expand Devices to see your list of IoT devices.

  2. Right-click the IoT Edge device that you want to deploy to, then select Create Deployment for Single Device.

  3. In the file explorer, navigate into the config folder then select the deployment.amd64.json file.

    Don't use the deployment.template.json file, which doesn't have the container registry credentials or module image values in it. If you target a Linux ARM32 device, the deployment manifest's name is deployment.arm32v7.json.

  4. Under your device, expand Modules to see a list of deployed and running modules. Select the refresh button. You should see the new tempSensor and filtermodule modules running on your device.

    It can take a few minutes for the modules to start. The IoT Edge runtime receives its new deployment manifest, pulls down the module images from the container runtime, then starts each new module.

View messages from device

The sample module code gets messages through its input queue and sends them through its output queue. The deployment manifest sets up routes that send messages to filtermodule from tempSensor, and then forward messages from filtermodule to IoT Hub. The Azure IoT Edge and Azure IoT Hub extensions let you see messages as they arrive at IoT Hub from your device.

  1. In the Visual Studio Code explorer, select the IoT Edge device you want to monitor, then select Start Monitoring Built-in Event Endpoint.

  2. Watch the output window in Visual Studio Code to see messages arrive at your IoT Hub.

    :::image type="content" source="./media/tutorial-develop-for-linux/view-d2c-messages.png" alt-text="Screenshot of the Visual Studio Code output window showing incoming device-to-cloud messages.":::

::: zone-end

View changes on device

To see what's happening on your device, use the commands in this section to inspect the IoT Edge runtime and modules running on your device.

These commands are for your IoT Edge device, not your development machine. If you're using a virtual machine for your IoT Edge device, connect to it now. In Azure, go to the virtual machine's overview page and select Connect to access the secure shell connection.

  • View all modules deployed to your device, and check their status:

    iotedge list

    You see four modules: the two IoT Edge runtime modules, tempSensor, and filtermodule. All four should be listed as running.

  • Inspect the logs for a specific module:

    iotedge logs <module name>

    Module names are case-sensitive.

    The tempSensor and filtermodule logs show the messages they're processing. The edgeAgent module starts the other modules, so its logs have information about the deployment manifest. If a module isn't listed or isn't running, check the edgeAgent logs for errors. The edgeHub module manages communication between the modules and IoT Hub. If the modules are running but messages aren't arriving at your IoT Hub, check the edgeHub logs for errors.

Clean up resources

If you want to continue to the next recommended article, keep the resources and configurations you created and reuse them. You can also keep using the same IoT Edge device as a test device. Otherwise, to avoid charges, delete the local configuration and the Azure resources you used in this article.

[!INCLUDE iot-edge-clean-up-cloud-resources]

Next steps

In this tutorial, you set up Visual Studio Code on your development machine and deploy your first IoT Edge module with code that filters raw data generated by your IoT Edge device.

Continue to the next tutorials to learn how Azure IoT Edge lets you deploy Azure cloud services to process and analyze data at the edge.

[!div class="nextstepaction"] Debug Azure IoT Edge modules Functions Stream Analytics Custom Vision Service