Real-time Edge Computing with .NET 8 and Azure IoT Edge: Deploy Native AOT Modules

Why Real-time Edge Matters

Imagine a factory floor where a sensor detects a temperature spike and an actuator shuts down a motor within milliseconds. According to a 2023 IDC report, 65% of manufacturers consider sub‑second latency a competitive advantage. Traditional cloud‑centric pipelines add network round‑trip time that can easily exceed 200 ms, breaking the real‑time loop. Bringing compute to the edge and compiling to native code eliminates the managed runtime overhead, delivering deterministic performance.

Choosing .NET 8 and Native AOT for Edge

.NET 8 introduces Native Ahead‑of‑Time (AOT) compilation that produces a single executable without a JIT or garbage‑collector warm‑up. The binary starts in under 50 ms on a Raspberry Pi 4, a typical Azure IoT Edge device. Native AOT also reduces the container footprint from ~150 MB to under 30 MB, which lowers bandwidth costs for OTA updates.

System Requirements and Toolchain Setup

Before writing code, ensure the development workstation runs Windows 11 or Ubuntu 22.04, with the following tools installed:

dotnet sdk 8.0.100
az cli 2.53.0
Docker Engine 24.0.5
IoT Edge runtime 1.4.0

On the target device, Azure IoT Edge runtime must be at least version 1.4, and the OS should be a 64‑bit Linux distribution such as Ubuntu 20.04 LTS.

Creating a Native AOT Microservice

Start with a minimal console app that processes a JSON payload from the Edge Hub. The Microsoft.NET.Runtime.Aot package enables native compilation.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <PublishAot>true</PublishAot>
    <RuntimeIdentifier>linux-arm64</RuntimeIdentifier>
    <SelfContained>true</SelfContained>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Runtime.Aot" Version="8.0.0" />
    <PackageReference Include="Microsoft.Azure.Devices.Client" Version="1.41.0" />
  </ItemGroup>
</Project>

Implement the module logic in Program.cs:

using Microsoft.Azure.Devices.Client;
using System.Text;
var moduleClient = await ModuleClient.CreateFromEnvironmentAsync();
await moduleClient.OpenAsync();
moduleClient.SetInputMessageHandlerAsync("input1", async (msg, ctx) =>
{    var payload = Encoding.UTF8.GetString(msg.GetBytes());
    Console.WriteLine($"Received: {payload}");
    // Simulate fast processing
    var response = Encoding.UTF8.GetBytes($"Processed at {DateTime.UtcNow:O}");
    var outputMsg = new Message(response);
    await moduleClient.SendEventAsync("output1", outputMsg);
    return MessageResponse.Completed;
}, null);
await Task.Delay(Timeout.Infinite);

Compile with dotnet publish -c Release. The output folder contains a single myedgemodule executable ready for Docker.

Dockerizing the Native AOT Binary

Because the binary is self‑contained, a tiny mcr.microsoft.com/dotnet/runtime-deps:8.0 base image suffices. The Dockerfile copies only the executable and sets the entry point.

FROM mcr.microsoft.com/dotnet/runtime-deps:8.0-alpine AS base
WORKDIR /app
COPY bin/Release/net8.0/linux-arm64/publish/myedgemodule ./myedgemodule
ENTRYPOINT ["/app/myedgemodule"]

Build and push the image to Azure Container Registry (ACR):

az acr login --name MyRegistry
docker build -t myregistry.azurecr.io/edge/myedgemodule:1.0 .
docker push myregistry.azurecr.io/edge/myedgemodule:1.0

Deploying the Module with Azure IoT Edge

Create a deployment manifest that references the ACR image and configures input/output routes. The createOptions field can set memory limits to 50 MiB, which is sufficient for the AOT binary.

{
  "modulesContent": {
    "$edgeAgent": {
      "properties.desired": {
        "modules": {
          "myEdgeAotModule": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "myregistry.azurecr.io/edge/myedgemodule:1.0",
              "createOptions": "{\"HostConfig\":{\"Memory\":52428800}}"
            }
          }
        }
      }
    },
    "$edgeHub": {
      "properties.desired": {
        "routes": {
          "sensorToAot": "FROM /messages/modules/sensorModule/outputs/temperature INTO $upstream",
          "aotToCloud": "FROM /messages/modules/myEdgeAotModule/outputs/processed INTO $upstream"
        },
        "schemaVersion": "1.0",
        "storeAndForwardConfiguration": {"timeToLiveSecs": 7200}
      }
    }
  }
}

Deploy the JSON using the Azure portal or the az iot edge deployment create CLI command. After deployment, the module appears in iotedge list and starts within seconds.

Monitoring Performance and Updating

Edge runtime exposes metrics via the built‑in edgeAgent API. Query the /modules/myEdgeAotModule/stats endpoint to verify CPU usage stays below 10 % and memory under the configured limit. For OTA updates, bump the image tag, push the new container, and apply a new deployment manifest. Because the binary is native, the update size is typically 5‑10 MB, making it ideal for low‑bandwidth sites.

Conclusion

Combining .NET 8 Native AOT with Azure IoT Edge delivers sub‑second latency, minimal container size, and a familiar C# development experience. By following the steps above—setting up the toolchain, building an AOT‑compiled microservice, containerizing it, and deploying through IoT Edge—you can turn any ARM‑based gateway into a high‑performance compute node. The real payoff appears when dozens of sensors feed data into a native module that reacts instantly, keeping production lines safe and efficient.

Sources

Microsoft .NET 8 Documentation; Azure IoT Edge Official Documentation; IDC Edge Computing Market Report 2023

Author: Mahmut Sarıkaya — sarikayadev.com