Is there is a way to connect devices from Azure IoT Hub to Azure IoT Central?

Question

i see so many devices that can easily connect to Azure IoT hub via MQTT. But it is NOT as easy to connect those same devices to Azure IoT Central. Is there a way to send those data from Azure IoT Hub to Azure IoT Central?

Answer 1

In the case of sending only a telemetry data to the Azure IoT Central App, you can use the Azure Event Grid integrator, where the device telemetry message is published via the Azure IoT Hub routing feature:

The following code snippet is an example of the webhook subscriber implementation (HttpTrigger Function) for handling all needs such as DPS, etc.

function.json file:

{
  "bindings": [
    {
      "name": "eventGridEvent",
      "authLevel": "function",
      "methods": [
        "post",
        "options"
      ],
      "direction": "in",
      "type": "httpTrigger"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    }
  ]
}

run.csx file:

#r "Newtonsoft.Json"

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Net;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

public static async Task<ActionResult> Run(JObject eventGridEvent, HttpRequest req, ILogger log)
{ 
    if (req.Method == HttpMethod.Options.ToString())
    {
        log.LogInformation("CloudEventSchema validation");               
        req.HttpContext.Response.Headers.Add("Webhook-Allowed-Origin", req.Headers["WebHook-Request-Origin"].FirstOrDefault()?.Trim());
        return (ActionResult)new OkResult();
    }

    // consumer of telemetry (iot central)
    uint sasTokenTTLInHrs = 1;
    string iotcScopeId = req.Headers["iotc-scopeId"].FirstOrDefault() ?? Environment.GetEnvironmentVariable("AzureIoTC_scopeId"); 
    string iotcSasToken = req.Headers["iotc-sasToken"].FirstOrDefault() ?? Environment.GetEnvironmentVariable("AzureIoTC_sasToken"); 
    log.LogInformation($"CloudEvent_Id = {eventGridEvent["id"]}"); 
    log.LogInformation($"AzureIoT_scopeId = {iotcScopeId}"); 
  
    // mandatory properties
    string source = eventGridEvent["data"]?["systemProperties"]?["iothub-message-source"]?.Value<string>();
    string deviceId = eventGridEvent["data"]?["systemProperties"]?["iothub-connection-device-id"]?.Value<string>();
                
    if (source == "Telemetry" && !string.IsNullOrEmpty(deviceId) && Regex.IsMatch(deviceId, @"^[a-z0-9\-]+$"))
    {
        var sysProp = eventGridEvent["data"]["systemProperties"];
        var appProp = eventGridEvent["data"]["properties"];
        // device model
        var component = appProp?["iothub-app-component-name"]?.Value<string>() ?? sysProp["dt-subject"]?.Value<string>() ?? "";
        var modelId = appProp?["iothub-app-model-id"]?.Value<string>() ?? sysProp["dt-dataschema"]?.Value<string>();
        // creation time
        var enqueuedtime = sysProp["iothub-enqueuedtime"]?.Value<DateTime>().ToString("o");
        var ctime = appProp?["iothub-creation-time-utc"]?.Value<DateTime>().ToString("o");
        // device group (device prefix)
        var deviceGroup = appProp?["iothub-app-device-group"]?.Value<string>();
        deviceId = $"{(deviceGroup == null ? "" : deviceGroup + "-")}{deviceId}";
        // remove sysprop
        ((JObject)eventGridEvent["data"]).Remove("systemProperties");
        
        try
        {
            var info = await Connectivity.GetConnectionInfo(deviceId, modelId, iotcScopeId, iotcSasToken, log, sasTokenTTLInHrs);
            using (HttpClient client = new HttpClient())
            {
                client.DefaultRequestHeaders.Add("Authorization", info.SasToken);
                client.DefaultRequestHeaders.Add("dt-subject", component);
                client.DefaultRequestHeaders.Add("iothub-app-iothub-creation-time-utc", ctime ?? enqueuedtime);
                var response = await client.PostAsJsonAsync(info.RequestUri, eventGridEvent["data"]);
                response.EnsureSuccessStatusCode();
            }
            log.LogInformation($"POST: {info.RequestUri}\r\n{eventGridEvent["data"]}");
        }
        catch(Exception ex)
        {
            log.LogError(ex.InnerException == null ? ex.Message : ex.InnerException.Message);
            Connectivity.RemoveDevice(deviceId);
            throw ex; // for retrying and deadlettering undeliverable message
        }
    }
    else
    {
        log.LogWarning($"Wrong event message:\r\n{eventGridEvent}");
    }
    return (ActionResult)new OkResult();
}

class ConnectivityInfo
{
    public string IoTHubName { get; set; }
    public string RequestUri { get; set; }
    public string SasToken { get; set; }
    public ulong SaSExpiry { get; set; }
    public string ModelId { get; set; }
    public string DeviceConnectionString { get; set; }
}


static class Connectivity
{
    static Dictionary<string, ConnectivityInfo> devices = new Dictionary<string, ConnectivityInfo>();

    public static async Task<ConnectivityInfo> GetConnectionInfo(string deviceId, string modelId, string iotcScopeId, string iotcSasToken, ILogger log, uint sasTokenTTLInHrs = 24, int retryCounter = 10, int pollingTimeInSeconds = 3)
    {
        if (devices.ContainsKey(deviceId))
        {
            if (!string.IsNullOrEmpty(modelId) && devices[deviceId].ModelId != modelId)
            {
                log.LogWarning($"Reprovissiong device with new model");
                devices.Remove(deviceId);
            }
            else
            {
                if (!SharedAccessSignatureBuilder.IsValidExpiry(devices[deviceId].SaSExpiry, 100))
                {
                    log.LogWarning($"Refreshing sasToken");
                    devices[deviceId].SasToken = SharedAccessSignatureBuilder.GetSASTokenFromConnectionString(devices[deviceId].DeviceConnectionString, sasTokenTTLInHrs);
                    devices[deviceId].SaSExpiry = ulong.Parse(SharedAccessSignatureBuilder.GetExpiry(sasTokenTTLInHrs));
                }
                return devices[deviceId];
            }
        }

        string deviceKey = SharedAccessSignatureBuilder.ComputeSignature(iotcSasToken, deviceId);
        string address = $"https://global.azure-devices-provisioning.net/{iotcScopeId}/registrations/{deviceId}/register?api-version=2021-06-01";
        string sas = SharedAccessSignatureBuilder.GetSASToken($"{iotcScopeId}/registrations/{deviceId}", deviceKey, "registration", 1);

        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", sas);
            client.DefaultRequestHeaders.Add("accept", "application/json");
            string jsontext = string.IsNullOrEmpty(modelId) ? null : $"{{ \"modelId\":\"{modelId}\" }}";
            var response = await client.PutAsync(address, new StringContent(JsonConvert.SerializeObject(new { registrationId = deviceId, payload = jsontext }), Encoding.UTF8, "application/json"));

            var atype = new { errorCode = "", message = "", operationId = "", status = "", registrationState = new JObject() };
            do
            {
                dynamic operationStatus = JsonConvert.DeserializeAnonymousType(await response.Content.ReadAsStringAsync(), atype);
                if (!string.IsNullOrEmpty(operationStatus.errorCode))
                {
                    throw new Exception($"{operationStatus.errorCode} - {operationStatus.message}");
                }
                response.EnsureSuccessStatusCode();
                if (operationStatus.status == "assigning")
                {
                    Task.Delay(TimeSpan.FromSeconds(pollingTimeInSeconds)).Wait();
                    address = $"https://global.azure-devices-provisioning.net/{iotcScopeId}/registrations/{deviceId}/operations/{operationStatus.operationId}?api-version=2021-06-01";
                    response = await client.GetAsync(address);
                }
                else if (operationStatus.status == "assigned")
                {
                    var cinfo = new ConnectivityInfo();
                    cinfo.ModelId = modelId;
                    cinfo.IoTHubName = operationStatus.registrationState.assignedHub;
                    cinfo.DeviceConnectionString = $"HostName={cinfo.IoTHubName};DeviceId={deviceId};SharedAccessKey={deviceKey}";
                    cinfo.RequestUri = $"https://{cinfo.IoTHubName}/devices/{deviceId}/messages/events?api-version=2021-04-12";
                    cinfo.SasToken = SharedAccessSignatureBuilder.GetSASToken($"{cinfo.IoTHubName}/{deviceId}", deviceKey, null, sasTokenTTLInHrs);
                    cinfo.SaSExpiry = ulong.Parse(SharedAccessSignatureBuilder.GetExpiry(sasTokenTTLInHrs));
                    devices.Add(deviceId, cinfo);
                    log.LogInformation($"DeviceConnectionString: {cinfo.DeviceConnectionString}");                        
                    return cinfo;
                }
                else
                {
                    throw new Exception($"{operationStatus.registrationState.status}: {operationStatus.registrationState.errorCode} - {operationStatus.registrationState.errorMessage}");
                }
            } while (--retryCounter > 0);

            throw new Exception("Registration device status retry timeout exprired, try again.");
        }
    }

    public static void RemoveDevice(string deviceId)
    {
        if (devices.ContainsKey(deviceId))
            devices.Remove(deviceId);
    }
}

public sealed class SharedAccessSignatureBuilder
{
    public static string GetHostNameNamespaceFromConnectionString(string connectionString)
    {
        return GetPartsFromConnectionString(connectionString)["HostName"].Split('.').FirstOrDefault();
    }
    public static string GetSASTokenFromConnectionString(string connectionString, uint hours = 24)
    {
        var parts = GetPartsFromConnectionString(connectionString);
        if (parts.ContainsKey("HostName") && parts.ContainsKey("SharedAccessKey"))
            return GetSASToken(parts["HostName"], parts["SharedAccessKey"], parts.Keys.Contains("SharedAccessKeyName") ? parts["SharedAccessKeyName"] : null, hours);
        else
            return string.Empty;
    }
    public static string GetSASToken(string resourceUri, string key, string keyName = null, uint hours = 24)
    {
        try
        {
            var expiry = GetExpiry(hours);
            string stringToSign = System.Web.HttpUtility.UrlEncode(resourceUri) + "\n" + expiry;
            var signature = SharedAccessSignatureBuilder.ComputeSignature(key, stringToSign);
            var sasToken = keyName == null ?
                String.Format(CultureInfo.InvariantCulture, "SharedAccessSignature sr={0}&sig={1}&se={2}", System.Web.HttpUtility.UrlEncode(resourceUri), System.Web.HttpUtility.UrlEncode(signature), expiry) :
                String.Format(CultureInfo.InvariantCulture, "SharedAccessSignature sr={0}&sig={1}&se={2}&skn={3}", System.Web.HttpUtility.UrlEncode(resourceUri), System.Web.HttpUtility.UrlEncode(signature), expiry, keyName);
            return sasToken;
        }
        catch
        {
            return string.Empty;
        }
    }

    #region Helpers
    public static string ComputeSignature(string key, string stringToSign)
    {
        using (HMACSHA256 hmac = new HMACSHA256(Convert.FromBase64String(key)))
        {
            return Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(stringToSign)));
        }
    }

    public static Dictionary<string, string> GetPartsFromConnectionString(string connectionString)
    {
        return connectionString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Split(new[] { '=' }, 2)).ToDictionary(x => x[0].Trim(), x => x[1].Trim(), StringComparer.OrdinalIgnoreCase);
    }

    // default expiring = 24 hours
    public static string GetExpiry(uint hours = 24)
    {
        TimeSpan sinceEpoch = DateTime.UtcNow - new DateTime(1970, 1, 1);
        return Convert.ToString((ulong)sinceEpoch.TotalSeconds + 3600 * hours);
    }

    public static DateTime GetDateTimeUtcFromExpiry(ulong expiry)
    {
        return (new DateTime(1970, 1, 1)).AddSeconds(expiry);
    }
    public static bool IsValidExpiry(ulong expiry, ulong toleranceInSeconds = 0)
    {
        return GetDateTimeUtcFromExpiry(expiry) - TimeSpan.FromSeconds(toleranceInSeconds) > DateTime.UtcNow;
    }
    #endregion
}

The following screen snippet shows part of the subscription for passing requested headers for webhook subscriber:

Note, that the mapping feature can be used at the Azure IoT Central App on the input side, based on the device model.

As the above first picture shows, this solution is based on using the Azure Event Grid feature, where the Azure IoT Hub represents a publisher of the device telemetry data and the Azure IoT Central app is its consumer.

The logical connectivity between the Azure IoT Hub and Azure IoT Central is done via the AEG Subscription with a webhook destination handler such as the HttpTrigger Function (see the above implementation). Note, that this subscription is configured for delivering an event message (device telemetry data) in the CloudEventSchema.

Answer 2

Device that provisions itself in IoTHub via DPS will work with IoT Central with no change other than ID Scope sent by device during provisioning which identifies DPS service instance. One ID Scope will point it specific IoT Hub configured in DPS enrollment group, while other will point it to an internal IoT Hub in IoT Central application (IoT Central spins additional internal IoT Hubs as needed for auto scaling, which is why it has its own internal DPS).

Use of DPS allows provisioning of the device to specific IoTHub at the first call and subsequently the change can be triggered explicitly for reprovisioning to different IoTHub or IoT Central, which can be used to move device if needed. This functionality allows scenarios where you can force a device to connect to an IoT Hub or IoT Central by implementing ID Scope change direct method and triggering reprovisioning. Use of DPS is highly recommended as it simplifies provisioning and provides this flexibility.

Reprovisioning should be part of retry logic on the device in case if it fails to connect to IoTHub for certain amount of time in addition to on-demand change described above.

Answer 3

What makes you think "But it is NOT as easy to connect those same devices to Azure IoT Central"?

Any device connecting to IoTHub can also connect to IoTCentral, you just need to provision the device using DPS, it will get the IoTHub hostname and everything else will work the same way.