Démarrage rapide : Provisionner un appareil TPM simulé

Dans ce démarrage rapide, vous créez un appareil simulé sur votre machine Windows. L’appareil simulé est configuré pour utiliser un mécanisme d’attestation de module de plateforme sécurisée (TPM) pour l’authentification. Une fois votre appareil configuré, vous le provisionnez dans votre hub IoT en utilisant le Service IoT Hub Device Provisioning. L’exemple de code est ensuite utilisé pour inscrire l’appareil avec une instance du Service de Provisionnement d'Appareils.

Si vous ne connaissez pas le processus de provisionnement, passez en revue la vue d’ensemble du provisionnement. Veillez également à suivre les étapes de démarrage rapide : configurez le service IoT Hub Device Provisioning avec le portail Azure avant de continuer.

Le service Azure IoT Device Provisioning prend en charge deux types d’inscriptions :

• Les groupes d’inscriptions qui permettent d’inscrire plusieurs appareils associés.

• Inscriptions individuelles utilisées pour inscrire un seul appareil.

Cet article présente les inscriptions individuelles.

L’attestation TPM (Trusted Platform Module) n’est pas prise en charge dans le Kit de développement logiciel (SDK) Python. Avec Python, vous pouvez approvisionner un appareil à l’aide de clés symétriques ou de certificats X.509.

Prérequis

• Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

• Suivez les étapes de démarrage rapide : Configurer le service IoT Hub Device Provisioning avec le portail Azure.

Les prérequis suivants s’appliquent à un environnement de développement Windows. Pour Linux ou macOS, consultez la section appropriée de Préparer votre environnement de développement dans la documentation du kit de développement logiciel (SDK).

• Visual Studio 2019 ou version ultérieure avec la charge de travail « Développement Desktop avec C++ » activée. Visual Studio 2015 et Visual Studio 2017 sont également pris en charge.

• Un module de sécurité matériel TPM 2.0 sur votre machine Windows.

• Installez le kit SDK .NET Core 6.0 sur votre machine Windows. Vous pouvez exécuter la commande suivante pour vérifier votre version.

  dotnet --info
  

• Installez Node.js v4.0+.

• Installez Java SE Development Kit 8 ou une version ultérieure sur votre machine.

• Téléchargez et installez Maven.

• Installez la dernière version de Git. Vérifiez que Git est ajouté aux variables d’environnement accessibles à la fenêtre de commande. Consultez Outils clients Git de Software Freedom Conservancy pour accéder à la dernière version des outils git à installer, ce qui inclut Git Bash, l’application en ligne de commande que vous pouvez utiliser pour interagir avec votre dépôt Git local.

Préparer votre environnement de développement

Dans cette section, vous préparez un environnement de développement utilisé pour générer le Kit de développement logiciel (SDK) Azure IoT C et l’exemple de simulateur d’appareil TPM .

1. Téléchargez le dernier système de génération CMake.

   Important

   Vérifiez que les prérequis de Visual Studio (Visual Studio et la charge de travail « Développement Desktop en C++ ») sont installés sur votre machine avant de commencer l’installation de CMake. Une fois les composants requis en place et le téléchargement effectué, installez le système de génération de CMake. En outre, les versions antérieures du système de génération CMake ne parviennent pas à générer le fichier de solution utilisé dans cet article. Veillez à utiliser la dernière version de CMake.

2. Ouvrez un navigateur web, puis accédez à la page des versions du kit SDK C Azure IoT.

3. Sélectionnez l’onglet Étiquettes en haut de la page.

4. Copiez le nom d’étiquette de la version la plus récente du SDK C Azure IoT.

5. Ouvrez une invite de commandes ou l’interpréteur de commandes Git Bash. Exécutez les commandes suivantes pour cloner la dernière version du dépôt GitHub du kit Azure IoT Device SDK pour C. Remplacez <release-tag> par la balise que vous avez copiée à l’étape précédente (ex. : lts_03_2025).

   git clone -b <release-tag> https://github.com/Azure/azure-iot-sdk-c.git
   cd azure-iot-sdk-c
   git submodule update --init
   

   Cette opération peut prendre plusieurs minutes.

6. Une fois l’opération terminée, exécutez les commandes suivantes à partir du répertoire azure-iot-sdk-c :

   mkdir cmake
   cd cmake
   

1. Ouvrez un environnement de ligne de commande Git CMD ou Git Bash.

2. Clonez le référentiel GitHub de l'Azure IoT SDK pour .NET à l'aide de la commande suivante :

   git clone https://github.com/Azure/azure-iot-sdk-csharp.git
   

1. Ouvrez un environnement de ligne de commande Git CMD ou Git Bash.

2. Clonez le dépôt GitHub azure-utpm-c à l’aide de la commande suivante :

   git clone https://github.com/Azure/azure-utpm-c.git --recursive
   

1. Ouvrez un environnement de ligne de commande Git CMD ou Git Bash.

2. Clonez le dépôt GitHub Java à l’aide de la commande suivante :

   git clone https://github.com/Azure/azure-iot-sdk-java.git --recursive
   

Générer et exécuter le simulateur d’appareil TPM

Dans cette section, vous générez et exécutez le simulateur TPM. Ce simulateur écoute un socket sur les ports 2321 et 2322. Ne fermez pas la fenêtre de commande. Vous devez laisser l’exécution de ce simulateur se poursuivre jusqu’à la fin de ce guide de démarrage rapide.

1. Exécutez la commande suivante pour générer le SDK C Azure IoT qui comprend l’exemple de code du simulateur d’appareil TMP. Une solution Visual Studio pour l’appareil simulé est générée dans le répertoire cmake. Cet exemple fournit un mécanisme d’attestation TPM via l’authentification par jeton de signature d’accès partagé (SAP).

   cmake -Duse_prov_client:BOOL=ON -Duse_tpm_simulator:BOOL=ON ..
   

   Conseil

   Si cmake ne trouve pas votre compilateur C++, vous pourriez rencontrer des erreurs de construction lors de l’exécution de la commande précédente. Si cela se produit, essayez d’exécuter la commande dans l’invite de commandes de Visual Studio.

2. Quand la génération aboutit, les dernières lignes de la sortie ressemblent à la sortie suivante :

   $ cmake -Duse_prov_client:BOOL=ON ..
   -- Building for: Visual Studio 16 2019
   -- The C compiler identification is MSVC 19.23.28107.0
   -- The CXX compiler identification is MSVC 19.23.28107.0
   
   ...
   
   -- Configuring done
   -- Generating done
   -- Build files have been written to: C:/code/azure-iot-sdk-c/cmake
   

3. Accédez au dossier racine du dépôt Git que vous avez cloné.

4. Exécutez le simulateur TPM à l’aide du chemin d’accès indiqué dans l’exemple suivant.

   cd ..
   .\provisioning_client\deps\utpm\tools\tpm_simulator\Simulator.exe
   

   Le simulateur n’affiche aucune sortie. Laissez-le poursuivre son exécution car il simule un appareil TPM.

1. Accédez au dossier racine GitHub.

2. Exécutez le simulateur TPM pour en faire le HSM de l’appareil simulé.

   .\azure-utpm-c\tools\tpm_simulator\Simulator.exe
   

3. Créez un dossier vide appelé registerdevice. Dans le dossier registerdevice, créez un fichier package.json en utilisant la commande suivante à l’invite de commandes. Veillez à répondre à toutes les questions posées par npm ou acceptez les paramètres par défaut, s’ils vous conviennent :

   npm init
   

4. Installez les packages précurseurs suivants :

   npm install node-gyp -g
   npm install ffi-napi -g
   

   Remarque

   Il existe des problèmes connus liés à l’installation des packages précédents. Pour résoudre ces problèmes, exécutez npm install --global --production windows-build-tools en utilisant une invite de commandes en mode Exécuter en tant qu’administrateur, exécutez SET VCTargetsPath=C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V140 après avoir remplacé le chemin par votre version installée, puis réexécutez les commandes d’installation précédentes.

5. Installez tous les packages nécessaires en exécutant la commande suivante à partir de votre invite de commandes, dans le dossier registerdevice :

   npm install --save azure-iot-device azure-iot-device-mqtt azure-iot-security-tpm azure-iot-provisioning-device-http azure-iot-provisioning-device
   

   La commande installe les packages suivants :

   • un client de sécurité qui fonctionne avec TPM : azure-iot-security-tpm

   • Un mode de transport pour connecter l’appareil au service Device Provisioning : azure-iot-provisioning-device-http ou azure-iot-provisioning-device-amqp

   • Un client pour utiliser le mode de transport et le client de sécurité : azure-iot-provisioning-device

   • Le client d’appareil : azure-iot-device

   • Un mode de transport : azure-iot-device-amqp, azure-iot-device-mqtt ou azure-iot-device-http

   • Le client de sécurité que vous avez déjà installé : azure-iot-security-tpm

     Remarque

     Les exemples de ce guide de démarrage utilisent les transports azure-iot-provisioning-device-http et azure-iot-device-mqtt.

6. Ouvrez l’éditeur de texte de votre choix.

7. Dans le dossier registerdevice, créez le fichier ExtractDevice.js.

8. Ajoutez les instructions require ci-dessous au début du fichier ExtractDevice.js :

   
   'use strict';
   
   var tpmSecurity = require('azure-iot-security-tpm');
   var tssJs = require("tss.js");
   
   var myTpm = new tpmSecurity.TpmSecurityClient(undefined, new tssJs.Tpm(true));
   

9. Ajoutez la fonction suivante pour implémenter la méthode :

   
   myTpm.getEndorsementKey(function(err, endorsementKey) {
     if (err) {
       console.log('The error returned from get key is: ' + err);
     } else {
       console.log('the endorsement key is: ' + endorsementKey.toString('base64'));
       myTpm.getRegistrationId((getRegistrationIdError, registrationId) => {
         if (getRegistrationIdError) {
           console.log('The error returned from get registration id is: ' + getRegistrationIdError);
         } else {
           console.log('The Registration Id is: ' + registrationId);
           process.exit();
         }
       });
     }
   });
   

10. Enregistrez et fermez le fichier ExtractDevice.js.

    node ExtractDevice.js
    

11. Exécutez l’exemple.

12. La fenêtre de sortie affiche la clé d’approbation et l’ID d’inscription nécessaires pour l’inscription de l’appareil. Copiez ces valeurs.

1. Exécutez le simulateur TPM pour en faire le HSM de l’appareil simulé.

2. Sélectionnez Autoriser l’accès. Le simulateur écoute un socket sur les ports 2321 et 2322. Ne fermez pas cette fenêtre de commande ; vous devez laisser ce simulateur s’exécuter jusqu’à la fin de ce guide de démarrage rapide.

   .\azure-iot-sdk-java\provisioning\provisioning-tools\tpm-simulator\Simulator.exe
   

   

3. Ouvrez une deuxième invite de commandes.

4. Dans la deuxième invite de commandes, accédez au dossier racine et générez les exemples de dépendances.

   cd azure-iot-sdk-java
   mvn install -DskipTests=true
   

5. Accédez à l’exemple de dossier.

   cd provisioning/provisioning-samples/provisioning-tpm-sample
   

Lire les clés de chiffrement à partir de l’appareil TPM

Dans cette section, vous allez générer et exécuter un exemple qui lit la paire de clés de type EK (Endorsement Key) et l’ID d’inscription du simulateur TPM que vous avez laissé en cours d’exécution, et qui écoute toujours sur les ports 2321 et 2322. Ces valeurs sont utilisées pour l’inscription d’appareils avec votre instance de service Device Provisioning.

1. Lancez Visual Studio.

2. Ouvrez la solution générée dans le dossier cmake nommé azure_iot_sdks.sln.

3. Dans le menu Visual Studio, sélectionnez Génération>Générer la solution pour générer tous les projets dans la solution.

4. Dans la fenêtre Explorateur de solutions de Visual Studio, accédez au dossier Provision_ToolsTools. Cliquez avec le bouton droit sur le projet tpm_device_provision et sélectionnez Définir comme projet de démarrage.

5. Dans le menu Visual Studio, sélectionnez Déboguer>Exécuter sans débogage pour exécuter la solution. L’application lit et affiche un ID d’inscription et une clé d’approbation. Notez ou copiez ces valeurs. Ces valeurs sont utilisées dans la section suivante pour l’inscription des appareils.

1. Connectez-vous au portail Azure, sélectionnez le bouton Toutes les ressources dans le menu de gauche et ouvrez votre instance du service Device Provisioning. Notez vos valeurs d'étendue d’ID et de point de terminaison global de l’appareil.

   

2. Modifiez src/main/java/samples/com/microsoft/azure/sdk/iot/ProvisioningTpmSample.java pour inclure votre étendue de l’ID et point de terminaison global de service d’approvisionnement notés précédemment.

   private static final String idScope = "[Your ID scope here]";
   private static final String globalEndpoint = "[Your Provisioning Service Global Endpoint here]";
   private static final ProvisioningDeviceClientTransportProtocol PROVISIONING_DEVICE_CLIENT_TRANSPORT_PROTOCOL = ProvisioningDeviceClientTransportProtocol.HTTPS;
   

3. Enregistrez le fichier .

4. Utilisez les commandes suivantes pour générer le projet, accédez au dossier cible, puis exécutez le fichier .jar créé (en remplaçant {version} par votre version de Java) :

   mvn clean install
   cd target
   java -jar ./provisioning-tpm-sample-{version}-with-deps.jar
   

5. Lorsque le programme commence à s’exécuter, il affiche la clé d’approbation et l’ID d’inscription. Copiez ces valeurs pour la section suivante. Veillez à laisser le programme en cours d’exécution.

Dans cette section, vous générez et exécutez un exemple qui lit la clé d’approbation à partir de votre module de sécurité matériel TPM 2.0. Cette valeur est utilisée pour l’inscription d’appareils avec votre instance de service Device Provisioning.

1. Dans une invite de commandes, accédez au répertoire du projet contenant l’exemple d’approvisionnement d’appareil TPM.

   cd '.\azure-iot-sdk-csharp\provisioning\device\samples\how to guides\TpmSample\'
   

2. Tapez la commande suivante pour générer et exécuter l’exemple d’approvisionnement d’appareil TPM. Copiez la paire de clés de type EK (Endorsement Key) renvoyée à partir de votre module de sécurité matériel TPM 2.0 pour l’utiliser ultérieurement lors de l’inscription de votre appareil.

   dotnet run -- -e
   

Créer une entrée d’inscription d’appareil

1. Connectez-vous au portail Azure et accédez à votre instance du service Device Provisioning.

2. Sélectionnez Gérer les inscriptions dans la section Paramètres du menu de navigation.

3. Sélectionnez l’onglet Inscriptions individuelles, puis Ajouter une inscription individuelle.

   

4. Dans la section Inscription + approvisionnement de la page Ajouter une inscription, fournissez les informations suivantes pour configurer les détails de l’inscription :

   Champ	Description
   Attestation	Sélectionnez Module de plateforme sécurisée (TPM) comme mécanisme d’attestation.
   Paramètres de Module de plateforme sécurisée (TPM)	Indiquez la clé d’approbation utilisée pour vérifier l’appareil pour cette inscription. Vous pouvez récupérer la paire de clés de type EK (Endorsement Key) à partir du module TPM de votre appareil.
   ID d'inscription	Fournissez l’ID d’inscription unique pour l’appareil. Vous pouvez récupérer l’ID d’inscription à partir du module TPM de votre appareil.
   État d’approvisionnement	Cochez la case Activer cette inscription si vous souhaitez que cette inscription soit disponible pour approvisionner son appareil. Désélectionnez cette case si vous souhaitez désactiver l’inscription. Vous pouvez modifier ce paramètre ultérieurement.
   Stratégie de réapprovisionnement	Choisissez une stratégie de réapprovisionnement qui reflète la façon dont vous souhaitez que DPS gère les appareils qui demandent le réapprovisionnement. Pour plus d’informations, consultez Réplica de réapprovisionnement.

5. Sélectionnez Suivant : hubs IoT.

6. Sous l’onglet IoT Hubs de la page Ajouter une inscription, fournissez les informations suivantes pour déterminer les hubs IoT pour lesquels l’inscription peut approvisionner des appareils :

   Champ	Description
   Hubs IoT cibles	Sélectionnez un ou plusieurs de vos hubs IoT liés, ou ajoutez un nouveau lien à un hub IoT. Pour en savoir plus sur la liaison de hubs IoT à votre instance DPS, consultez Comment lier et gérer des hubs IoT.
   Stratégie d’allocation	Si vous avez sélectionné plusieurs hubs IoT liés, sélectionnez la façon dont vous souhaitez affecter des appareils aux différents hubs. Pour en savoir plus sur les stratégies d’allocation, consultez le guide pratique pour utiliser des stratégies d’allocation. Si vous avez sélectionné un seul hub IoT lié, nous vous recommandons d’utiliser la stratégie de distribution uniformément pondérée.

7. Sélectionnez Suivant : paramètres de l’appareil

8. Sous l’onglet Paramètres de l’appareil de la page Ajouter une inscription , fournissez les informations suivantes pour définir la configuration des appareils nouvellement approvisionnés :

   Champ	Description
   ID de l’appareil	Fournissez un ID d’appareil affecté à l’appareil approvisionné dans IoT Hub. Si vous ne fournissez pas d’ID d’appareil, l’ID d’inscription est utilisé.
   IoT Edge	Vérifiez l’activation d’IoT Edge sur les appareils provisionnés si l’appareil approvisionné exécute Azure IoT Edge. Désélectionnez cette case si cette inscription concerne un appareil sans IoT Edge activé.
   Étiquettes d’appareil	Utilisez cette zone de texte pour fournir les balises que vous souhaitez appliquer au jumeau d’appareil de l’appareil approvisionné.
   Propriétés souhaitées	Utilisez cette zone de texte pour fournir les propriétés souhaitées que vous souhaitez appliquer au jumeau d’appareil de l’appareil approvisionné.

   Pour en savoir plus, consultez Comprendre et utiliser les jumeaux d’appareil IoT Hub.

9. Sélectionnez Suivant : Vérifier + créer.

10. Dans l’onglet Vérifier + créer, vérifiez toutes vos valeurs, puis sélectionnez Créer.

L’exemple C# TPM pour ce démarrage rapide ne fournit pas d’ID d’inscription. Lorsque vous êtes invité à en ajouter un pour l’inscription individuelle, indiquez votre propre valeur.

1. Connectez-vous au portail Azure et accédez à votre instance du service Device Provisioning.

2. Sélectionnez Gérer les inscriptions dans la section Paramètres du menu de navigation.

3. Sélectionnez l’onglet Inscriptions individuelles, puis Ajouter une inscription individuelle.

   

4. Dans la section Inscription + approvisionnement de la page Ajouter une inscription, fournissez les informations suivantes pour configurer les détails de l’inscription :

   Champ	Description
   Attestation	Sélectionnez Module de plateforme sécurisée (TPM) comme mécanisme d’attestation.
   Paramètres de Module de plateforme sécurisée (TPM)	Indiquez la clé d’approbation utilisée pour vérifier l’appareil pour cette inscription. Vous pouvez récupérer la paire de clés de type EK (Endorsement Key) à partir du module TPM de votre appareil.
   ID d'inscription	Fournissez l’ID d’inscription unique pour l’appareil. Vous pouvez récupérer l’ID d’inscription à partir du module TPM de votre appareil.
   État d’approvisionnement	Cochez la case Activer cette inscription si vous souhaitez que cette inscription soit disponible pour approvisionner son appareil. Désélectionnez cette case si vous souhaitez désactiver l’inscription. Vous pouvez modifier ce paramètre ultérieurement.
   Stratégie de réapprovisionnement	Choisissez une stratégie de réapprovisionnement qui reflète la façon dont vous souhaitez que DPS gère les appareils qui demandent le réapprovisionnement. Pour plus d’informations, consultez Réplica de réapprovisionnement.

5. Sélectionnez Suivant : hubs IoT.

6. Sous l’onglet IoT Hubs de la page Ajouter une inscription, fournissez les informations suivantes pour déterminer les hubs IoT pour lesquels l’inscription peut approvisionner des appareils :

   Champ	Description
   Hubs IoT cibles	Sélectionnez un ou plusieurs de vos hubs IoT liés, ou ajoutez un nouveau lien à un hub IoT. Pour en savoir plus sur la liaison de hubs IoT à votre instance DPS, consultez Comment lier et gérer des hubs IoT.
   Stratégie d’allocation	Si vous avez sélectionné plusieurs hubs IoT liés, sélectionnez la façon dont vous souhaitez affecter des appareils aux différents hubs. Pour en savoir plus sur les stratégies d’allocation, consultez le guide pratique pour utiliser des stratégies d’allocation. Si vous avez sélectionné un seul hub IoT lié, nous vous recommandons d’utiliser la stratégie de distribution uniformément pondérée.

7. Sélectionnez Suivant : paramètres de l’appareil

8. Sous l’onglet Paramètres de l’appareil de la page Ajouter une inscription , fournissez les informations suivantes pour définir la configuration des appareils nouvellement approvisionnés :

   Champ	Description
   ID de l’appareil	Fournissez un ID d’appareil affecté à l’appareil approvisionné dans IoT Hub. Si vous ne fournissez pas d’ID d’appareil, l’ID d’inscription est utilisé.
   IoT Edge	Vérifiez l’activation d’IoT Edge sur les appareils provisionnés si l’appareil approvisionné exécute Azure IoT Edge. Désélectionnez cette case si cette inscription concerne un appareil sans IoT Edge activé.
   Étiquettes d’appareil	Utilisez cette zone de texte pour fournir les balises que vous souhaitez appliquer au jumeau d’appareil de l’appareil approvisionné.
   Propriétés souhaitées	Utilisez cette zone de texte pour fournir les propriétés souhaitées que vous souhaitez appliquer au jumeau d’appareil de l’appareil approvisionné.

   Pour en savoir plus, consultez Comprendre et utiliser les jumeaux d’appareil IoT Hub.

9. Sélectionnez Suivant : Vérifier + créer.

10. Dans l’onglet Vérifier + créer, vérifiez toutes vos valeurs, puis sélectionnez Créer.

Inscrire l’appareil

Dans cette section, vous allez configurer l’exemple de code pour utiliser le protocole AMQP (Advanced Message Queuing Protocol) pour envoyer la séquence de démarrage de l’appareil à votre instance de service Device Provisioning. Grâce à cette séquence de démarrage, l’appareil est inscrit dans le hub IoT lié à l’instance du service Device Provisioning.

1. Dans le portail Azure, sélectionnez l’onglet Vue d’ensemble de votre instance de service Device Provisioning.

2. Copiez la valeur Étendue de l’ID.

   

3. Dans la fenêtre Explorateur de solutions de Visual Studio, accédez au dossier Provision_Samples. Développez le projet exemple nommé prov_dev_client_sample. Développez Fichiers sources, puis ouvrez prov_dev_client_sample.c.

4. En haut du fichier, recherchez les #define instructions pour chaque protocole d’appareil, comme indiqué dans l’exemple suivant. Assurez-vous que seulement SAMPLE_AMQP ne soit pas commenté.

   Actuellement, le protocole MQTT n’est pas pris en charge pour l’inscription individuelle TPM.

   //
   // The protocol you wish to use should be uncommented
   //
   //#define SAMPLE_MQTT
   //#define SAMPLE_MQTT_OVER_WEBSOCKETS
   #define SAMPLE_AMQP
   //#define SAMPLE_AMQP_OVER_WEBSOCKETS
   //#define SAMPLE_HTTP
   

5. Recherchez la constante id_scope et remplacez la valeur par la valeur Étendue de l’ID que vous avez copiée précédemment.

   static const char* id_scope = "0ne00002193";
   

6. Recherchez la définition de la fonction main() dans le même fichier. Vérifiez que la hsm_type variable est définie SECURE_DEVICE_TYPE_TPM comme indiqué dans l’exemple suivant.

   SECURE_DEVICE_TYPE hsm_type;
   hsm_type = SECURE_DEVICE_TYPE_TPM;
   //hsm_type = SECURE_DEVICE_TYPE_X509;
   //hsm_type = SECURE_DEVICE_TYPE_SYMMETRIC_KEY;
   

7. Cliquez avec le bouton droit sur le projet dps_client_sample et sélectionnez Définir comme projet de démarrage.

8. Dans le menu Visual Studio, sélectionnez Déboguer>Exécuter sans débogage pour exécuter la solution. Dans l’invite pour régénérer le projet, sélectionnez Oui pour régénérer le projet avant de l’exécuter.

   La sortie suivante illustre un exemple d’approvisionnement d’un client d’appareil, son démarrage réussi, sa connexion à une instance de service Device Provisioning pour obtenir des informations sur le hub IoT et son inscription :

   Provisioning API Version: 1.2.7
   
   Registering... Press enter key to interrupt.
   
   Provisioning Status: PROV_DEVICE_REG_STATUS_CONNECTED
   Provisioning Status: PROV_DEVICE_REG_STATUS_ASSIGNING
   Provisioning Status: PROV_DEVICE_REG_STATUS_ASSIGNING
   
   Registration Information received from service:
   test-docs-hub.azure-devices.net, deviceId: test-docs-cert-device
   

1. Dans le portail Azure, sélectionnez l’onglet Vue d’ensemble de votre instance de service Device Provisioning.

2. Copiez la valeur Étendue de l’ID.

   

3. Dans une invite de commandes, accédez au répertoire du projet contenant l’exemple d’approvisionnement d’appareil TPM.

    cd '.\azure-iot-sdk-csharp\provisioning\device\samples\how to guides\TpmSample\'
   

4. Exécutez la commande suivante pour inscrire votre appareil. Remplacez <IdScope> par la valeur du DPS que vous venez de copier et <RegistrationId> par la valeur que vous avez utilisée lors de la création de l’inscription de l’appareil.

   dotnet run -- -s <IdScope> -r <RegistrationId>
   

   Si l’inscription de l’appareil a réussi, les messages suivants s’affichent :

   Initializing security using the local TPM...
   Initializing the device provisioning client...
   Initialized for registration Id <RegistrationId>.
   Registering with the device provisioning service...
   Registration status: Assigned.
   Device <RegistrationId> registered to <HubName>.azure-devices.net.
   Creating TPM authentication for IoT Hub...
   Testing the provisioned device with IoT Hub...
   Sending a telemetry message...
   Finished.
   

1. Dans le portail Azure, sélectionnez l’onglet Vue d’ensemble de votre instance de service Device Provisioning.

2. Copiez la valeur Étendue de l’ID.

   

3. Ouvrez l’éditeur de texte de votre choix.

4. Dans le dossier registerdevice, créez le fichier RegisterDevice.js.

5. Ajoutez les instructions require ci-dessous au début du fichier RegisterDevice.js :

   
   'use strict';
   
   var ProvisioningTransport = require('azure-iot-provisioning-device-http').Http;
   var iotHubTransport = require('azure-iot-device-mqtt').Mqtt;
   var Client = require('azure-iot-device').Client;
   var Message = require('azure-iot-device').Message;
   var tpmSecurity = require('azure-iot-security-tpm');
   var ProvisioningDeviceClient = require('azure-iot-provisioning-device').ProvisioningDeviceClient;
   

   Remarque

   Le Kit de développement logiciel (SDK) Azure IoT pour Node.js prend en charge d’autres protocoles tels que AMQP, AMQP WS et MQTT WS. Pour plus d’exemples, consultez les exemples de kit de développement logiciel (SDK) du service Device Provisioning pour Node.js.

6. Ajoutez les variables globalDeviceEndpoint et idScope, et utilisez-les pour créer une instance ProvisioningDeviceClient. Remplacez {globalDeviceEndpoint} et {idScope} par les valeurs de point de terminaison d’appareil global et d’étendue d’ID de l’étape 1 :

   
   var provisioningHost = '{globalDeviceEndpoint}';
   var idScope = '{idScope}';
   
   var tssJs = require("tss.js");
   var securityClient = new tpmSecurity.TpmSecurityClient('', new tssJs.Tpm(true));
   // if using non-simulated device, replace the above line with following:
   //var securityClient = new tpmSecurity.TpmSecurityClient();
   
   var provisioningClient = ProvisioningDeviceClient.create(provisioningHost, idScope, new ProvisioningTransport(), securityClient);
   

7. Ajoutez la fonction suivante pour implémenter la méthode sur l’appareil :

   
   provisioningClient.register(function(err, result) {
     if (err) {
       console.log("error registering device: " + err);
     } else {
       console.log('registration succeeded');
       console.log('assigned hub=' + result.registrationState.assignedHub);
       console.log('deviceId=' + result.registrationState.deviceId);
       var tpmAuthenticationProvider = tpmSecurity.TpmAuthenticationProvider.fromTpmSecurityClient(result.registrationState.deviceId, result.registrationState.assignedHub, securityClient);
       var hubClient = Client.fromAuthenticationProvider(tpmAuthenticationProvider, iotHubTransport);
   
       var connectCallback = function (err) {
         if (err) {
           console.error('Could not connect: ' + err.message);
         } else {
           console.log('Client connected');
           var message = new Message('Hello world');
           hubClient.sendEvent(message, printResultFor('send'));
         }
       };
   
       hubClient.open(connectCallback);
   
       function printResultFor(op) {
         return function printResult(err, res) {
           if (err) console.log(op + ' error: ' + err.toString());
           if (res) console.log(op + ' status: ' + res.constructor.name);
           process.exit(1);
         };
       }
     }
   });
   

8. Enregistrez et fermez le fichier RegisterDevice.js.

9. Exécutez la commande suivante :

   node RegisterDevice.js
   

10. Notez les messages qui simulent le démarrage et la connexion de l’appareil au service d’approvisionnement d’appareil pour obtenir des informations concernant votre IoT Hub.

1. Dans la fenêtre de commande exécutant l’exemple de code Java sur votre machine, appuyez sur Entrée pour continuer à exécuter l’application. Notez les messages qui simulent le démarrage et la connexion de l’appareil au service d’approvisionnement d’appareil pour obtenir des informations concernant votre IoT Hub.