bibliothèque cliente Azure Event Hubs pour JavaScript - version 5.12.0

Azure Event Hubs est un service de publication-abonnement hautement évolutif qui peut ingérer des millions d’événements par seconde et les diffuser en continu vers plusieurs consommateurs. Cela vous permet de traiter et d’analyser les énormes quantités de données produites par vos appareils et applications connectés. Si vous souhaitez en savoir plus sur Azure Event Hubs, vous pouvez consulter : Qu’est-ce qu’Event Hubs ?

La bibliothèque cliente Azure Event Hubs vous permet d’envoyer et de recevoir des événements dans votre application Node.js.

Liens clés :

• Code source
• Package (npm)
• Documentation de référence de l’API
• Documentation du produit
• Exemples

REMARQUE : Si vous utilisez la version 2.1.0 ou une version ultérieure et que vous souhaitez migrer vers la dernière version de ce package, consultez notre guide de migration pour passer d’EventHubs V2 à EventHubs V5

Des exemples pour v2 et la documentation sont toujours disponibles ici :

Code source pour v2.1.0 | Package pour v2.1.0 (npm) | Exemples pour v2.1.0

Prise en main

Installer le package

Installer la bibliothèque cliente Azure Event Hubs à l’aide de npm

npm install @azure/event-hubs

Environnements actuellement pris en charge

• Versions LTS de Node.js
• Dernières versions de Safari, Chrome, Edge et Firefox.

Pour plus d’informations, consultez notre politique de support .

Prérequis

• Un abonnement Azure
• Espace de noms Event Hubs

Configurer TypeScript

Les utilisateurs TypeScript doivent avoir installé des définitions de type de nœud :

npm install @types/node

Vous devez également activer compilerOptions.allowSyntheticDefaultImports dans votre tsconfig.json. Notez que si vous avez activé compilerOptions.esModuleInterop, allowSyntheticDefaultImports est activé par défaut. Pour plus d’informations, consultez le manuel des options du compilateur de TypeScript .

Ensemble JavaScript

Pour utiliser cette bibliothèque cliente dans le navigateur, vous devez d’abord utiliser un bundler. Pour plus d’informations sur la façon de procéder, reportez-vous à notre documentation sur le regroupement.

En plus de ce qui est décrit ici, cette bibliothèque a également besoin de polyfills supplémentaires pour les modules intégrés principaux NodeJS suivants afin de fonctionner correctement dans les navigateurs :

• buffer
• os
• path
• process

Regroupement avec Webpack

Si vous utilisez Webpack v5, vous pouvez installer les dépendances de développement suivantes

• npm install --save-dev os-browserify path-browserify

ajoutez ensuite les éléments suivants à votre webpack.config.js

 const path = require("path");
+const webpack = require("webpack");

 module.exports = {
   entry: "./src/index.ts",
@@ -12,8 +13,21 @@ module.exports = {
       },
     ],
   },
+  plugins: [
+    new webpack.ProvidePlugin({
+      process: "process/browser",
+    }),
+    new webpack.ProvidePlugin({
+      Buffer: ["buffer", "Buffer"],
+    }),
+  ],
   resolve: {
     extensions: [".ts", ".js"],
+    fallback: {
+      buffer: require.resolve("buffer/"),
+      os: require.resolve("os-browserify"),
+      path: require.resolve("path-browserify"),
+    },
   },

Regroupement avec un cumul cumulatif

Si vous utilisez rollup bundler, installez les dépendances de développement suivantes

• npm install --save-dev @rollup/plugin-commonjs @rollup/plugin-inject @rollup/plugin-node-resolve

Incluez ensuite les éléments suivants dans votre rollup.config.js

+import nodeResolve from "@rollup/plugin-node-resolve";
+import cjs from "@rollup/plugin-commonjs";
+import shim from "rollup-plugin-shim";
+import inject from "@rollup/plugin-inject";

export default {
  // other configs
  plugins: [
+    shim({
+      fs: `export default {}`,
+      net: `export default {}`,
+      tls: `export default {}`,
+      path: `export default {}`,
+      dns: `export function resolve() { }`,
+    }),
+    nodeResolve({
+      mainFields: ["module", "browser"],
+      preferBuiltins: false,
+    }),
+    cjs(),
+    inject({
+      modules: {
+        Buffer: ["buffer", "Buffer"],
+        process: "process",
+      },
+      exclude: ["./**/package.json"],
+    }),
  ]
};

Consultez la documentation de votre bundler favori pour plus d’informations sur l’utilisation de polyfills.

Support React Native

Comme pour les navigateurs, React Native ne prend pas en charge certaines API JavaScript utilisées par cette bibliothèque sdk. Vous devez donc leur fournir des polyfills. Pour plus d’informations, consultez l’exemple Messaging React Native avec Expo.

Authentifier le client

L’interaction avec Event Hubs commence par un instance de la classe EventHubConsumerClient ou par un instance de la classe EventHubProducerClient. Il existe des surcharges de constructeur pour prendre en charge différentes façons d’instancier ces classes, comme indiqué ci-dessous :

Utiliser chaîne de connexion pour l’espace de noms Event Hubs

L’une des surcharges de constructeur prend une chaîne de connexion du formulaire Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key; et du nom d’entité à votre instance Event Hub. Vous pouvez créer un groupe de consommateurs et obtenir le chaîne de connexion ainsi que le nom d’entité à partir du Portail Azure.

const { EventHubProducerClient, EventHubConsumerClient } = require("@azure/event-hubs");

const producerClient = new EventHubProducerClient("my-connection-string", "my-event-hub");
const consumerClient = new EventHubConsumerClient(
  "my-consumer-group",
  "my-connection-string",
  "my-event-hub"
);

Utiliser chaîne de connexion pour la stratégie sur event Hub

Une autre surcharge de constructeur prend le chaîne de connexion correspondant à la stratégie d’accès partagé que vous avez définie directement sur le instance Event Hub (et non l’espace de noms Event Hubs). Cette chaîne de connexion se présente sous la forme Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name. La principale différence dans le format chaîne de connexion par rapport à la surcharge du constructeur précédent est .;EntityPath=my-event-hub-name

const { EventHubProducerClient, EventHubConsumerClient } = require("@azure/event-hubs");

const producerClient = new EventHubProducerClient("my-connection-string-with-entity-path");
const consumerClient = new EventHubConsumerClient(
  "my-consumer-group",
  "my-connection-string-with-entity-path"
);

Utiliser l’espace de noms Event Hubs et Azure Identity

Cette surcharge de constructeur prend le nom d’hôte et le nom d’entité de votre Event Hub instance et les informations d’identification qui implémentent l’interface TokenCredential. Cela vous permet de vous authentifier à l’aide d’un principal Azure Active Directory. Des implémentations de l’interface TokenCredential sont disponibles dans le package @azure/identité . Le nom d’hôte est au format <yournamespace>.servicebus.windows.net. Lorsque vous utilisez Azure Active Directory, un rôle qui autorise l’accès à Event Hubs doit être attribué à votre principal, tel que le rôle propriétaire des données Azure Event Hubs. Pour plus d’informations sur l’utilisation de l’autorisation Azure Active Directory avec Event Hubs, consultez la documentation associée.

const { EventHubProducerClient, EventHubConsumerClient } = require("@azure/event-hubs");

const { DefaultAzureCredential } = require("@azure/identity");
const credential = new DefaultAzureCredential();
const producerClient = new EventHubProducerClient("my-host-name", "my-event-hub", credential);
const consumerClient = new EventHubConsumerClient(
  "my-consumer-group",
  "my-host-name",
  "my-event-hub",
  credential
);

Concepts clés

• Un producteur Event Hub est une source de données de télémétrie, d’informations diagnostics, de journaux d’utilisation ou d’autres données de journal, dans le cadre d’une solution d’appareil incorporée, d’une application d’appareil mobile, d’un titre de jeu s’exécutant sur une console ou un autre appareil, d’une solution métier basée sur un client ou un serveur ou d’un site web.

• Un consommateur Event Hub récupère ces informations à partir d’Event Hub et les traite. agrégation, calcul et filtrage complexes, ou encore distribution ou stockage des informations brutes ou transformées. Les consommateurs Event Hub correspondent souvent à des composants d’infrastructure de plateforme robustes à grande échelle intégrant des fonctionnalités d’analytique, par exemple Azure Stream Analytics, Apache Spark ou Apache Storm.

• Une partition constitue une séquence ordonnée d’événements conservée dans un hub d’événements. Les partitions représentent un moyen d’organiser les données associé au parallélisme requis par les consommateurs d’événements. Azure Event Hubs assure la diffusion de messages suivant un modèle de consommateur partitionné dans lequel chaque consommateur ne lit qu’un sous-ensemble spécifique, ou partition, du flux de message. Les événements les plus récents sont ajoutés à la fin de cette séquence. Le nombre de partitions est spécifié lors de la création du hub d’événements. Il n’est pas modifiable.

• Un groupe de consommateurs constitue une vue de tout un hub d’événements. Les groupes de consommateurs permettent à plusieurs applications consommatrices de disposer chacune d’une vue distincte du flux d’événements, et de lire le flux séparément, à son propre rythme et à partir de sa propre position. Il peut y avoir au maximum cinq lecteurs simultanés sur une partition par groupe de consommateurs. Toutefois, il est recommandé de se limiter à un seul consommateur actif pour une association donnée entre une partition et un groupe de consommateurs. Chaque lecteur actif reçoit tous les événements de sa partition ; S’il y a plusieurs lecteurs sur la même partition, ils recevront des événements en double.

Pour plus de concepts et une discussion plus approfondie, consultez : Fonctionnalités Event Hubs

Conseils sur les nouvelles tentatives

et EventHubConsumerClientEventHubProducerClient acceptez options l’emplacement où vous pouvez définir qui retryOptions vous permet d’ajuster la façon dont le KIT de développement logiciel (SDK) gère les erreurs temporaires. Parmi les exemples d’erreurs temporaires, citons les problèmes de réseau ou de service temporaires.

Nouvelles tentatives lors de la consommation d’événements

Si une erreur temporaire (par exemple, un problème réseau temporaire) se produit pendant que le KIT de développement logiciel (SDK) reçoit des événements, il réessaye de recevoir les événements en fonction des options de nouvelle tentative passées dans le EventHubConsumerClient. Si le nombre maximal de nouvelles tentatives est épuisé, la processError fonction est appelée.

Vous pouvez utiliser les paramètres de nouvelle tentative pour contrôler la rapidité avec laquelle vous êtes informé des problèmes temporaires tels qu’un problème de connexion réseau. Par exemple, si vous avez besoin de savoir quand il y a un problème réseau immédiatement, vous pouvez réduire les valeurs pour maxRetries et retryDelayInMs.

Après avoir exécuté la processError fonction, le client continue de recevoir des événements de la partition tant que l’erreur était une nouvelle tentative. Sinon, le client appelle la fonction fournie par processClose l’utilisateur. Cette fonction est également appelée lorsque vous arrêtez l’abonnement ou lorsque le client cesse de lire les événements de la partition actuelle en raison de son enlèvement par un autre instance de votre application dans le cadre de l’équilibrage de charge.

La processClose fonction permet de mettre à jour les points de contrôle si nécessaire. Après avoir exécuté processClose, le client (ou, dans le cas de l’équilibrage de charge, un client d’une autre instance de votre application) appelle la fonction fournie par processInitialize l’utilisateur pour reprendre la lecture des événements du dernier point de contrôle mis à jour pour la même partition.

Si vous souhaitez arrêter toute tentative de lecture des événements, vous devez appeler close() sur le subscription retourné par la subscribe méthode .

Exemples

Les sections suivantes fournissent des extraits de code qui couvrent certaines des tâches courantes utilisant Azure Event Hubs

• Inspection d’un hub d’événements
• Publication d’événements sur un hub d’événements
• Utiliser des événements à partir d’un hub d’événements
• Utiliser EventHubConsumerClient pour utiliser IotHub

Inspection d’un hub d’événements

De nombreuses opérations liées aux hubs d’événements ont lieu dans l’étendue d’une partition spécifique. Étant donné que les partitions sont détenues par le hub d’événements, leurs noms sont assignés au moment de la création. Pour comprendre quelles partitions sont disponibles, vous interrogez event Hub à l’aide de l’un des deux clients disponibles : EventHubProducerClient ou EventHubConsumerClient

Dans l’exemple ci-dessous, nous utilisons un EventHubProducerClient.

const { EventHubProducerClient } = require("@azure/event-hubs");

async function main() {
  const client = new EventHubProducerClient("connectionString", "eventHubName");

  const partitionIds = await client.getPartitionIds();

  await client.close();
}

main();

Publication d’événements sur un hub d’événements

Pour publier des événements, vous devez créer un EventHubProducerClient. Bien que l’exemple ci-dessous montre une façon de créer le client, consultez la section Authentifier le client pour découvrir d’autres façons d’instancier le client.

Vous pouvez publier des événements sur une partition spécifique ou autoriser le service Event Hubs à décider sur quels événements de partition doivent être publiés. Il est recommandé d’utiliser le routage automatique lorsque la publication d’événements doit être hautement disponible ou lorsque les données d’événement doivent être distribuées uniformément entre les partitions. Dans l’exemple ci-dessous, nous allons tirer parti du routage automatique.

• Create un EventDataBatch objet à l’aide de createBatch
• Ajoutez des événements au lot à l’aide de la méthode tryAdd . Vous pouvez effectuer cette opération jusqu’à ce que la limite de taille maximale des lots soit atteinte ou jusqu’à ce que vous avez terminé d’ajouter le nombre d’événements que vous avez aimés, selon la première éventualité. Cette méthode revenirait false pour indiquer qu’aucun autre événement ne peut être ajouté au lot en raison de la taille maximale du lot atteinte.
• Envoyez le lot d’événements à l’aide de la méthode sendBatch .

Dans l’exemple ci-dessous, nous essayons d’envoyer 10 événements à Azure Event Hubs.

const { EventHubProducerClient } = require("@azure/event-hubs");

async function main() {
  const producerClient = new EventHubProducerClient("connectionString", "eventHubName");

  const eventDataBatch = await producerClient.createBatch();
  let numberOfEventsToSend = 10;

  while (numberOfEventsToSend > 0) {
    let wasAdded = eventDataBatch.tryAdd({ body: "my-event-body" });
    if (!wasAdded) {
      break;
    }
    numberOfEventsToSend--;
  }

  await producerClient.sendBatch(eventDataBatch);
  await producerClient.close();
}

main();

Il existe des options que vous pouvez passer à différentes étapes pour contrôler le processus d’envoi d’événements à Azure Event Hubs.

• Le EventHubProducerClient constructeur prend un paramètre facultatif de type EventHubClientOptions que vous pouvez utiliser pour spécifier des options telles que le nombre de nouvelles tentatives.
• La createBatch méthode prend un paramètre facultatif de type CreateBatchOptions que vous pouvez utiliser pour spécifier la taille maximale du lot pris en charge par le lot en cours de création.
• La sendBatch méthode prend un paramètre facultatif de type SendBatchOptions que vous pouvez utiliser pour spécifier abortSignal pour annuler l’opération en cours.
• Si vous souhaitez envoyer à une partition spécifique, une surcharge de la sendBatch méthode vous permet de passer l’ID de la partition à laquelle envoyer des événements. L’exemple Inspect an Event Hub ci-dessus montre comment extraire les ID de partitions disponibles.

Remarque : Lorsque vous utilisez Azure Stream Analytics, le corps de l’événement envoyé doit également être un objet JSON. Par exemple : body: { "message": "Hello World" }

Utiliser des événements à partir d’un hub d’événements

Pour utiliser des événements à partir d’un instance Event Hub, vous devez également savoir quel groupe de consommateurs vous souhaitez cibler. Une fois que vous le savez, vous êtes prêt à créer un EventHubConsumerClient. Bien que l’exemple ci-dessous montre une façon de créer le client, consultez la section Authentifier le client pour découvrir d’autres façons d’instancier le client.

La subscribe méthode sur le client présente des surcharges qui, combinées au constructeur, peuvent répondre à plusieurs façons de consommer les événements :

• Consommer des événements dans un processus unique
• Consommer des événements avec une charge équilibrée sur plusieurs processus
• Consommer des événements à partir d’une partition unique

La subscribe méthode prend un paramètre facultatif de type SubscriptionOptions que vous pouvez utiliser pour spécifier des options telles que maxBatchSize (nombre d’événements à attendre) et maxWaitTimeInSeconds (délai d’attente avant l’arrivée des événements maxBatchSize).

Consommer des événements dans un processus unique

Commencez par créer une instance du EventHubConsumerClient, puis appelez la subscribe() méthode dessus pour commencer à consommer des événements.

La subscribe méthode prend des rappels pour traiter les événements à mesure qu’ils sont reçus de Azure Event Hubs. Pour arrêter la réception d’événements, vous pouvez appeler close() sur l’objet retourné par la subscribe() méthode .

const { EventHubConsumerClient, earliestEventPosition } = require("@azure/event-hubs");

async function main() {
  const client = new EventHubConsumerClient(
    "my-consumer-group",
    "connectionString",
    "eventHubName"
  );

  // In this sample, we use the position of earliest available event to start from
  // Other common options to configure would be `maxBatchSize` and `maxWaitTimeInSeconds`
  const subscriptionOptions = {
    startPosition: earliestEventPosition
  };

  const subscription = client.subscribe(
    {
      processEvents: async (events, context) => {
        // event processing code goes here
      },
      processError: async (err, context) => {
        // error reporting/handling code here
      }
    },
    subscriptionOptions
  );

  // Wait for a few seconds to receive events before closing
  setTimeout(async () => {
    await subscription.close();
    await client.close();
    console.log(`Exiting sample`);
  }, 3 * 1000);
}

main();

Consommer des événements avec une charge équilibrée sur plusieurs processus

Azure Event Hubs est capable de gérer des millions d’événements par seconde. Pour mettre à l’échelle votre application de traitement, vous pouvez exécuter plusieurs instances de votre application et lui faire équilibrer la charge entre elles.

Commencez par créer une instance du à l’aide EventHubConsumerClient de l’une des surcharges de constructeur qui prennent un CheckpointStore, puis appelez la subscribe() méthode pour commencer à consommer des événements. Le magasin de points de contrôle permet aux abonnés au sein d’un groupe de consommateurs de coordonner le traitement entre plusieurs instances de votre application.

Dans cet exemple, nous allons utiliser le BlobCheckpointStore à partir du @azure/eventhubs-checkpointstore-blob package qui implémente la lecture/écriture requise dans un magasin durable à l’aide de Stockage Blob Azure.

La subscribe méthode prend des rappels pour traiter les événements à mesure qu’ils sont reçus de Azure Event Hubs. Pour arrêter la réception d’événements, vous pouvez appeler close() sur l’objet retourné par la subscribe() méthode .

const { EventHubConsumerClient } = require("@azure/event-hubs");
const { ContainerClient } = require("@azure/storage-blob");
const { BlobCheckpointStore } = require("@azure/eventhubs-checkpointstore-blob");

const storageAccountConnectionString = "storage-account-connection-string";
const containerName = "container-name";
const eventHubConnectionString = "eventhub-connection-string";
const consumerGroup = "my-consumer-group";
const eventHubName = "eventHubName";

async function main() {
  const blobContainerClient = new ContainerClient(storageAccountConnectionString, containerName);

  if (!(await blobContainerClient.exists())) {
    await blobContainerClient.create();
  }

  const checkpointStore = new BlobCheckpointStore(blobContainerClient);
  const consumerClient = new EventHubConsumerClient(
    consumerGroup,
    eventHubConnectionString,
    eventHubName,
    checkpointStore
  );

  const subscription = consumerClient.subscribe({
    processEvents: async (events, context) => {
      // event processing code goes here
      if (events.length === 0) {
        // If the wait time expires (configured via options in maxWaitTimeInSeconds) Event Hubs
        // will pass you an empty array.
        return;
      }

      // Checkpointing will allow your service to pick up from
      // where it left off when restarting.
      //
      // You'll want to balance how often you checkpoint with the
      // performance of your underlying checkpoint store.
      await context.updateCheckpoint(events[events.length - 1]);
    },
    processError: async (err, context) => {
      // handle any errors that occur during the course of
      // this subscription
      console.log(`Errors in subscription to partition ${context.partitionId}: ${err}`);
    }
  });

  // Wait for a few seconds to receive events before closing
  await new Promise((resolve) => setTimeout(resolve, 10 * 1000));

  await subscription.close();
  await consumerClient.close();
  console.log(`Exiting sample`);
}

main();

Pour en savoir plus, consultez Équilibrer la charge des partitions sur plusieurs instances de votre application .

Consommer des événements à partir d’une partition unique

Commencez par créer une instance du EventHubConsumerClient, puis appelez la subscribe() méthode dessus pour commencer à consommer des événements. Passez l’ID de la partition que vous souhaitez cibler à la subscribe() méthode à consommer uniquement à partir de cette partition.

Dans l’exemple ci-dessous, nous utilisons la première partition.

La subscribe méthode prend des rappels pour traiter les événements à mesure qu’ils sont reçus de Azure Event Hubs. Pour arrêter la réception d’événements, vous pouvez appeler close() sur l’objet retourné par la subscribe() méthode .

const { EventHubConsumerClient, earliestEventPosition } = require("@azure/event-hubs");

async function main() {
  const client = new EventHubConsumerClient(
    "my-consumer-group",
    "connectionString",
    "eventHubName"
  );
  const partitionIds = await client.getPartitionIds();

  // In this sample, we use the position of earliest available event to start from
  // Other common options to configure would be `maxBatchSize` and `maxWaitTimeInSeconds`
  const subscriptionOptions = {
    startPosition: earliestEventPosition
  };

  const subscription = client.subscribe(
    partitionIds[0],
    {
      processEvents: async (events, context) => {
        // event processing code goes here
      },
      processError: async (err, context) => {
        // error reporting/handling code here
      }
    },
    subscriptionOptions
  );

  // Wait for a few seconds to receive events before closing
  setTimeout(async () => {
    await subscription.close();
    await client.close();
    console.log(`Exiting sample`);
  }, 3 * 1000);
}

main();

Utiliser EventHubConsumerClient pour utiliser IotHub

Vous pouvez également utiliser EventHubConsumerClient pour utiliser IotHub. Cela est utile pour recevoir des données de télémétrie d’IotHub à partir de l’EventHub lié. Le chaîne de connexion associé n’aura pas de revendications d’envoi. Par conséquent, l’envoi d’événements n’est pas possible.

• Notez que la chaîne de connexion doit être destinée à un point de terminaison compatible avec Event Hub (par exemple, « Endpoint=sb ://my-iothub-namespace-[uid].servicebus.windows.net/ ; SharedAccessKeyName=my-SA-name ; SharedAccessKey=my-SA-key ; EntityPath=my-iot-hub-name")

const { EventHubConsumerClient } = require("@azure/event-hubs");

async function main() {
  const client = new EventHubConsumerClient(
    "my-consumer-group",
    "Endpoint=sb://my-iothub-namespace-[uid].servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-iot-hub-name"
  );
  await client.getEventHubProperties();
  // retrieve partitionIds from client.getEventHubProperties() or client.getPartitionIds()
  const partitionId = "0";
  await client.getPartitionProperties(partitionId);

  await client.close();
}

main();

Dépannage

Dépendances AMQP

La bibliothèque Event Hubs dépend de la bibliothèque rhea-promise pour la gestion des connexions, l’envoi et la réception d’événements via le protocole AMQP .

Journalisation

Vous pouvez définir la variable d’environnement AZURE_LOG_LEVEL pour activer la journalisation sur stderr:

export AZURE_LOG_LEVEL=verbose

Pour obtenir des instructions plus détaillées sur l’activation des journaux, consultez les documents relatifs au package @azure/logger.

Vous pouvez également définir la variable d’environnement DEBUG pour obtenir les journaux lors de l’utilisation de cette bibliothèque. Cela peut être utile si vous souhaitez également émettre des journaux à partir des dépendances rhea-promise et rhea .

Note: AZURE_LOG_LEVEL, s’il est défini, est prioritaire sur DEBUG. Ne spécifiez pas azure de bibliothèques via DEBUG lorsque vous spécifiez également AZURE_LOG_LEVEL ou appelez setLogLevel.

• Obtention uniquement des journaux de débogage au niveau des informations à partir du Kit de développement logiciel (SDK) Event Hubs.

export DEBUG=azure:*:info

• Obtention des journaux de débogage à partir du Kit de développement logiciel (SDK) Event Hubs et de la bibliothèque au niveau du protocole.

export DEBUG=azure*,rhea*

• Si vous n’êtes pas intéressé par l’affichage des données d’événement brutes (qui consomme une grande quantité d’espace console/disque), vous pouvez définir la variable d’environnement DEBUG comme suit :

export DEBUG=azure*,rhea*,-rhea:raw,-rhea:message

• Si vous vous intéressez uniquement aux erreurs et aux avertissements du Kit de développement logiciel (SDK), vous pouvez définir la variable d’environnement DEBUG comme suit :

export DEBUG=azure:*:(error|warning),rhea-promise:error,rhea:events,rhea:frames,rhea:io,rhea:flow

Étapes suivantes

Autres exemples de code

Consultez le répertoire d’exemples pour obtenir des exemples détaillés sur l’utilisation de cette bibliothèque pour envoyer et recevoir des événements vers/à partir d’Event Hubs.

Contribution

Si vous souhaitez contribuer à cette bibliothèque, lisez le guide de contribution pour en savoir plus sur la génération et le test du code.