Envoyer et recevoir des messages cloud-à-appareil

Article
01/01/2025

Azure IoT Hub est un service entièrement managé qui permet des communications bidirectionnelles, y compris les messages cloud-à-appareil (C2D) de la solution back-ends vers des millions d’appareils.

Cet article explique comment utiliser les kits SDK Azure IoT pour générer les types d’applications suivants :

Applications d’appareil qui reçoivent et gèrent des messages cloud-à-appareil à partir d’une file d’attente de messagerie IoT Hub.
Applications principales qui envoient des messages cloud-à-appareil à un seul appareil via une file d’attente de messagerie IoT Hub.

Cet article est destiné à compléter les exemples de SDK exécutables référencés à partir de cet article.

Remarque

Les fonctionnalités décrites dans cet article sont uniquement disponibles au niveau Standard d’IoT Hub. Pour plus d’informations sur les niveaux de base et standard/gratuit d’IoT Hub, consultez Choisir le niveau IoT Hub correspondant à votre solution.

Vue d’ensemble

Pour qu’une application d’appareil reçoive des messages cloud-à-appareil, elle doit se connecter à IoT Hub, puis configurer un gestionnaire de messages pour traiter les messages entrants. Les SDK de l’appareil Azure IoT Hub fournissent des classes et des méthodes qu’un appareil peut utiliser pour recevoir et gérer les messages du service. Cet article décrit les éléments clés de n’importe quelle application d’appareil qui reçoit des messages, notamment :

Déclarer un objet client d’appareil
Connexion à IoT Hub
Récupérer des messages à partir de la file d’attente de messages IoT Hub
Traiter le message et renvoyer un accusé de réception à IoT Hub
Configurer une stratégie de nouvelle tentative de message de réception

Pour qu’une application principale envoie des messages cloud-à-appareil, elle doit se connecter à un Hub IoT et envoyer des messages via une file d’attente de messages IoT Hub. Les SDK du service Azure IoT Hub fournissent des classes et des méthodes qu’une application peut utiliser pour envoyer des messages aux appareils. Cet article traite des éléments clés de n’importe quelle application qui envoie des messages à des appareils, notamment :

Déclarer un objet client de service
Connexion à IoT Hub
Générer et envoyer le message
Réception des commentaires de remise
Configurer une stratégie de nouvelle tentative d’envoi de message

Comprendre la file d'attente des messages

Pour comprendre la messagerie cloud vers appareil, il est important de comprendre quelques principes fondamentaux sur le fonctionnement des files d’attente de messages des appareils IoT Hub.

Les messages cloud-à-appareil envoyés à partir d’une application back-end de solution vers un appareil IoT sont routés via IoT Hub. Il n’existe aucune communication directe entre la messagerie homologue à pair entre l’application back-end de la solution et l’appareil cible. IoT Hub place les messages entrants dans sa file d’attente de messages, prêts à être téléchargés par les appareils IoT cibles.

Pour garantir une remise de messages au moins une fois, IoT Hub conserve les messages cloud-à-appareil dans les files d’attente par appareil. Les appareils doivent explicitement accuser réception d’un message avant que IoT Hub ne supprime le message de la file d’attente. Cette approche garantit la résilience contre les échecs de connectivité et d’appareils.

Quand IoT Hub place un message dans une file d’attente de messages d’appareil, il définit l’état du message sur mise en file d’attente. Lorsqu’un thread d’appareil extrait un message de la file d’attente, IoT Hub verrouille le message en définissant l’état du message sur Invisible. Cet état empêche les autres threads sur l’appareil de traiter le même message. Lorsqu’un thread d’appareil termine correctement le traitement d’un message, il notifie IoT Hub, puis IoT Hub définit l’état du message sur Terminé.

Une application d’appareil qui reçoit et traite correctement un message est dite Terminer le message. Toutefois, si nécessaire, un appareil peut également :

Rejeter le message, ce qui permet à IoT Hub de le définir à l’état lettre morte. Les appareils qui se connectent via le protocole MQTT (Message Queuing Telemetry Transport) ne peuvent pas rejeter les messages cloud-à-appareil.
Abandonner le message, ce qui permet à IoT Hub de remettre le message dans la file d’attente, avec l’état du message défini sur mise en file d’attente. Les appareils qui se connectent via le protocole MQTT ne peuvent pas abandonner les messages cloud-à-appareil.

Pour plus d’informations sur le cycle de vie des messages cloud-à-appareil et sur la manière dont l’IoT Hub traite les messages cloud-à-appareil, consultez Envoyer des messages cloud-à-appareil à partir d’un hub IoT.

Créer une application d’appareil

Cette section décrit comment recevoir des messages cloud-à-appareil.

Il existe deux options qu’une application cliente d’appareil peut utiliser pour recevoir des messages :

Rappel: l’application d’appareil configure une méthode de gestionnaire de messages asynchrone appelée immédiatement lorsqu’un message arrive.
Interrogation : l’application de l’appareil recherche de nouveaux messages IoT Hub à l’aide d’une boucle de code (par exemple, une boucle while ou for). La boucle s’exécute en continu, en vérifiant les messages.

Package NuGet d’appareil nécessaire

Les applications clientes d’appareil écrites en C# nécessitent le package NuGet Microsoft.Azure.Devices.Client.

Ajoutez ces instructions using pour utiliser la bibliothèque d’appareils.

using Microsoft.Azure.Devices.Client;
using Microsoft.Azure.Devices.Shared;

Connecter un appareil à IoT Hub

Un appareil périphérique peut être authentifié auprès d’IoT Hub à l’aide des méthodes suivantes :

Clé d’accès partagé
Certificat X.509

Important

Cet article comprend les étapes à suivre pour connecter un appareil en utilisant une signature d’accès partagé, également appelée « authentification par clé symétrique ». Cette méthode d’authentification est pratique pour les tests et les évaluations, mais l’authentification d’un appareil en utilisant des certificats X.509 est une approche plus sécurisée. Pour plus d’informations, consultez Meilleures pratiques de sécurité > Sécurité des connexions.

S’authentifier à l’aide d’une clé d’accès partagé

La classe DeviceClient expose toutes les méthodes requises pour recevoir des messages sur l’appareil.

Fournir les paramètres de connexion

Fournissez la chaîne de connexion principale IoT Hub et l’ID de l’appareil à l’aide de DeviceClient en utilisant la méthode CreateFromConnectionString. Outre la chaîne de connexion principale IoT Hub requise, la méthode CreateFromConnectionString peut être surchargée pour inclure ces paramètres de facultatifs :

transportType - Le protocole de transport : variantes de HTTP version 1, AMQP ou MQTT. AMQP est la valeur par défaut. Pour afficher toutes les valeurs disponibles, consultez Énumération TransportType.
transportSettings - - Interface utilisée pour définir divers paramètres spécifiques au transport pour DeviceClient et ModuleClient. Pour plus d’informations, consultez interface ITransportSettings.
ClientOptions : options qui autorisent la configuration de l’instance cliente de l’appareil ou du module pendant l’initialisation.

Cet exemple se connecte à un appareil à l’aide du protocole de transfert Mqtt.

static string DeviceConnectionString = "{IoT hub device connection string}";
static deviceClient = null;
deviceClient = DeviceClient.CreateFromConnectionString(DeviceConnectionString, 
   TransportType.Mqtt);

S’authentifier à l’aide d’un certificat X.509

Pour connecter un appareil à IoT Hub à l’aide d’un certificat X.509 :

Utilisez DeviceAuthenticationWithX509Certificate pour créer un objet qui contient des informations sur l’appareil et le certificat. DeviceAuthenticationWithX509Certificate est passé en tant que deuxième paramètre à DeviceClient.Create (étape 2).
Utilisez DeviceClient.Create pour connecter l’appareil à IoT Hub à l’aide d’un certificat X.509.

Dans cet exemple, les informations sur l’appareil et le certificat sont renseignées dans l’objet auth DeviceAuthenticationWithX509Certificate passé à DeviceClient.Create.

Cet exemple montre les valeurs des paramètres d’entrée du certificat en tant que variables locales pour plus de clarté. Dans un système de production, stockez des paramètres d’entrée sensibles dans des variables d’environnement ou un autre emplacement de stockage plus sécurisé. Par exemple, utilisez cette option Environment.GetEnvironmentVariable("HOSTNAME") pour lire la variable d’environnement du nom d’hôte.

RootCertPath = "~/certificates/certs/sensor-thl-001-device.cert.pem";
Intermediate1CertPath = "~/certificates/certs/sensor-thl-001-device.intermediate1.cert.pem";
Intermediate2CertPath = "~/certificates/certs/sensor-thl-001-device.intermediate2.cert.pem";
DevicePfxPath = "~/certificates/certs/sensor-thl-001-device.cert.pfx";
DevicePfxPassword = "1234";
DeviceName = "MyDevice";
HostName = "xxxxx.azure-devices.net";

var chainCerts = new X509Certificate2Collection();
chainCerts.Add(new X509Certificate2(RootCertPath));
chainCerts.Add(new X509Certificate2(Intermediate1CertPath));
chainCerts.Add(new X509Certificate2(Intermediate2CertPath));
using var deviceCert = new X509Certificate2(DevicePfxPath, DevicePfxPassword);
using var auth = new DeviceAuthenticationWithX509Certificate(DeviceName, deviceCert, chainCerts);

using var deviceClient = DeviceClient.Create(
    HostName,
    auth,
    TransportType.Amqp);

Pour plus d’informations sur l’authentification par certificat, consultez :

Exemples de code

Pour obtenir des exemples de fonctionnement de l’authentification d’un appareil avec le certificat X.509, consultez :

Rappel

Pour recevoir des messages de rappel cloud-à-appareil dans l'application de l'appareil, l'application doit se connecter à IoT Hub et configurer un écouteur de rappel pour traiter les messages entrants. Les messages entrants de l’appareil sont reçus à partir de la file d’attente de messages IoT Hub.

À l’aide du rappel, l’application d’appareil configure une méthode de gestionnaire de messages à l’aide de SetReceiveMessageHandlerAsync. Le gestionnaire de messages est appelé, puis un message est reçu. La création d’une méthode de rappel pour recevoir des messages supprime la nécessité d’interroger en permanence les messages reçus.

Le rappel est disponible uniquement à l’aide de ces protocoles :

Mqtt
Mqtt_WebSocket_Only
Mqtt_Tcp_Only
Amqp
Amqp_WebSocket_Only
Amqp_Tcp_only

L’option de protocole Http1 ne prend pas en charge les rappels, car les méthodes du Kit de développement logiciel (SDK) doivent interroger les messages reçus de toute façon, ce qui bat le principe de rappel.

Dans cet exemple, SetReceiveMessageHandlerAsync configure une méthode de gestionnaire de rappel nommée OnC2dMessageReceivedAsync, appelée chaque fois qu’un message est reçu.

// Subscribe to receive C2D messages through a callback (which isn't supported over HTTP).
await deviceClient.SetReceiveMessageHandlerAsync(OnC2dMessageReceivedAsync, deviceClient);
Console.WriteLine($"\n{DateTime.Now}> Subscribed to receive C2D messages over callback.");

Interrogation

L'interrogation utilise ReceiveAsync pour vérifier les messages.

Un appel à ReceiveAsync peut prendre ces formes :

ReceiveAsync() : attendez la période d’expiration par défaut d’un message avant de continuer.
ReceiveAsync (Timespan) : recevez un message de la file d’attente de l’appareil à l’aide d’un délai d’expiration spécifique.
ReceiveAsync (CancellationToken) : recevez un message de la file d’attente de l’appareil à l’aide d’un jeton d’annulation. Lors de l’utilisation d’un jeton d’annulation, la période d’expiration par défaut n’est pas utilisée.

Lorsque vous utilisez un type de transport HTTP 1 au lieu de MQTT ou AMQP, la méthode ReceiveAsync retourne immédiatement. Le modèle pris en charge pour les messages cloud-à-appareil avec HTTP 1 est des appareils connectés par intermittence qui vérifient les messages rarement (un minimum de toutes les 25 minutes). L’émission de plus de réceptions HTTP 1 entraîne la limitation des requêtes IoT Hub. Pour plus d’informations sur les différences entre la prise en charge de MQTT, AMQP et HTTP 1, consultez conseils de communication cloud-à-appareil et Choisir un protocole de communication.

Méthode CompleteAsync

Une fois que l’appareil reçoit un message, l’application de l’appareil appelle la méthode CompleteAsync pour informer IoT Hub que le message a été traité avec succès et qu’il peut être supprimé en toute sécurité de la file d’attente de l’appareil IoT Hub. L’appareil doit appeler cette méthode lorsque son traitement se termine correctement, quel que soit le protocole de transport qu’il utilise.

Abandon, rejet ou délai d’expiration du message

Avec les protocoles AMQP et HTTP version 1, mais pas les protocole MQTT, l’appareil peut également :

Abandonnez un message en appelant AbandonAsync. Ainsi, IoT Hub conserve le message dans la file d’attente de l’appareil pour une consommation future.
Rejeter un message en appelant RejectAsync. Cela supprime définitivement le message de la file d’attente de l’appareil.

S’il se produit un événement qui empêche l’appareil de traiter, d’abandonner ou de rejeter le message, IoT Hub le met à nouveau en file d’attente après un délai d’attente déterminé. C’est la raison pour laquelle la logique de traitement des messages de l’application pour périphérique doit être idempotente pour qu’un message identique reçu plusieurs fois produise le même résultat.

Boucle d’interrogation

À l’aide de l’interrogation, une application utilise une boucle de code qui appelle la méthode ReceiveAsync à plusieurs reprises pour rechercher les nouveaux messages jusqu’à ce qu’ils s’arrêtent.

Si vous utilisez ReceiveAsync avec une valeur de délai d’attente ou le délai d’expiration par défaut, dans la boucle, chaque appel à ReceiveAsync attend la période d’expiration spécifiée. Si ReceiveAsync expire, une valeur null est retournée et la boucle continue.

Lorsqu'un message est reçu, un objet Task est renvoyé par ReceiveAsync qui doit être transmis à CompleteAsync. Un appel à CompleteAsync avertit IoT Hub de supprimer le message spécifié de la file d’attente de messages en fonction du paramètre Task.

Dans cet exemple, la boucle appelle ReceiveAsync jusqu’à ce qu’un message soit reçu ou que la boucle d’interrogation soit arrêtée.

static bool stopPolling = false;

while (!stopPolling)
{
   // Check for a message. Wait for the default DeviceClient timeout period.
   using Message receivedMessage = await _deviceClient.ReceiveAsync();

   // Continue if no message was received
   if (receivedMessage == null)
   {
      continue;
   }
   else  // A message was received
   {
      // Print the message received
      Console.WriteLine($"{DateTime.Now}> Polling using ReceiveAsync() - received message with Id={receivedMessage.MessageId}");
      PrintMessage(receivedMessage);

      // Notify IoT Hub that the message was received. IoT Hub will delete the message from the message queue.
      await _deviceClient.CompleteAsync(receivedMessage);
      Console.WriteLine($"{DateTime.Now}> Completed C2D message with Id={receivedMessage.MessageId}.");
   }

   // Check to see if polling loop should end
   stopPolling = ShouldPollingstop ();
}

Recevoir une stratégie de nouvelle tentative de message

La stratégie de nouvelle tentative de message du client d’appareil peut être définie à l’aide de DeviceClient.SetRetryPolicy.

Le délai d’attente de nouvelle tentative de message est stocké dans la propriété DeviceClient.OperationTimeoutInMilliseconds.

Exemple de message de réception du SDK

Le Kit de développement logiciel (SDK) .NET/C# inclut un exemple Message Receive qui inclut les méthodes de message de réception décrites dans cette section.

Créer une application back-end

Cette section décrit le code essentiel pour envoyer un message d’une application back-end de solution à un appareil IoT à l’aide de la classe ServiceClient dans le Kit de développement logiciel (SDK) Azure IoT pour .NET. Comme indiqué précédemment, une application backend de solution se connecte à un IoT Hub et les messages sont envoyés à IoT Hub codés avec un appareil de destination. IoT Hub stocke les messages entrants dans sa file d’attente de messages et les messages sont remis de la file d’attente de messages IoT Hub à l’appareil cible.

Une application back-end de solution peut également demander et recevoir un retour de livraison pour un message envoyé à IoT Hub destiné à être distribué sur l'appareil via la file d'attente des messages.

Ajouter un package NuGet de service

Les applications de service principal nécessitent le package NuGet Microsoft.Azure.Devices.

Se connecter au hub IoT

Vous pouvez connecter un service back-end à IoT Hub à l’aide des méthodes suivantes :

Stratégie d’accès partagé
Microsoft Entra

Important

Cet article comprend les étapes à suivre pour se connecter à un service à l’aide d’une signature d’accès partagé. Cette méthode d’authentification est pratique pour les tests et les évaluations, mais l’authentification à un service avec Microsoft Entra ID ou des identités managées est une approche plus sécurisée. Pour plus d’informations, consultez Meilleures pratiques de sécurité > Sécurité du cloud.

Se connecter à l’aide d’une stratégie d’accès partagé

Fournir la chaîne de connexion

Connectez une application back-end à un appareil à l’aide de CreateFromConnectionString. Outre la chaîne de connexion principale IoT Hub requise, la méthode CreateFromConnectionString peut être surchargée pour inclure ces paramètres de facultatifs :

transportType - Amqp ou Amqp_WebSocket_Only.
transportSettings : paramètres de proxy AMQP et HTTP pour le client de service.
ServiceClientOptions : options qui autorisent la configuration de l’instance du client de service lors de l’initialisation. Pour plus d’informations, consultez ServiceClientOptions.

Cet exemple crée l’objet ServiceClient à l’aide de la chaîne de connexion IoT Hub et du transport Amqp par défaut.

static string connectionString = "{your IoT hub connection string}";
serviceClient = ServiceClient.CreateFromConnectionString(connectionString);

Se connecter à l’aide de Microsoft Entra

Une application back-end qui utilise Microsoft Entra doit s’authentifier et obtenir des informations d’identification de jeton de sécurité avant de se connecter à IoT Hub. Ce jeton est passé à une méthode de connexion IoT Hub. Pour obtenir des informations générales sur la configuration et l’utilisation de Microsoft Entra pour IoT Hub, consultez Contrôler l’accès à IoT Hub à l’aide de Microsoft Entra ID.

Configurer l’application Microsoft Entra

Vous devez configurer une application Microsoft Entra configurée pour vos informations d’identification d’authentification préférées. L’application contient des paramètres tels que la clé secrète client utilisée par l’application back-end pour s’authentifier. Les configurations d’authentification d’application disponibles sont les suivantes :

Clè secrète client
Certificat
Informations d’identification d’identité fédérée

Les applications Microsoft Entra peuvent nécessiter des autorisations de rôle spécifiques en fonction des opérations effectuées. Par exemple, le Contributeur de jumeaux IoT Hub est nécessaire pour activer l’accès en lecture et en écriture à un appareil IoT Hub et à des jumeaux de module. Pour plus d’informations, consultez Gérer l’accès à IoT Hub à l’aide de l’attribution de rôle RBAC Azure.

Pour plus d’informations concernant la configuration d’une application Microsoft Entra, consultez Démarrage rapide : inscrire une application auprès de la plateforme d’identités Microsoft.

S’authentifier à l’aide de DefaultAzureCredential

Le moyen le plus simple d’utiliser Microsoft Entra pour authentifier une application back-end consiste à utiliser DefaultAzureCredential. Cependant, nous vous recommandons d’utiliser une autre méthode dans un environnement de production, y compris un TokenCredential spécifique ou un ChainedTokenCredential simplifié. Par souci de simplicité, cette section décrit l’authentification à l’aide de DefaultAzureCredential et de la clé secrète client. Pour plus d’informations sur les avantages et les inconvénients de l’utilisation de DefaultAzureCredential, consultez Conseils d’utilisation pour DefaultAzureCredential.

DefaultAzureCredential prend en charge différents mécanismes d’authentification et détermine le type d’informations d’identification approprié en fonction de l’environnement dans lequel il s’exécute. Cette méthode tente d’utiliser plusieurs types d’informations d’identification dans un ordre jusqu’à ce qu’elle trouve des informations d’identification fonctionnelles.

Microsoft Entra nécessite ces packages NuGet et les instructions using correspondantes :

Azure.Core
Azure.Identity

using Azure.Core;
using Azure.Identity;

Dans cet exemple, la clé secrète client d’inscription de l’application Microsoft Entra, l’ID client et l’ID de locataire sont ajoutés aux variables d’environnement. Ces variables d’environnement sont utilisées par DefaultAzureCredential pour authentifier l’application. Le résultat d’une authentification Microsoft Entra réussie est une information d’identification de jeton de sécurité passée à une méthode de connexion IoT Hub.

string clientSecretValue = "xxxxxxxxxxxxxxx";
string clientID = "xxxxxxxxxxxxxx";
string tenantID = "xxxxxxxxxxxxx";

Environment.SetEnvironmentVariable("AZURE_CLIENT_SECRET", clientSecretValue);
Environment.SetEnvironmentVariable("AZURE_CLIENT_ID", clientID);
Environment.SetEnvironmentVariable("AZURE_TENANT_ID", tenantID);

TokenCredential tokenCredential = new DefaultAzureCredential();

Le TokenCredential résultant peut ensuite être passé pour se connecter à une méthode IoT Hub pour n’importe quel client du Kit de développement logiciel (SDK) qui accepte les informations d’identification Microsoft Entra :

Dans cet exemple, TokenCredential est passé à ServiceClient.Create pour créer un objet de connexion ServiceClient.

string hostname = "xxxxxxxxxx.azure-devices.net";
using var serviceClient = ServiceClient.Create(hostname, tokenCredential, TransportType.Amqp);

Dans cet exemple, TokenCredential est passé à RegistryManager.Create pour créer un objet RegistryManager.

string hostname = "xxxxxxxxxx.azure-devices.net";
registryManager = RegistryManager.Create(hostname, tokenCredential);

Exemple de code

Pour obtenir un exemple fonctionnel de l’authentification du service Microsoft Entra, consultez Exemple d’authentification basée sur les rôles.

Envoyer un message cloud-à-appareil asynchrone

Utilisez sendAsync pour envoyer un message asynchrone depuis une application via le cloud (IoT Hub) vers l'appareil. L’appel est effectué à l’aide du protocole AMQP.

sendAsync utilise ces paramètres :

deviceID : identificateur de chaîne de l’appareil cible.
message - Message cloud-à-appareil. Le message est de type Message et peut être mis en forme en conséquence.
timeout - Une valeur de délai d'attente facultative. La valeur par défaut est d’une minute si elle n’est pas spécifiée.

Cet exemple envoie un message de test à l’appareil cible avec une valeur de délai d’expiration de 10 secondes.

string targetDevice = "Device-1";
static readonly TimeSpan operationTimeout = TimeSpan.FromSeconds(10);
var commandMessage = new
Message(Encoding.ASCII.GetBytes("Cloud to device message."));
await serviceClient.SendAsync(targetDevice, commandMessage, operationTimeout);

Réception des commentaires de remise

Un programme d’envoi peut demander des accusés de réception (ou d’expiration) à IoT Hub pour chaque message cloud-à-appareil. Cette option permet au programme d’envoi d’utiliser la logique d’information, de nouvelle tentative ou de compensation. Une description complète des opérations et des propriétés de retour de message est décrite dans Retour de message.

Pour recevoir des commentaires sur la remise des messages :

Créer l’objet feedbackReceiver
Envoyer des messages en utilisant le paramètre Ack
Attendez de recevoir des commentaires

Créer l'objet feedbackReceiver

Appelez GetFeedbackReceiver pour créer un objet FeedbackReceiver . FeedbackReceiver contient des méthodes que les services peuvent utiliser pour effectuer des opérations de réception de commentaires.

var feedbackReceiver = serviceClient.GetFeedbackReceiver();

Envoyer des messages à l’aide du paramètre Ack

Chaque message doit inclure une valeur pour l’accusé de réception propriété Ack afin de recevoir des commentaires de remise. La propriété Ack peut être l’une des valeurs suivantes :

aucun (valeur par défaut) : aucun message de commentaires n’est généré.
Positive: recevez un message de commentaires si le message a été terminé.
Negative: recevez un message de commentaires si le message a expiré (ou le nombre maximal de remises a été atteint) sans être terminé par l’appareil.
Full: commentaires pour les résultats Positive et Negative.

Dans cet exemple, la propriété Ack est définie sur Full, demandant un retour de livraison de message positif ou négatif pour un message.

var commandMessage = new
Message(Encoding.ASCII.GetBytes("Cloud to device message."));
commandMessage.Ack = DeliveryAcknowledgement.Full;
await serviceClient.SendAsync(targetDevice, commandMessage);

Attendez de recevoir des commentaires

Définissez une CancellationToken. Ensuite, dans une boucle, appelez ReceiveAsync à plusieurs reprises, en vérifiant les messages de commentaires de remise. Chaque appel à ReceiveAsync attend la période d’expiration définie pour l’objet ServiceClient.

Si un délai d’expiration ReceiveAsync expire sans message reçu, ReceiveAsync retourne null et la boucle continue.
Si un message de commentaires est reçu, un objet Task est retourné par ReceiveAsync qui doit être transmis à CompleteAsync, ainsi que le jeton d’annulation. Un appel à CompleteAsync supprime le message envoyé spécifié de la file d’attente de messages en fonction du paramètre Task.
Si nécessaire, le code de réception peut appeler AbandonAsync pour remettre un message d'envoi dans la file d'attente.

var feedbackReceiver = serviceClient.GetFeedbackReceiver();

// Define the cancellation token.
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
// Call ReceiveAsync, passing the token. Wait for the timout period.
var feedbackBatch = await feedbackReceiver.ReceiveAsync(token);
if (feedbackBatch == null) continue;

Cet exemple montre une méthode qui inclut ces étapes.

private async static void ReceiveFeedbackAsync()
{
      var feedbackReceiver = serviceClient.GetFeedbackReceiver();

      Console.WriteLine("\nReceiving c2d feedback from service");
      while (true)
      {
         // Check for messages, wait for the timeout period.
         var feedbackBatch = await feedbackReceiver.ReceiveAsync();
         // Continue the loop if null is received after a timeout.
         if (feedbackBatch == null) continue;

         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine("Received feedback: {0}",
            string.Join(", ", feedbackBatch.Records.Select(f => f.StatusCode)));
         Console.ResetColor();

         await feedbackReceiver.CompleteAsync(feedbackBatch);
      }
   }

Notez que ce modèle de réception de commentaires est similaire au modèle utilisé pour recevoir des messages cloud-à-appareil dans l’application d’appareil.

Reconnexion du client de service

Lors de la rencontre d’une exception, le client de service transmet ces informations à l’application appelante. À ce stade, il est recommandé d’inspecter les détails de l’exception et de prendre les mesures nécessaires.

Par exemple :

S’il s’agit d’une exception réseau, vous pouvez réessayer l’opération.
S’il s’agit d’une exception de sécurité (exception non autorisée), inspectez vos informations d’identification et vérifiez qu’elles sont à jour.
S’il s’agit d’une exception de limitation/quota dépassée, surveillez et/ou modifiez la fréquence d’envoi de requêtes, ou mettez à jour votre unité d’échelle d’instance hub. Consultez Quotas et limitation IoT Hub pour plus de détails.

Envoyer une stratégie de nouvelle tentative de message

La stratégie de nouvelle tentative de message ServiceClient peut être définie à l’aide de ServiceClient.SetRetryPolicy.

Exemple de message d'envoi du SDK

Le SDK .NET/C# inclut un exemple de client de service qui inclut les méthodes d'envoi de message décrites dans cette section.

Créer une application d’appareil

Cette section explique comment recevoir des messages cloud-à-appareil à l’aide de la classe DeviceClient du Kit de développement logiciel (SDK) Azure IoT pour Java.

Pour qu’une application d’appareil basée sur Java reçoive des messages cloud vers appareil, elle doit se connecter à IoT Hub, puis configurer un écouteur de rappel et un gestionnaire de messages pour traiter les messages entrants provenant d’IoT Hub.

Importer des bibliothèques du Kit de développement logiciel (SDK) Java Azure IoT

Le code référencé dans cet article utilise ces bibliothèques SDK.

import com.microsoft.azure.sdk.iot.device.*;
import com.microsoft.azure.sdk.iot.device.exceptions.IotHubClientException;
import com.microsoft.azure.sdk.iot.device.transport.IotHubConnectionStatus;

Connecter un appareil à IoT Hub

Un appareil périphérique peut être authentifié auprès d’IoT Hub à l’aide des méthodes suivantes :

Clé d’accès partagé
Certificat X.509

Important

S’authentifier à l’aide d’une clé d’accès partagé

L'instanciation de l'objet DeviceClient nécessite ces paramètres :

connString : Chaîne de connexion de l’appareil IoT. La chaîne de connexion est un ensemble de paires clé-valeur séparées par « ; », avec les clés et les valeurs séparées par '='. Elle doit contenir des valeurs pour ces clés : HostName, DeviceId, and SharedAccessKey.
Protocole de transport : la connexion DeviceClient peut utiliser l’un des protocoles de transport IoTHubClientProtocol suivants . AMQP est le plus polyvalent, permet de vérifier fréquemment les messages et permet le rejet et l’annulation des messages. MQTT ne prend pas en charge les méthodes de rejet ou d’abandon des messages :
- AMQPS
- AMQPS_WS
- HTTPS
- MQTT
- MQTT_WS

Par exemple :

static string connectionString = "{IOT hub device connection string}";
static protocol = IotHubClientProtocol.AMQPS;
DeviceClient client = new DeviceClient(connectionString, protocol);

S’authentifier à l’aide d’un certificat X.509

Pour connecter un appareil à IoT Hub à l’aide d’un certificat X.509 :

Générez l’objet SSLContextà l’aide de buildSSLContext.
Ajoutez les SSLContext informations à un objet ClientOptions.
Appelez DeviceClient à l’aide des ClientOptions informations pour créer la connexion device-to-IoT Hub.

Cet exemple montre les valeurs des paramètres d’entrée du certificat en tant que variables locales pour plus de clarté. Dans un système de production, stockez des paramètres d’entrée sensibles dans des variables d’environnement ou un autre emplacement de stockage plus sécurisé. Par exemple, utilisez Environment.GetEnvironmentVariable("PUBLICKEY") pour lire une variable d’environnement de chaîne du certificat de clé publique.

private static final String publicKeyCertificateString =
        "-----BEGIN CERTIFICATE-----\n" +
        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n" +
        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n" +
        "-----END CERTIFICATE-----\n";

//PEM encoded representation of the private key
private static final String privateKeyString =
        "-----BEGIN EC PRIVATE KEY-----\n" +
        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n" +
        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n" +
        "-----END EC PRIVATE KEY-----\n";

SSLContext sslContext = SSLContextBuilder.buildSSLContext(publicKeyCertificateString, privateKeyString);
ClientOptions clientOptions = ClientOptions.builder().sslContext(sslContext).build();
DeviceClient client = new DeviceClient(connString, protocol, clientOptions);

Pour plus d’informations sur l’authentification par certificat, consultez :

Exemples de code

Pour obtenir des exemples de fonctionnement de l’authentification d’un appareil avec le certificat X.509, consultez :

Définir la méthode de rappel de message

Utilisez la méthode setMessageCallback pour définir une méthode de gestionnaire de messages qui est avertie lorsqu'un message est reçu d'IoT Hub.

setMessageCallback inclut ces paramètres :

callback - Nom de la méthode de rappel. Peut être null.
context - Contexte facultatif de type object. Utilisez null si aucune spécification n’est spécifiée.

Dans cet exemple, une méthode callback nommée MessageCallback sans paramètre de contexte n’est passée à setMessageCallback.

client.setMessageCallback(new MessageCallback(), null);

Créer un gestionnaire de rappel de message

Un gestionnaire de messages de rappel reçoit et traite un message entrant transmis à partir de la file d’attente des messages IoT Hub.

Dans cet exemple, le gestionnaire de messages traite un message entrant, puis retourne IotHubMessageResult.COMPLETE. Une valeur de retour IotHubMessageResult.COMPLETE informe IoT Hub que le message est correctement traité et que le message peut être supprimé en toute sécurité de la file d’attente de l’appareil. L’appareil doit retourner IotHubMessageResult.COMPLETE une fois son traitement terminé, en informant IoT Hub que le message doit être supprimé de la file d’attente de messages, quel que soit le protocole qu’il utilise.

  protected static class MessageCallback implements com.microsoft.azure.sdk.iot.device.MessageCallback
  {
      public IotHubMessageResult onCloudToDeviceMessageReceived(Message msg, Object context)
      {
          System.out.println(
                  "Received message with content: " + new String(msg.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET));
          // Notify IoT Hub that the message
          return IotHubMessageResult.COMPLETE;
      }
  }

Options d’abandon et de rejet des messages

Bien que le grand nombre de messages entrants d’un appareil soit correctement reçu et entraîne IotHubMessageResult.COMPLETE, il peut être nécessaire d’abandonner ou de rejeter un message.

Avec AMQP et HTTPS, mais pas MQTT, une application peut :
- IotHubMessageResult.ABANDON le message. IoT Hub le remet en file d'attente et le renvoie plus tard.
- IotHubMessageResult.REJECT le message. IoT Hub ne met pas en file d’attente le message et supprime définitivement le message de la file d’attente des messages.
Les clients utilisant MQTT ou MQTT_WS ne peuvent pas ABANDON ou REJECT messages.

Notes

Si vous utilisez HTTPS plutôt que MQTT ou AMQP comme moyen de transport, l'instance DeviceClient ne vérifie pas très souvent les messages provenant d'IoT Hub (au minimum toutes les 25 minutes). Pour plus d'informations sur les différences de prise en charge entre MQTT, AMQP et HTTPS, consultez Conseils sur les communications cloud-à-appareil et Choisir un protocole de communication.

Créer la méthode de rappel d’état du message

Une application peut utiliser registerConnectionStatusChangeCallback pour enregistrer une méthode de rappel à exécuter lorsque l'état de connexion de l'appareil change. Ainsi, l’application peut détecter une connexion de messages arrêtés et tenter de se reconnecter.

Dans cet exemple, IotHubConnectionStatusChangeCallbackLogger est inscrite en tant que méthode de rappel de changement d’état de connexion.

client.registerConnectionStatusChangeCallback(new IotHubConnectionStatusChangeCallbackLogger(), new Object());

Le rappel est déclenché et passé un objet ConnectionStatusChangeContext.

Appelez connectionStatusChangeContext.getNewStatus() pour obtenir l’état de connexion actuel.

IotHubConnectionStatus status = connectionStatusChangeContext.getNewStatus();

L’état de connexion retourné peut être l’une des valeurs suivantes :

IotHubConnectionStatus.DISCONNECTED
IotHubConnectionStatus.DISCONNECTED_RETRYING
IotHubConnectionStatus.CONNECTED

Appelez connectionStatusChangeContext.getNewStatusReason() pour obtenir la raison du changement d’état de la connexion.

IotHubConnectionStatusChangeReason statusChangeReason = connectionStatusChangeContext.getNewStatusReason();

Appelez connectionStatusChangeContext.getCause() pour trouver la raison de la modification de l’état de la connexion. getCause() peut retourner null si aucune information n’est disponible.

Throwable throwable = connectionStatusChangeContext.getCause();
if (throwable != null)
    throwable.printStackTrace();

Consultez l’exemple de HandleMessages listé dans l’exemple de message SDK recevoir l’exemple de message de cet article pour obtenir un exemple complet montrant comment extraire l’état de modification de l’état de la méthode de rappel de changement d’état, raison pour laquelle l’état de l’appareil a changé et le contexte.

Ouvrir la connexion entre l’appareil et IoT Hub

Utilisez ouvrir pour créer une connexion entre l’appareil et IoT Hub. L’appareil peut désormais envoyer et recevoir des messages de manière asynchrone vers et depuis un IoT Hub. Si le client est déjà ouvert, la méthode ne fait rien.

client.open(true);

Exemple de message de réception du SDK

HandleMessages : exemple d’application d’appareil incluse avec le kit de développement logiciel Microsoft Azure IoT pour Java, qui se connecte à votre hub IoT et reçoit des messages cloud à appareil.

Créer une application back-end

Cette section explique comment envoyer un message cloud-à-appareil à l’aide de la classe ServiceClient à partir du Kit de développement logiciel (SDK) Azure IoT pour Java. Une application back-end de solution se connecte à un hub IoT et les messages sont envoyés à IoT Hub encodés avec un appareil de destination. IoT Hub stocke les messages entrants dans sa file d’attente de messages et les messages sont remis de la file d’attente de messages IoT Hub à l’appareil cible.

Ajouter l’instruction de dépendance

Ajoutez la dépendance pour utiliser le package iothub-java-service-client dans votre application pour communiquer avec votre service IoT Hub :

<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.7.23</version>
</dependency>

Ajouter des instructions import

Ajoutez ces instructions importer pour utiliser le Kit de développement logiciel (SDK) Java Azure IoT et le gestionnaire d’exceptions.

import com.microsoft.azure.sdk.iot.service.*;
import java.io.IOException;
import java.net.URISyntaxException;

Se connecter au hub IoT

Vous pouvez connecter un service back-end à IoT Hub à l’aide des méthodes suivantes :

Stratégie d’accès partagé
Microsoft Entra

Important

Se connecter à l’aide d’une stratégie d’accès partagé

Définir le protocole de connexion

Utilisez IotHubServiceClientProtocol pour définir le protocole de couche application utilisé par le client de service pour communiquer avec un IoT Hub.

IotHubServiceClientProtocol accepte uniquement l’énumération AMQPS ou AMQPS_WS .

IotHubServiceClientProtocol protocol = IotHubServiceClientProtocol.AMQPS;

Créer l’objet ServiceClient

Créez l’objet ServiceClient , en fournissant la chaîne de connexion et le protocole Iot Hub.

String connectionString = "{yourhubconnectionstring}";
ServiceClient serviceClient (connectionString, protocol);

Ouvrir la connexion entre l’application et IoT Hub

ouvrir la connexion de l’expéditeur AMQP. Cette méthode crée la connexion entre l’application et IoT Hub.

serviceClient.open();

Se connecter à l’aide de Microsoft Entra

Pour obtenir une vue d’ensemble de l’authentification à l’aide du kit SDK Java, consultez Authentification Azure avec Java et Azure Identity.

Par souci de simplicité, cette section se concentre sur la description de l’authentification à l’aide d’une clé secrète client.

Configurer l’application Microsoft Entra

Clè secrète client
Certificat
Informations d’identification d’identité fédérée

Pour plus d’informations concernant la configuration d’une application Microsoft Entra, consultez Démarrage rapide : inscrire une application auprès de la plateforme d’identités Microsoft.

S’authentifier à l’aide de DefaultAzureCredential

Le moyen le plus simple d’utiliser Microsoft Entra pour authentifier une application back-end consiste à utiliser DefaultAzureCredential. Cependant, nous vous recommandons d’utiliser une autre méthode dans un environnement de production, y compris un TokenCredential spécifique ou un ChainedTokenCredential simplifié. Pour plus d’informations sur les avantages et les inconvénients de l’utilisation de DefaultAzureCredential, consultez Chaînes d’informations d’identification dans la bibliothèque de client Azure Identity pour Java.

DefaultAzureCredential prend en charge différents mécanismes d’authentification et détermine le type d’informations d’identification approprié en fonction de l’environnement dans lequel il s’exécute. Cette méthode tente d’utiliser plusieurs types d’informations d’identification dans un ordre jusqu’à ce qu’elle trouve des informations d’identification fonctionnelles.

Vous pouvez authentifier les informations d’identification de l’application Microsoft Entra en utilisant DefaultAzureCredentialBuilder. Enregistrez les paramètres de connexion tels que l’ID de locataire, l’ID client et les valeurs de la clé secrète client en tant que variables environnementales. Une fois TokenCredential créé, passez-le à ServiceClient ou à un autre générateur en tant que paramètre « credential ».

Dans cet exemple, DefaultAzureCredentialBuilder tente d’authentifier une connexion à partir de la liste décrite dans DefaultAzureCredential. Le résultat d’une authentification Microsoft Entra réussie est une information d’identification de jeton de sécurité passée à un constructeur tel que ServiceClient.

TokenCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();

S’authentifier en utilisant ClientSecretCredentialBuilder

Vous pouvez utiliser ClientSecretCredentialBuilder pour créer des informations d’identification à l’aide des informations de la clé secrète client. Si cette méthode réussit, elle retourne un TokenCredential qui peut être passé à ServiceClient ou à un autre générateur en tant que paramètre « credential ».

Dans cet exemple, les valeurs de l’ID de locataire, de l’ID client et de la clé secrète client d’inscription de l’application Microsoft Entra ont été ajoutés aux variables d’environnement. Ces variables d’environnement sont utilisées par ClientSecretCredentialBuilder pour générer les informations d’identification.

string clientSecretValue = System.getenv("AZURE_CLIENT_SECRET");
string clientID = System.getenv("AZURE_CLIENT_ID");
string tenantID = System.getenv("AZURE_TENANT_ID");

TokenCredential credential =
     new ClientSecretCredentialBuilder()
          .tenantId(tenantID)
          .clientId(clientID)
          .clientSecret(clientSecretValue)
          .build();

Autres classes d’authentification

Le kit SDK Java inclut également ces classes qui authentifient une application back-end auprès de Microsoft Entra :

Exemples de code

Pour obtenir des exemples fonctionnels d’authentification auprès du service Microsoft Entra, consultez Exemple d’authentification basée sur les rôles.

Ouvrir un récepteur de commentaires pour les commentaires de remise de messages

Vous pouvez utiliser un FeedbackReceiver pour recevoir des messages envoyés aux commentaires IoT Hub. Un FeedbackReceiver est un récepteur spécialisé dont la méthode Receive retourne un FeedbackBatch au lieu d’un Message.

Dans cet exemple, l’objet FeedbackReceiver est créé et l’instruction open() est appelée pour attendre des commentaires.

FeedbackReceiver feedbackReceiver = serviceClient
  .getFeedbackReceiver();
if (feedbackReceiver != null) feedbackReceiver.open();

Ajouter des propriétés de message

Vous pouvez éventuellement utiliser setProperties pour ajouter des propriétés de message. Ces propriétés sont incluses dans le message envoyé à l’appareil et peuvent être extraites par l’application de l’appareil dès réception.

Map<String, String> propertiesToSend = new HashMap<String, String>();
propertiesToSend.put(messagePropertyKey,messagePropertyKey);
messageToSend.setProperties(propertiesToSend);

Créer et envoyer un message asynchrone

L’objet Message stocke le message à envoyer. Dans cet exemple, un « message cloud à appareil » est remis.

Utilisez setDeliveryAcknowledgement pour demander un accusé de réception de la file d’attente de messages remis/non remis à IoT Hub. Dans cet exemple, l'accusé de réception demandé est Full, soit délivré, soit non délivré.

Utilisez SendAsync pour envoyer un message asynchrone du client au périphérique. Vous pouvez également utiliser la méthode Send (pas asynchrone), mais cette fonction est synchronisée en interne afin qu’une seule opération d’envoi soit autorisée à la fois. Le message est remis de l’application à IoT Hub. IoT Hub place le message dans la file d’attente de messages, prêt à être remis à l’appareil cible.

Message messageToSend = new Message("Cloud to device message.");
messageToSend.setDeliveryAcknowledgementFinal(DeliveryAcknowledgement.Full);
serviceClient.sendAsync(deviceId, messageToSend);

Recevoir des commentaires sur la remise des messages

Une fois qu’un message est envoyé à partir de l’application, l’application peut appeler recevoir avec ou sans valeur de délai d’expiration. Si aucune valeur de délai d’expiration n’est fournie, le délai d’expiration par défaut est utilisé. Cela renvoie un objet FeedbackBatch qui contient les propriétés de commentaires de remise des messages qui peuvent être examinées.

Cet exemple crée le récepteur FeedbackBatch et appelle getEnqueuedTimeUtc, imprimant l'heure de mise en file d'attente du message.

FeedbackBatch feedbackBatch = feedbackReceiver.receive(10000);
if (feedbackBatch != null) {
  System.out.println("Message feedback received, feedback time: "
    + feedbackBatch.getEnqueuedTimeUtc().toString());
}

Exemples de messages envoyés par le KIT SDK

Il existe deux exemples d’envoi de message :

Exemple de client de service - Exemple d'envoi de message, #1.
Exemple de client de service - Exemple d’envoi de message, #2.

Créer une application d’appareil

Cette section décrit comment recevoir des messages cloud-à-appareil.

La classe IoTHubDeviceClient inclut des méthodes permettant de créer une connexion synchrone d’un appareil à un Azure IoT Hub et de recevoir des messages d’IoT Hub.

La bibliothèque azure-iot-device doit être installée pour créer des applications d’appareil.

pip install azure-iot-device

Pour qu’une application d’appareil basée sur Python reçoive des messages cloud vers appareil, elle doit se connecter à IoT Hub, puis configurer un gestionnaire de messages de rappel pour traiter les messages entrants provenant d’IoT Hub.

Instruction d’importation d’appareil

Ajoutez ce code pour importer les fonctions IoTHubDeviceClient à partir du Kit de développement logiciel (SDK) azure.iot.device.

from azure.iot.device import IoTHubDeviceClient

Connecter un appareil à IoT Hub

Un appareil périphérique peut être authentifié auprès d’IoT Hub à l’aide des méthodes suivantes :

Clé d’accès partagé
Certificat X.509

Important

S’authentifier à l’aide d’une clé d’accès partagé

Pour connecter un appareil à IoT Hub :

Appelez create_from_connection_string pour ajouter la chaîne de connexion principale de l’appareil.
Appelez connect pour connecter le client d’appareil.

Par exemple :

# Add your IoT hub primary connection string
CONNECTION_STRING = "{Device primary connection string}"
device_client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)

# Connect the client
device_client.connect()

S’authentifier à l’aide d’un certificat X.509

Pour connecter un appareil à IoT Hub à l’aide d’un certificat X.509 :

Utilisez create_from_x509_certificate pour ajouter les paramètres de certificat X.509
Appelez connect pour connecter le client d’appareil

Cet exemple montre les valeurs des paramètres d’entrée du certificat en tant que variables locales pour plus de clarté. Dans un système de production, stockez des paramètres d’entrée sensibles dans des variables d’environnement ou un autre emplacement de stockage plus sécurisé. Par exemple, utilisez cette option os.getenv("HOSTNAME") pour lire la variable d’environnement du nom d’hôte.

# The Azure IoT hub name
hostname = "xxxxx.azure-devices.net"

# The device that has been created on the portal using X509 CA signing or self-signing capabilities
device_id = "MyDevice"

# The X.509 certificate file name
cert_file = "~/certificates/certs/sensor-thl-001-device.cert.pfx"
key_file = "~/certificates/certs/sensor-thl-001-device.cert.key"
# The optional certificate pass phrase
pass_phrase = "1234"

x509 = X509(
    cert_file,
    key_file,
    pass_phrase,
)

# The client object is used to interact with your Azure IoT hub.
device_client = IoTHubDeviceClient.create_from_x509_certificate(
    hostname=hostname, device_id=device_id, x509=x509
)

# Connect to IoT Hub
await device_client.connect()

Pour plus d’informations sur l’authentification par certificat, consultez :

Exemples de code

Pour obtenir des exemples de fonctionnement de l’authentification par certificat X.509 de l’appareil, consultez les exemples dont les noms de fichiers se terminent par x509 dans les scénarios de hub asynchrone.

Gérer la reconnexion

IoTHubDeviceClient tente par défaut de rétablir une connexion supprimée. Le comportement de reconnexion est régi par les paramètres IoTHubDeviceClient connection_retry et connection_retry_interval.

Créer un gestionnaire de messages

Créez une fonction de gestionnaire de messages pour traiter les messages entrants sur l’appareil. Cela sera attribué par on_message_received (étape suivante) en tant que gestionnaire de messages de rappel.

Dans cet exemple, message_handler est appelée lorsqu’un message est reçu. Les propriétés du message (.items) sont imprimées dans la console à l’aide d’une boucle.

def message_handler(message):
    global RECEIVED_MESSAGES
    RECEIVED_MESSAGES += 1
    print("")
    print("Message received:")

    # print data from both system and application (custom) properties
    for property in vars(message).items():
        print ("    {}".format(property))

    print("Total calls received: {}".format(RECEIVED_MESSAGES))

Affecter le gestionnaire de messages

Utilisez la méthode on_message_received pour affecter la méthode de gestionnaire de messages.

Dans cet exemple, une méthode de gestionnaire de messages nommée message_handler est attachée à l'objet IoTHubDeviceClient client. L’objet client attend de recevoir un message cloud-à-appareil provenant d’un IoT Hub. Ce code attend jusqu’à 300 secondes (5 minutes) pour un message ou se ferme si une touche de clavier est enfoncée.

try:
    # Attach the handler to the client
    client.on_message_received = message_handler

    while True:
        time.sleep(300)
except KeyboardInterrupt:
    print("IoT Hub C2D Messaging device sample stopped")
finally:
    # Graceful exit
    print("Shutting down IoT Hub Client")
    client.shutdown()

Exemple de message de réception du SDK

Recevoir un message - Recevez des messages Cloud-to-Device (C2D) envoyés depuis Azure IoT Hub vers un appareil.

Créer une application back-end

Cette section décrit comment envoyer un message cloud-à-appareil. Une application back-end de solution se connecte à un hub IoT et les messages sont envoyés à IoT Hub encodés avec un appareil de destination. IoT Hub stocke les messages entrants dans sa file d’attente de messages et les messages sont remis de la file d’attente de messages IoT Hub à l’appareil cible.

La classe IoTHubRegistryManager expose toutes les méthodes requises pour créer une application back-end afin d’interagir avec des messages cloud-à-appareil à partir du service. La bibliothèque azure-iot-hub doit être installée pour créer des applications de service back-end.

pip install azure-iot-hub

Importer l’objet IoTHubRegistryManager

Ajoutez l’instruction import suivante : IoTHubRegistryManager inclut des API pour les opérations IoT Hub Registry Manager.

from azure.iot.hub import IoTHubRegistryManager

Se connecter au hub IoT

Vous pouvez connecter un service back-end à IoT Hub à l’aide des méthodes suivantes :

Stratégie d’accès partagé
Microsoft Entra

Important

Se connecter à l’aide d’une stratégie d’accès partagé

Connectez-vous à IoT Hub à l’aide de fromConnectionString.

Par exemple :

IoTHubConnectionString = "{IoT hub service connection string}"
registry_manager = IoTHubRegistryManager.from_connection_string(IoTHubConnectionString)

Se connecter à l’aide de Microsoft Entra

Configurer l’application Microsoft Entra

Clè secrète client
Certificat
Informations d’identification d’identité fédérée

Pour plus d’informations concernant la configuration d’une application Microsoft Entra, consultez Démarrage rapide : inscrire une application auprès de la plateforme d’identités Microsoft.

S’authentifier à l’aide de DefaultAzureCredential

Microsoft Entra nécessite ces packages NuGet et les instructions using correspondantes :

Azure.Core
Azure.Identity

using Azure.Core;
using Azure.Identity;

string clientSecretValue = "xxxxxxxxxxxxxxx";
string clientID = "xxxxxxxxxxxxxx";
string tenantID = "xxxxxxxxxxxxx";

Environment.SetEnvironmentVariable("AZURE_CLIENT_SECRET", clientSecretValue);
Environment.SetEnvironmentVariable("AZURE_CLIENT_ID", clientID);
Environment.SetEnvironmentVariable("AZURE_TENANT_ID", tenantID);

TokenCredential tokenCredential = new DefaultAzureCredential();

Dans cet exemple, TokenCredential est passé à ServiceClient.Create pour créer un objet de connexion ServiceClient.

string hostname = "xxxxxxxxxx.azure-devices.net";
using var serviceClient = ServiceClient.Create(hostname, tokenCredential, TransportType.Amqp);

Dans cet exemple, TokenCredential est passé à RegistryManager.Create pour créer un objet RegistryManager.

string hostname = "xxxxxxxxxx.azure-devices.net";
registryManager = RegistryManager.Create(hostname, tokenCredential);

Exemple de code

Pour obtenir un exemple fonctionnel de l’authentification du service Microsoft Entra, consultez Exemple d’authentification basée sur les rôles.

Générer et envoyer un message

Utilisez send_c2d_message pour envoyer un message via le cloud (IoT Hub) à l’appareil.

send_c2d_message utilise ces paramètres :

deviceID : identificateur de chaîne de l’appareil cible.
message - Message cloud-à-appareil. Le message est de type str (chaîne).
properties - Collection facultative de propriétés de type dict. Les propriétés peuvent contenir des propriétés d’application et des propriétés système. La valeur par défaut est {}.

Cet exemple envoie un message de test à l’appareil cible.

# define the device ID
deviceID = "Device-1"

# define the message
message = "{\"c2d test message\"}"

# include optional properties
props={}
props.update(messageId = "message1")
props.update(prop1 = "test property-1")
props.update(prop1 = "test property-2")
prop_text = "Test message"
props.update(testProperty = prop_text)

# send the message through the cloud (IoT Hub) to the device
registry_manager.send_c2d_message(deviceID, message, properties=props)

Exemple de message d'envoi du SDK

Le kit SDK Azure IoT pour Python fournit un exemple fonctionnel d’application de service qui illustre comment envoyer un message cloud-à-appareil. Pour plus d’informations, consultez send_message.py, qui illustre comment envoyer un message cloud-à-appareil.

Créer une application d’appareil

Cette section décrit comment recevoir des messages cloud-à-appareil à l'aide du package azure-iot-device dans le SDK Azure IoT pour Node.js.

Pour qu’une application d’appareil basée sur Node.js reçoive des messages cloud-à-appareil, elle doit se connecter à IoT Hub, puis configurer un écouteur de rappel et un gestionnaire de messages pour traiter les messages entrants provenant d’IoT Hub. L’application d’appareil doit également être en mesure de détecter et de gérer les déconnexions si la connexion de message appareil-à-IoT Hub est interrompue.

Installer les packages du Kit de développement logiciel (SDK)

Le package azure-iot-device contient des objets qui s’interfacent avec les appareils IoT. Exécutez cette commande pour installer le SDK d’appareil azure-iot-device sur votre ordinateur de développement :

npm install azure-iot-device --save

Connecter un appareil à IoT Hub

Un appareil périphérique peut être authentifié auprès d’IoT Hub à l’aide des méthodes suivantes :

Certificat X.509
Clé d’accès partagé

Important

S’authentifier à l’aide d’un certificat X.509

Le certificat X.509 est attaché au transport de connexion appareil-à-IoT Hub.

Pour configurer une connexion appareil-à-IoT Hub à l’aide d’un certificat X.509 :

Appelez fromConnectionString pour ajouter la chaîne de connexion de l’appareil et le type de transport. Ajoutez x509=true à la chaîne de connexion de l’appareil pour indiquer qu’un certificat est ajouté à DeviceClientOptions. Par exemple : HostName=xxxxx.azure-devices.net;DeviceId=Device-1;SharedAccessKey=xxxxxxxxxxxxx;x509=true.
Configurez une variable JSON avec les détails du certificat et transmettez-la à DeviceClientOptions.
Appelez setOptions pour ajouter un certificat et une clé X.509 (et éventuellement, phrase secrète) au transport client.
Appelez Open pour ouvrir la connexion à partir de l’appareil vers IoT Hub.

Cet exemple montre des informations de configuration de certificat dans une variable JSON. La configuration options de certification est transmise à setOptionset la connexion est ouverte à l’aide de open.

var options = {
   cert: myX509Certificate,
   key: myX509Key,
   passphrase: passphrase,
   http: {
     receivePolicy: {
       interval: 10
     }
   }
 }
 client.setOptions(options, callback);
 client.open(connectCallback);

Pour plus d’informations sur l’authentification par certificat, consultez :

Exemple de code

Pour obtenir un exemple de fonctionnement de l’authentification de certificat X.509 de l’appareil, consultez l’exemple simple d’appareil X.509.

S’authentifier à l’aide d’une clé d’accès partagé

Choisir un protocole de transport

L’objet Client prend en charge ces protocoles :

Amqp
Http - Lors de l'utilisation de Http, l'instance Client vérifie rarement les messages provenant d'IoT Hub (au minimum toutes les 25 minutes).
Mqtt
MqttWs
AmqpWs

Installez les protocoles de transport nécessaires sur votre ordinateur de développement.

Par exemple, cette commande installe le protocole Amqp :

npm install azure-iot-device-amqp --save

Pour plus d’informations sur les différences de prise en charge entre MQTT, AMQP et HTTPS, consultez Conseils sur les communications cloud-à-appareil et Choisir un protocole de communication.

Cet exemple affecte le protocole AMQP à une variable Protocol. Cette variable de protocole est transmise à la méthode Client.fromConnectionString dans la Ajouter la chaîne de connexion section de cet article.

const Protocol = require('azure-iot-device-mqtt').Amqp;

Fonctionnalités d’achèvement, de rejet et d’abandon des messages

Les méthodes d’achèvement, de rejet et d’abandon des messages peuvent être utilisées en fonction du protocole choisi.

AMQP et HTTP

Les transports AMQP et HTTP peuvent terminer, rejeter ou abandonner un message :

Terminer : pour terminer un message, le service qui a envoyé le message cloud-à-appareil est averti que le message est reçu. IoT Hub supprime le message de la file d’attente de messages. La méthode prend la forme de client.complete(message, callback function).
Rejeter - Pour rejeter un message, le service qui a envoyé le message cloud-à-appareil est averti que le message n’est pas traité par l’appareil. IoT Hub supprime définitivement le message de la file d’attente de l’appareil. La méthode prend la forme de client.reject(message, callback function).
Abandonner - Pour abandonner un message, IoT Hub tente immédiatement de le renvoyer. IoT Hub conserve le message dans la file d’attente de l’appareil pour une consommation future. La méthode prend la forme de client.abandon(message, callback function).

MQTT

MQTT ne prend pas en charge les fonctions complètes, rejetées ou abandonnées du message. Au lieu de cela, MQTT accepte un message par défaut et le message est supprimé de la file d’attente de messages IoT Hub.

Tentatives de Redelivery

Créer un objet client

Créer un objet Client à l’aide du package installé.

Par exemple :

const Client = require('azure-iot-device').Client;

Créer un objet de protocole

Créez un objet Protocol à l’aide d’un package de transfert installé.

Cet exemple affecte le protocole AMQP :

const Protocol = require('azure-iot-device-amqp').Amqp;

Ajouter la chaîne de connexion d’appareil et le protocole de transfert

Appelez fromConnectionString pour fournir des paramètres de connexion d’appareil :

connStr : chaîne de connexion de l’appareil.
transportCtor : protocole de transport.

Cet exemple utilise le protocole de transfert Amqp :

const deviceConnectionString = "{IoT hub device connection string}"
const Protocol = require('azure-iot-device-mqtt').Amqp;
let client = Client.fromConnectionString(deviceConnectionString, Protocol);

Créer un gestionnaire de messages entrants

Le gestionnaire de messages est appelé pour chaque message entrant.

Une fois qu’un message a été reçu, si vous utilisez AMQP ou le transport HTTP, appelez la méthode client.complete pour informer IoT Hub que le message peut être supprimé de la file d’attente de messages.

Par exemple, ce gestionnaire de messages imprime l’ID de message et le corps du message dans la console, puis appelle client.complete pour informer IoT Hub qu’il a traité le message et qu’il peut être supprimé en toute sécurité de la file d’attente de l’appareil. L’appel à complete n’est pas obligatoire si vous utilisez le transport MQTT et que vous pouvez l’omettre. Un appel àcomplete est requis pour le transport AMQP ou HTTPS.

function messageHandler(msg) {
  console.log('Id: ' + msg.messageId + ' Body: ' + msg.data);
  client.complete(msg, printResultFor('completed'));
}

Créer un gestionnaire de déconnexion de connexion

Le gestionnaire de déconnexion est appelé lorsque la connexion est déconnectée. Un gestionnaire de déconnexion est utile pour implémenter le code de reconnexion.

Cet exemple intercepte et affiche le message d’erreur de déconnexion dans la console.

function disconnectHandler() {
  clearInterval(sendInterval);
  sendInterval = null;
  client.open().catch((err) => {
    console.error(err.message);
  });
}

Ajouter des écouteurs d’événements

Vous pouvez spécifier ces écouteurs d’événements à l’aide de la méthode .on.

Gestionnaire de connexions
Gestionnaire d’erreurs
Gestionnaire de déconnexion
Gestionnaire de messages

Cet exemple inclut le message et les gestionnaires de déconnexion définis précédemment.

client.on('connect', connectHandler);
client.on('error', errorHandler);
client.on('disconnect', disconnectHandler);
client.on('message', messageHandler);

Ouvrir la connexion à IoT Hub

Utilisez la méthode ouvrir pour ouvrir une connexion entre un appareil IoT et IoT Hub. Utilisez .catch(err) pour intercepter un code d’erreur et de gestionnaire d’appels.

Par exemple :

client.open()
.catch((err) => {
  console.error('Could not connect: ' + err.message);
});

Exemples d’appareils SDK

Le kit SDK Azure IoT pour Node.js fournit un exemple fonctionnel d’application de service qui gère les réceptions de messages. Pour plus d’informations, consultez l’article suivant :

simple_sample_device : application d’appareil qui se connecte à votre hub IoT et reçoit des messages cloud-à-appareil.

Créer une application back-end

Cette section décrit comment envoyer un message cloud-à-appareil. Comme indiqué précédemment, une application backend de solution se connecte à un IoT Hub et les messages sont envoyés à IoT Hub codés avec un appareil de destination. IoT Hub stocke les messages entrants dans sa file d’attente de messages et les messages sont remis de la file d’attente de messages IoT Hub à l’appareil cible.

Installer le package de Kit de développement logiciel (SDK) de service

Le package azure-iothub contient des objets qui s’interfacent avec IoT Hub. Cet article décrit Client code de classe qui envoie un message d’une application à un appareil via IoT Hub.

Exécutez cette commande pour installer azure-iothub sur votre machine de développement :

npm install azure-iothub --save

Charger les modules client et de message

Déclarez un objet Client à l’aide de la classe Client à partir du package azure-iothub.

Déclarez un objet Message à l’aide de la classe Message à partir du package azure-iot-common.

'use strict';
var Client = require('azure-iothub').Client;
var Message = require('azure-iot-common').Message;

Se connecter au hub IoT

Vous pouvez connecter un service back-end à IoT Hub à l’aide des méthodes suivantes :

Stratégie d’accès partagé
Microsoft Entra

Important

Se connecter à l’aide d’une stratégie d’accès partagé

Utilisez fromConnectionString pour vous connecter au hub IoT Hub.

Dans cet exemple, l’objet serviceClient est créé avec le type de transport Amqp.

var connectionString = '{IoT hub device connection string}';
var serviceClient = Client.fromConnectionString(connectionString,`Amqp`);

Ouvrir la connexion cliente

Appelez la méthode Client ouvrir pour ouvrir une connexion entre une application et IoT Hub.

open pouvez être appelée avec ou sans spécifier une fonction de rappel appelée lorsque l’opération de open est terminée.

Dans cet exemple, la méthode open inclut une fonction facultative err de rappel de connexion ouverte. Si une erreur ouverte se produit, un objet d’erreur est retourné. Si la connexion ouverte réussit, une valeur de rappel null est retournée.

serviceClient.open(function (err)
if (err)
  console.error('Could not connect: ' + err.message);

Se connecter à l’aide de Microsoft Entra

Pour obtenir une vue d’ensemble de l’authentification à l’aide du kit SDK Node.js, consultez :

Configurer l’application Microsoft Entra

Clè secrète client
Certificat
Informations d’identification d’identité fédérée

Pour plus d’informations concernant la configuration d’une application Microsoft Entra, consultez Démarrage rapide : inscrire une application auprès de la plateforme d’identités Microsoft.

S’authentifier à l’aide de DefaultAzureCredential

Le moyen le plus simple d’utiliser Microsoft Entra pour authentifier une application back-end consiste à utiliser DefaultAzureCredential. Cependant, nous vous recommandons d’utiliser une autre méthode dans un environnement de production, y compris un TokenCredential spécifique ou un ChainedTokenCredential simplifié. Par souci de simplicité, cette section décrit l’authentification à l’aide de DefaultAzureCredential et de la clé secrète client. Pour plus d’informations sur les avantages et les inconvénients de l’utilisation de DefaultAzureCredential, consultez Chaînes d’informations d’identification dans la bibliothèque de client Azure Identity pour JavaScript.

Microsoft Entra nécessite ce package :

npm install --save @azure/identity

Dans cet exemple, l’ID de locataire, l’ID client et la clé secrète client d’inscription de l’application Microsoft Entra ont été ajoutés aux variables d’environnement. Ces variables d’environnement sont utilisées par DefaultAzureCredential pour authentifier l’application. Le résultat d’une authentification Microsoft Entra réussie est une information d’identification de jeton de sécurité passée à une méthode de connexion IoT Hub.

import { DefaultAzureCredential } from "@azure/identity";

// Azure SDK clients accept the credential as a parameter
const credential = new DefaultAzureCredential();

Le jeton d’informations d’identification résultant peut ensuite être passé à fromTokenCredential pour se connecter à IoT Hub pour n’importe quel client du kit SDK qui accepte les informations d’identification Microsoft Entra :

fromTokenCredential nécessite deux paramètres :

URL du service Azure : l’URL du service Azure doit être au format {Your Entra domain URL}.azure-devices.net sans préfixe https://. Par exemple : MyAzureDomain.azure-devices.net.
Jeton d’informations d’identification Azure

Dans cet exemple, les informations d’identification Azure sont obtenues en utilisant DefaultAzureCredential. L’URL et les informations d’identification du domaine Azure sont ensuite fournies à Registry.fromTokenCredential pour créer la connexion à IoT Hub.

const { DefaultAzureCredential } = require("@azure/identity");

let Registry = require('azure-iothub').Registry;

// Define the client secret values
clientSecretValue = 'xxxxxxxxxxxxxxx'
clientID = 'xxxxxxxxxxxxxx'
tenantID = 'xxxxxxxxxxxxx'

// Set environment variables
process.env['AZURE_CLIENT_SECRET'] = clientSecretValue;
process.env['AZURE_CLIENT_ID'] = clientID;
process.env['AZURE_TENANT_ID'] = tenantID;

// Acquire a credential object
const credential = new DefaultAzureCredential()

// Create an instance of the IoTHub registry
hostName = 'MyAzureDomain.azure-devices.net';
let registry = Registry.fromTokenCredential(hostName,credential);

Exemples de code

Pour obtenir des exemples fonctionnels d’authentification auprès du service Microsoft Entra, consultez Exemples d’identité Azure.

Créer un message

L'objet message inclut le message asynchrone cloud-à-appareil. La fonctionnalité de message fonctionne de la même façon sur AMQP, MQTT et HTTP.

L’objet message prend en charge plusieurs propriétés, y compris ces propriétés. Consultez les propriétés message pour obtenir une liste complète.

ack - Commentaires de remise. Décrit dans la section suivante.
properties : carte contenant des clés de chaîne et des valeurs pour le stockage des propriétés de message personnalisées.
messageId : utilisé pour mettre en corrélation la communication bidirectionnelle.

Ajoutez le corps du message lorsque l’objet de message est instancié. Dans cet exemple, un message 'Cloud to device message.' est ajouté.

var message = new Message('Cloud to device message.');
message.ack = 'full';
message.messageId = "My Message ID";

Accusé de réception

Chaque message qui doit recevoir un retour de message doit inclure une valeur pour la propriété d'accusé de réception de livraison ack. La propriété ack peut être l’une des valeurs suivantes :

aucun (valeur par défaut) : aucun message de commentaires n’est généré.
sent: recevez un message de commentaires si le message a été terminé.
: recevez un message de commentaires si le message a expiré (ou le nombre maximal de remises a été atteint) sans être terminé par l’appareil.
full: commentaires pour les résultats envoyés et non envoyés.

Dans cet exemple, la propriété ack est définie sur full, demandant à la fois les commentaires envoyés et non envoyés pour un message.

message.ack = 'full';

Lier le récepteur de commentaires de message

La fonction de rappel du récepteur de commentaires de message est liée au Client à l’aide de getFeedbackReceiver.

Le récepteur de commentaires de message reçoit deux arguments :

Objet Error (peut être null)
Objet AmqpReceiver : émet des événements lorsque de nouveaux messages de commentaires sont reçus par le client.

Cet exemple de fonction reçoit et imprime un message de commentaires de remise dans la console.

function receiveFeedback(err, receiver){
  receiver.on('message', function (msg) {
    console.log('Feedback message:')
    console.log(msg.getData().toString('utf-8'));
  });
}

Ce code lie la fonction de rappel de commentaires receiveFeedback au service Client objet à l’aide de getFeedbackReceiver.

serviceClient.getFeedbackReceiver(receiveFeedback);

Définir un gestionnaire de résultats d’achèvement de message

La fonction de rappel d’envoi de message est appelée après l’envoi de chaque message.

Cet exemple de fonction imprime le message send résultats de l’opération dans la console. Dans cet exemple, la fonction printResultFor est fournie en tant que paramètre à la fonction send décrite dans la section suivante.

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

Envoyer un message

Utilisez la envoyer fonction pour envoyer un message cloud-à-appareil asynchrone à l’application d’appareil via IoT Hub.

send prend en charge ces paramètres :

deviceID : ID d’appareil de l’appareil cible.
message : corps du message à envoyer à l’appareil.
terminé : fonction facultative à appeler une fois l’opération terminée. Terminé est appelé avec deux arguments :
- Objet Error (peut être null).
- objet de réponse spécifique au transport utile pour la journalisation ou le débogage.

Ce code appelle send pour envoyer un message cloud-à-appareil à l’application d’appareil via IoT Hub. La fonction de rappel printResultFor définie dans la section précédente reçoit les informations d’accusé de réception.

var targetDevice = '{device ID}';
serviceClient.send(targetDevice, message, printResultFor('send'));

Cet exemple montre comment envoyer un message à votre appareil et gérer le message de commentaires lorsque l’appareil reconnaît le message cloud-à-appareil :

serviceClient.open(function (err) {
  if (err) {
    console.error('Could not connect: ' + err.message);
  } else {
    console.log('Service client connected');
    serviceClient.getFeedbackReceiver(receiveFeedback);
    var message = new Message('Cloud to device message.');
    message.ack = 'full';
    message.messageId = "My Message ID";
    console.log('Sending message: ' + message.getData());
    serviceClient.send(targetDevice, message, printResultFor('send'));
  }
});

Exemple de message d'envoi du SDK

Le kit SDK Azure IoT pour Node.js fournit des exemples fonctionnels d’une application de service qui gère les tâches d’envoi de message. Pour plus d’informations, consultez l’article suivant :

send_c2d_message.js - Envoyer des messages C2D à un appareil via IoT Hub.

Stratégie de reconnexion de connexion

Cet article ne présente pas de stratégie de nouvelle tentative de message pour la connexion de l’appareil à IoT Hub ou une application externe à la connexion IoT Hub. Dans le code de production, vous devez implémenter des stratégies de nouvelle tentative de connexion, comme décrit dans Gérer les reconnexions des appareils pour créer des applications résilientes.

Durée de rétention des messages, tentatives de nouvelle tentative et nombre maximal de remises

Comme décrit dans Envoyer des messages cloud-à-appareil à partir d’IoT Hub, vous pouvez afficher et configurer les valeurs par défaut pour les valeurs de message suivantes à l’aide des options de configuration IoT Hub du portail ou d’Azure CLI. Ces options de configuration peuvent affecter la remise et les commentaires des messages.

TTL par défaut (durée de vie) : durée pendant laquelle un message est disponible pour qu'un appareil puisse le consommer avant son expiration par IoT Hub.
Temps de rétention des commentaires : durée pendant laquelle IoT Hub conserve les commentaires pour l’expiration ou la remise de messages cloud-à-appareil.
Nombre de fois où IoT Hub tente de remettre un message cloud-à-appareil à un appareil.

Partager via

Envoyer et recevoir des messages cloud-à-appareil

Vue d’ensemble

Comprendre la file d'attente des messages

Créer une application d’appareil

Package NuGet d’appareil nécessaire

Connecter un appareil à IoT Hub

S’authentifier à l’aide d’une clé d’accès partagé

Fournir les paramètres de connexion

S’authentifier à l’aide d’un certificat X.509

Exemples de code

Rappel

Interrogation

Méthode CompleteAsync

Abandon, rejet ou délai d’expiration du message

Boucle d’interrogation

Recevoir une stratégie de nouvelle tentative de message

Exemple de message de réception du SDK

Créer une application back-end

Ajouter un package NuGet de service

Se connecter au hub IoT

Se connecter à l’aide d’une stratégie d’accès partagé

Fournir la chaîne de connexion

Se connecter à l’aide de Microsoft Entra

Configurer l’application Microsoft Entra

S’authentifier à l’aide de DefaultAzureCredential

Exemple de code

Envoyer un message cloud-à-appareil asynchrone

Réception des commentaires de remise

Créer l'objet feedbackReceiver

Envoyer des messages à l’aide du paramètre Ack

Attendez de recevoir des commentaires

Reconnexion du client de service

Envoyer une stratégie de nouvelle tentative de message

Exemple de message d'envoi du SDK

Créer une application d’appareil

Importer des bibliothèques du Kit de développement logiciel (SDK) Java Azure IoT

Connecter un appareil à IoT Hub

S’authentifier à l’aide d’une clé d’accès partagé

S’authentifier à l’aide d’un certificat X.509

Exemples de code

Définir la méthode de rappel de message

Créer un gestionnaire de rappel de message

Options d’abandon et de rejet des messages

Créer la méthode de rappel d’état du message

Ouvrir la connexion entre l’appareil et IoT Hub

Exemple de message de réception du SDK

Créer une application back-end

Ajouter l’instruction de dépendance

Ajouter des instructions import

Se connecter au hub IoT

Se connecter à l’aide d’une stratégie d’accès partagé

Définir le protocole de connexion

Créer l’objet ServiceClient

Ouvrir la connexion entre l’application et IoT Hub

Se connecter à l’aide de Microsoft Entra

Configurer l’application Microsoft Entra

S’authentifier à l’aide de DefaultAzureCredential

S’authentifier en utilisant ClientSecretCredentialBuilder

Autres classes d’authentification

Exemples de code

Ouvrir un récepteur de commentaires pour les commentaires de remise de messages

Ajouter des propriétés de message

Créer et envoyer un message asynchrone

Recevoir des commentaires sur la remise des messages

Exemples de messages envoyés par le KIT SDK

Créer une application d’appareil

Instruction d’importation d’appareil

Connecter un appareil à IoT Hub

S’authentifier à l’aide d’une clé d’accès partagé

S’authentifier à l’aide d’un certificat X.509

Exemples de code

Gérer la reconnexion

Créer un gestionnaire de messages

Affecter le gestionnaire de messages

Exemple de message de réception du SDK

Créer une application back-end

Importer l’objet IoTHubRegistryManager

Se connecter au hub IoT

Se connecter à l’aide d’une stratégie d’accès partagé