Comment connecter Azure Sphere avec IoT Hub

Dans la série Azure Sphere, je vais vous parler de la connectivité de votre Azure Sphere à votre Hub IoT Azure.

En effet, dans mes précédents articles traitant de cette plateforme, je n’avais pas abordé cette partie et vous allez voir que cette intégration se fait très rapidement en gardant une sécurité accrue …

Azure Sphere Tenant

Lors de la mise en oeuvre de votre Azure Sphere, vous aurez remarqué que vous avez eu à créer un locataire (Tenant) Azure Sphere pour opérer votre appareil. Ce tenant est là pour gérer tous les aspects de la sécurité de votre appareil :

• Gestion des certificats d’appareil,
• Services de sécurité Azure Sphere,
• Mises à jours de l’OS,
• Configuration et déploiement des applications,
• …

Notez que ce tenant n’est pas là pour capter et traiter la donnée générée par vos appareils. Cette partie de l’IoT est traitée au travers de la plateforme Azure IoT Hub.

En revanche, vous aurez deviné que l’utilisation de la plateforme Azure IoT Hub n’est pas une obligation, en effet, la possibilité de développer vos applications avec un SDK en C vous permettra ainsi de déployer dans votre Azure Sphere des applications connectées à d’autres Hub IoT (tels que AWS IoT ou GCP, …).

Azure IoT Hub et DPS

Vous commencez certainement à connaître Azure IoT Hub et vous savez que vous pouvez connecter vos appareils de différentes manières :

• Symmetric Key,
• Certificat

De plus nous avons également la possibilité d’utiliser Device Provisioning Service (que je vous conseille fortement) afin de créer les identités des appareils sur le Hub au moment de la connexion de l’appareil via des groupes d’enrollement où vous pouvez définir la politique d’attachement à un hub :

• Configuration fixe,
• Distribution aléatoire,
• Latence la plus faible,
• Votre propre logique au travers d’une Azure Function

L’authentification de l’appareil au DPS de faisant également avec une clé symétrique ou un certificat…

Authentification basée sur les certificats

Ce que je vous propose ici est de réaliser une authentification de votre appareil Azure Sphere auprès de DPS puis de IoT Hub basée sur le certificats SSL généré par Azure Sphere Security Service dans le tenant auquel appartient votre appareil.

En effet avec cette méthode, nous pouvons authentifier et gérer les appareils Azure Sphere dans IoT Hub sans avoir à gérer les secrets d’authentification (Certificat et/ou clef symétrique).

Azure Sphere Security Service génère deux certificats pour l’appareil une fois l’attestation produite :

• Le certificat de mise à jours OTA (non accessible pour nous simples mortels)
• Le certificat de Device Authentication and Attestation (utilisable pour nous authentifier auprès d’autres services dont Azure IoT Hub & Co)

Le certificat DAA est un certificat généré parle service DAA et a une durée de validité de 25H environ. Tout comme son homologue, ce certificat est stocké sur l’appareil Azure Sphere dans la puce HSM de votre appareil, garantissant ainsi un accès sécurisé à ces secrets. Ce que vous devez retenir alors c’est que vous n’aurez pas à manipuler le certificat de l’appareil mais uniquement faire « confiance » à l’autorité de certification ayant généré le certificat pour cet appareil.

L’authorité de certification qui sera utilisée est alors une autorité propre au Tenant Azure Sphere que vous aurez créé, ainsi vous pouvez demander à Azure IoT Hub et DPS de faire confiance à cette autorité de certification et tous les appareils de ce tenant pourrons se connecter à votre Hub.

Enfin, côté appareil Azure Sphere, nous verrons ensemble que le SDK dispose de fonctions permettant de simplifier sont authentification sur IoT Hub…

Prérequis

Dans la suite de cet article, je vais considérer que vous avez déjà en main les éléments suivants :

• Votre appareil Azure Sphere ainsi que les droits sur le tenant
  • Dont le SDK Azure Sphere installé sur votre machine,
• Une instance de Azure IoT Hub,
• Une instance de Azure Device Provisioning Service.

Réccupération du certificat de votre Tenant

Avant toutes choses, vous devrez récupérer le certificat de l’autorité de certification de votre Tenant Azure Sphere.

L’outil en ligne de commande de Azure Sphere vous permet alors de le faire comme suit :

azsphere ca-certificate download --destination CAcertificate.cer

Configuration IoT Device Provisioning Service

Configuration des certificats

Rendez-vous dans le portail Azure sur le détail de votre DPS, puis sélectionnez « Certificates » :

A l’aide de l’outil, cliquer sur « Add » afin d’importer le certificat de votre Tenant :

Entrez maintenant le nom de votre certificat et sélectionnez le certificat que vous avez précédement exporté :

Une fois votre certificat ajouté, vous remarquerez que ce certificat n’est pas encore vérifié. Sélectionnez le certificat que vous venez d’ajouter, et avec l’outil de vérification cliquez sur « Generate a verification code » :

Copiez le code ainsi généré et récupérez la preuve de certificat avec le code suivant :

azsphere ca-certificate download-proof --destination ValidationCertification.cer --verification-code <code>

Enfin ajoutez votre certificat de validation dans l’outil de vérification et abracadabra, votre certificat est validé !

Ajout du groupe d’enrollement

Maintenant que le certificat est disponible, nous pouvons créer le groupe d’enrollement dans lequel les appareils pourront s’authentifier et se connecter à l’IoT Hub de votre choix.

Dans le portail Azure de votre DPS, rendez-vous dans le blade « Manage Enrollements » puis cliquez sur « Add enrollement group ». Dans la fenêtre de création de votre groupe, sélectionnez le type d’attestation par certificat, puis le certificat précédemment ajouté en tant que certificat primaire :

Enfin cliquez sur « Save ».

Et voilà pour cette partie configuration. Passons maintenant à la programmation Azure Sphere pour réussir cette authentification…

Application Azure Sphere

Je n’allais pas vous laisser comme cela sans avoir explicité un peu comment nous configurons Azure Sphere pour obtenir cette authentification.

Pour cette partie, je ne vais pas vous donner les éléments étapes par étapes pour construire votre sample, mais seulement vous donner les informations pertinentes qui vous permettrons de le construire.

Vous pourrez démarrer à partir d’une application simple HL Core (Application de haut niveau) comme proposé avec VS Code.

Modifications du manifest

Comme n’importe quel type de besoins de ressources dans Azure Sphere, vous devez déclarer ces besoins dans votre manifeste pour que vous puissiez y accéder. Cela concerne :

• L’accès au certificat de l’appareil,
• L’accès au DPS,
• L’accès à l’IoT Hub.

Réccupérez ainsi l’ID du tenant de votre appareil et l’URL de votre IoT Hub et modifiez dans votre manifeste (app_manifest.json) les capabilities comme suit :

{
  "SchemaVersion": 1,
  "Name": "********************",
  "ComponentId": "******************************",
  "EntryPoint": "/bin/app",
  "CmdArgs": [],
  "Capabilities": {
    "AllowedConnections": [ 
      "global.azure-devices-provisioning.net",
      "<nom du hub>.azure-devices.net"
    ],
    "DeviceAuthentication": "<ID du tenant>",
    "AllowedApplicationConnections": []
  },
  "ApplicationType": "Default"
}

Modification de la configuration CMake

Pour cette partie, nous allons devoir modifier la configuration CMakeLists.txt afin de pouvoir rajouter les dépendances dont nous allons avoir besoin.

Ces modifications doivent être faites avant la ligne azsphere_target_add_image_package.

Ajoutez les lignes suivantes dans votre fichier :

target_include_directories(${PROJECT_NAME} PUBLIC 
                        ${AZURE_SPHERE_API_SET_DIR}/usr/include/azureiot)

Cette commande CMAKE permet d’ajouter les dépendances aux moment de la compilation afin que CMAKE puisse retrouver où sont ces dépendances.

Enfin il nous faut également ajouter la dépendance en lien à notre exécutable pour que notre application puisse retrouver ses petits :

target_link_libraries (${PROJECT_NAME} azureiot applibs pthread gcc_s c)

Utilisation dans le code

Enfin, nous pouvons maintenant utiliser les librairies IoT de Azure dans notre application après avoir instancié un nouveau client d’appareil IoT :

#include <azure_sphere_provisioning.h>
#include <iothub_device_client_ll.h>
#include <iothub_message.h>

typedef enum
{
    IoTHubClientAuthenticationState_NotAuthenticated = 0,
    IoTHubClientAuthenticationState_AuthenticationInitiated = 1,
    IoTHubClientAuthenticationState_Authenticated = 2
} IoTHubClientAuthenticationState;

static IOTHUB_DEVICE_CLIENT_LL_HANDLE iothubClientHandle = NULL;
static IoTHubClientAuthenticationState iotHubClientAuthenticationState =
    IoTHubClientAuthenticationState_NotAuthenticated;

static void ConnectionStatusCallback(
    IOTHUB_CLIENT_CONNECTION_STATUS result,
    IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason,
    void *userContextCallback)
{
    if (result != IOTHUB_CLIENT_CONNECTION_AUTHENTICATED)
    {
        iotHubClientAuthenticationState = IoTHubClientAuthenticationState_NotAuthenticated;
        return;
    }

    iotHubClientAuthenticationState = IoTHubClientAuthenticationState_Authenticated;
}

static void SetUpAzureIoTHubClient(void)
{
    AZURE_SPHERE_PROV_RETURN_VALUE provResult =
        IoTHubDeviceClient_LL_CreateWithAzureSphereDeviceAuthProvisioning(
            "<ID du scope du DPS>",
            10000,
            &iothubClientHandle);

    iotHubClientAuthenticationState =
        IoTHubClientAuthenticationState_AuthenticationInitiated;

    IoTHubDeviceClient_LL_SetConnectionStatusCallback(
        iothubClientHandle,
        ConnectionStatusCallback,
        NULL);
}

int main(int argc, char *argv[])
{
    SetUpAzureIoTHubClient();

    while (iotHubClientAuthenticationState != IoTHubClientAuthenticationState_Authenticated)
    {
        IoTHubDeviceClient_LL_DoWork(iothubClientHandle);
    }

    return 0;
}

N’oubliez pas de remplacer votre ID de scope de votre DPS dans l’exemple ci-dessus.

Lancez votre application et vous constaterez que vous obtiendrez au moment de la sortie du main, une instance du client de device IoT Hub connecté que nous pouvons utilisez comme n’importe quel type de device.

Vous constaterez ainsi les logs suivants dans votre application :

Starting debugger....
Process /mnt/apps/<ID de l'app>/bin/app created; pid = 102
Listening on port 2345
Remote debugging from host 192.168.35.1, port 41046
[Azure IoT] Using HSM cert at /run/daa/<ID du tenant Azure Sphere>


Child exited with status 0

Enfin, vous pourrez vérifier que votre appareil a été correctement enregistré sur votre DPS :

Finalement, une fois la création de notre instance du client d’appareil IoT réalisé, nous remarquons que nous pouvons utiliser toutes les briques du SDK client IoT de Azure IoT Hub (comme si nous étions sur un Arduino). Pour ma part, je trouve ainsi cela rassurant de pouvoir notamment réaliser mes POCs sur Arduino et me laisser la liberté de pouvoir déployer ces solutions sur un MT3620 (Azure Sphere) avec tous ses avantages…

Conclusions

Je n’avais pas vraiment de doutes sur la possibilité d’inscrire mon appareil Azure Sphere dans un IoT Hub, mais j’avoue que j’ai été assez surpris de la facilité (et pas que pour cette partie là) avec laquelle nous arrivons à mettre en oeuvre une solution qui est en faite assez complexe (Microsoft nous masque en effet énormément de complexité dans cette partie et je les en remercie…).

C’est surtout en utilisant la documentation de Microsoft que j’ai pu réaliser ces éléments, mais il faut se le dire, la mise à disposition des samples sur Github est parfois plus claire que cette documentation.

Dans mon cas, j’ai souhaité vous en faire la démonstration avec un DPS et IoT Hub, mais sachez également qu’il est possible de réaliser le même type de connexion avec :

• Un IoT Hub (sans DPS),
• Un IoT Central,
• Un IoT Edge (En transparent Gateway).

Finalement tous les scénarios sont ainsi possible avec ce petit MT3620 !!