Azure Event Hubs clientbibliotheek voor JavaScript - versie 5.12.0

Azure Event Hubs is een uiterst schaalbare service voor publiceren/abonneren waarmee miljoenen gebeurtenissen per seconde kunnen worden opgenomen en naar meerdere consumenten kunnen worden gestreamd. Hiermee kunt u de enorme hoeveelheden gegevens die door uw verbonden apparaten en toepassingen worden geproduceerd, verwerken en analyseren. Als u meer wilt weten over Azure Event Hubs, kunt u het volgende lezen: Wat is Event Hubs?

Met de Azure Event Hubs-clientbibliotheek kunt u gebeurtenissen verzenden en ontvangen in uw Node.js-toepassing.

Belangrijke koppelingen:

• Broncode
• Package (npm)
• API-referentiedocumentatie
• Productdocumentatie
• Voorbeelden

OPMERKING: Als u versie 2.1.0 of lager gebruikt en wilt migreren naar de nieuwste versie van dit pakket, raadpleegt u onze migratiehandleiding om over te stappen van EventHubs V2 naar EventHubs V5

Voorbeelden voor v2 en documentatie zijn hier nog steeds beschikbaar:

Broncode voor v2.1.0 | Pakket voor v2.1.0 (npm) | Voorbeelden voor v2.1.0

Aan de slag

Het pakket installeren

De Azure Event Hubs-clientbibliotheek installeren met npm

npm install @azure/event-hubs

Momenteel ondersteunde omgevingen

• LTS-versies van Node.js
• Nieuwste versies van Safari, Chrome, Edge en Firefox.

Zie ons ondersteuningsbeleid voor meer informatie.

Vereisten

• Een Azure-abonnement
• Een Event Hubs-naamruimte

TypeScript configureren

TypeScript-gebruikers moeten knooppunttypedefinities hebben geïnstalleerd:

npm install @types/node

U moet ook inschakelen compilerOptions.allowSyntheticDefaultImports in uw tsconfig.json. Houd er rekening mee dat als u hebt ingeschakeld compilerOptions.esModuleInterop, allowSyntheticDefaultImports standaard is ingeschakeld. Zie het handboek voor compileropties van TypeScript voor meer informatie.

JavaScript-bundel

Als u deze clientbibliotheek in de browser wilt gebruiken, moet u eerst een bundler gebruiken. Raadpleeg onze bundeldocumentatie voor meer informatie over hoe u dit doet.

Naast wat daar wordt beschreven, heeft deze bibliotheek ook aanvullende polyfills nodig voor de volgende ingebouwde NodeJS-kernmodules om goed te kunnen werken in de browsers:

• buffer
• os
• path
• process

Bundelen met Webpack

Als u Webpack v5 gebruikt, kunt u de volgende dev-afhankelijkheden installeren

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

voeg vervolgens het volgende toe aan uw 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"),
+    },
   },

Bundelen met rollup

Als u rollup bundler gebruikt, installeert u de volgende dev-afhankelijkheden

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

Neem vervolgens het volgende op in uw 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"],
+    }),
  ]
};

Raadpleeg de documentatie van uw favoriete bundelaar voor meer informatie over het gebruik van polyfills.

React Native-ondersteuning

Net als bij browsers biedt React Native geen ondersteuning voor bepaalde JavaScript-API's die door deze SDK-bibliotheek worden gebruikt, dus u moet polyfills voor deze api's opgeven. Zie het Voorbeeld van berichten React Native met Expo voor meer informatie.

De client verifiëren

Interactie met Event Hubs begint met een exemplaar van de klasse EventHubConsumerClient of een exemplaar van de klasse EventHubProducerClient . Er zijn constructoroverbelastingen ter ondersteuning van verschillende manieren om deze klassen te instantiëren, zoals hieronder wordt weergegeven:

Gebruik verbindingsreeks voor de Event Hubs-naamruimte

Een van de constructoroverbelastingen neemt een verbindingsreeks van de formulierEndpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;- en entiteitsnaam naar uw Event Hub-exemplaar. U kunt een consumentengroep maken en de verbindingsreeks en de naam van de entiteit ophalen uit de Azure Portal.

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

Gebruik verbindingsreeks voor beleid op de Event Hub

Een andere constructoroverbelasting neemt de verbindingsreeks die overeenkomt met het beleid voor gedeelde toegang dat u rechtstreeks hebt gedefinieerd op het Event Hub-exemplaar (en niet op de Event Hubs-naamruimte). Deze verbindingsreeks heeft de vorm Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name. Het belangrijkste verschil in de verbindingsreeks-indeling van de vorige overbelasting van de constructor is de ;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"
);

De Event Hubs-naamruimte en Azure Identity gebruiken

Deze overbelasting van de constructor neemt de hostnaam en entiteitsnaam van uw Event Hub-exemplaar en de referentie waarmee de TokenCredential-interface wordt geïmplementeerd. Hiermee kunt u zich verifiëren met behulp van een Azure Active Directory-principal. Er zijn implementaties van de TokenCredential interface beschikbaar in het pakket @azure/identity . De hostnaam heeft de indeling <yournamespace>.servicebus.windows.net. Wanneer u Azure Active Directory gebruikt, moet aan uw principal een rol worden toegewezen die toegang tot Event Hubs toestaat, zoals de rol Azure Event Hubs Gegevenseigenaar. Raadpleeg de bijbehorende documentatie voor meer informatie over het gebruik van Azure Active Directory-autorisatie met Event Hubs.

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

Belangrijkste concepten

• Een Event Hub-producent is een bron van telemetriegegevens, diagnostische gegevens, gebruikslogboeken of andere logboekgegevens, als onderdeel van een ingesloten apparaatoplossing, een toepassing voor een mobiel apparaat, een gametitel die wordt uitgevoerd op een console of ander apparaat, een zakelijke oplossing op basis van een client of server of een website.

• Een Event Hub-consument haalt dergelijke informatie op uit de Event Hub en verwerkt deze. Verwerking kan bestaan uit aggregatie, complexe berekeningen en filteren. Verwerking kan ook betrekking hebben op distributie of opslag van de informatie op onbewerkte of getransformeerde wijze. Event Hub-gebruikers zijn vaak robuuste en grootschalige platforminfrastructuuronderdelen met ingebouwde analysemogelijkheden, zoals Azure Stream Analytics, Apache Spark of Apache Storm.

• Een partitie is een geordende reeks gebeurtenissen die wordt gehouden in een Event Hub. Partities zijn een methode voor gegevensorganisatie die is gekoppeld aan de parallelle uitvoering die is vereist door gebeurtenisgebruikers. Azure Event Hubs biedt berichtstreaming via een gepartitioneerd consumentenpatroon waarbij elke consument alleen een specifieke subset of partitie van de berichtenstroom leest. Als er nieuwere gebeurtenissen plaatsvinden, worden deze toegevoegd aan het einde van deze reeks. Het aantal partities wordt opgegeven op het moment dat een Event Hub wordt gemaakt en kan niet worden gewijzigd.

• Een consumentengroep is een weergave van een hele Event Hub. Met consumentengroepen kunnen meerdere verbruikende toepassingen elk een afzonderlijke weergave van de gebeurtenisstroom hebben en de stream onafhankelijk in hun eigen tempo en vanuit hun eigen positie lezen. Er kunnen maximaal 5 gelijktijdige lezers op een partitie per consumentengroep zijn; Het wordt echter aanbevolen dat er slechts één actieve consument is voor een bepaalde koppeling tussen partities en consumentengroepen. Elke actieve lezer ontvangt alle gebeurtenissen van zijn partitie; Als er meerdere lezers op dezelfde partitie zijn, ontvangen ze dubbele gebeurtenissen.

Zie Voor meer concepten en diepere discussie: Event Hubs-functies

Richtlijnen voor nieuwe pogingen

De EventHubConsumerClient en EventHubProducerClient accepteren options waar u de retryOptions kunt instellen, zodat u kunt afstemmen hoe de SDK tijdelijke fouten verwerkt. Voorbeelden van tijdelijke fouten zijn tijdelijke netwerk- of serviceproblemen.

Nieuwe pogingen bij het verbruik van gebeurtenissen

Als er een tijdelijke fout (bijvoorbeeld een tijdelijk netwerkprobleem) optreedt terwijl de SDK gebeurtenissen ontvangt, wordt opnieuw geprobeerd om gebeurtenissen te ontvangen op basis van de opties voor opnieuw proberen die zijn doorgegeven aan de EventHubConsumerClient. Als het maximum aantal nieuwe pogingen is uitgeput, wordt de processError functie aangeroepen.

U kunt de instellingen voor opnieuw proberen gebruiken om te bepalen hoe snel u wordt geïnformeerd over tijdelijke problemen, zoals een probleem met een netwerkverbinding. Als u bijvoorbeeld meteen wilt weten wanneer er een netwerkprobleem is, kunt u de waarden voor maxRetries en retryDelayInMsverlagen.

Nadat de processError functie is uitgevoerd, blijft de client gebeurtenissen van de partitie ontvangen zolang de fout een nieuwe poging is. Anders roept de client de door de gebruiker opgegeven functie aan processClose . Deze functie wordt ook aangeroepen wanneer u het abonnement stopt of wanneer de client stopt met het lezen van gebeurtenissen van de huidige partitie omdat deze wordt opgehaald door een ander exemplaar van uw toepassing als onderdeel van taakverdeling.

De processClose functie biedt de mogelijkheid om controlepunten bij te werken, indien nodig. Na het uitvoeren processClosevan roept de client (of in het geval van taakverdeling, een client van een ander exemplaar van uw toepassing) de door de gebruiker opgegeven processInitialize functie aan om leesgebeurtenissen van het laatst bijgewerkte controlepunt voor dezelfde partitie te hervatten.

Als u wilt stoppen met het lezen van gebeurtenissen, moet u de subscription aanroepen close() die door de subscribe methode worden geretourneerd.

Voorbeelden

De volgende secties bevatten codefragmenten die betrekking hebben op enkele veelvoorkomende taken met Azure Event Hubs

• Een Event Hub inspecteren
• Gebeurtenissen publiceren naar een Event Hub
• Gebeurtenissen van een Event Hub gebruiken
• EventHubConsumerClient gebruiken om te werken met IotHub

Een Event Hub inspecteren

Veel Event Hub-bewerkingen vinden plaats binnen het bereik van een specifieke partitie. Omdat partities eigendom zijn van de Event Hub, worden hun namen toegewezen op het moment van maken. Als u wilt weten welke partities beschikbaar zijn, voert u een query uit op de Event Hub met behulp van een van de twee beschikbare clients: EventHubProducerClient of EventHubConsumerClient

In het onderstaande voorbeeld gebruiken we een 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();

Gebeurtenissen publiceren naar een Event Hub

Als u gebeurtenissen wilt publiceren, moet u een EventHubProducerClientmaken. Hoewel in het onderstaande voorbeeld één manier wordt getoond om de client te maken, raadpleegt u de sectie De client verifiëren voor meer informatie over andere manieren om de client te instantiëren.

U kunt gebeurtenissen publiceren naar een specifieke partitie of de Event Hubs-service toestaan om te bepalen naar welke partitie-gebeurtenissen moeten worden gepubliceerd. Het wordt aanbevolen om automatische routering te gebruiken wanneer de publicatie van gebeurtenissen maximaal beschikbaar moet zijn of wanneer gebeurtenisgegevens gelijkmatig over de partities moeten worden verdeeld. In het onderstaande voorbeeld profiteren we van automatische routering.

• EventDataBatch een object Creatie met behulp van de createBatch
• Voeg gebeurtenissen toe aan de batch met behulp van de methode tryAdd . U kunt dit doen totdat de maximale batchgroottelimiet is bereikt of totdat u klaar bent met het toevoegen van het aantal gebeurtenissen dat u leuk vindt, afhankelijk van wat zich het eerst voordoet. Deze methode retourneert false om aan te geven dat er geen gebeurtenissen meer kunnen worden toegevoegd aan de batch omdat de maximale batchgrootte is bereikt.
• Verzend de batch met gebeurtenissen met behulp van de sendBatch-methode .

In het onderstaande voorbeeld proberen we 10 gebeurtenissen naar Azure Event Hubs te verzenden.

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

Er zijn opties die u in verschillende fasen kunt doorgeven om het proces van het verzenden van gebeurtenissen naar Azure Event Hubs te beheren.

• De EventHubProducerClient constructor gebruikt een optionele parameter van het type EventHubClientOptions die u kunt gebruiken om opties op te geven, zoals het aantal nieuwe pogingen.
• De createBatch methode gebruikt een optionele parameter van het type CreateBatchOptions die u kunt gebruiken om de maximale batchgrootte te bepalen die wordt ondersteund door de batch die wordt gemaakt.
• De sendBatch methode gebruikt een optionele parameter van het type SendBatchOptions die u kunt gebruiken om op te geven abortSignal om de huidige bewerking te annuleren.
• Als u naar een specifieke partitie wilt verzenden, kunt u met een overbelasting van de sendBatch methode de id doorgeven van de partitie waarnaar gebeurtenissen moeten worden verzonden. In het bovenstaande voorbeeld Een Event Hub inspecteren ziet u hoe u de beschikbare partitie-id's ophaalt.

Opmerking: wanneer u met Azure Stream Analytics werkt, moet de hoofdtekst van de gebeurtenis die wordt verzonden ook een JSON-object zijn. Bijvoorbeeld: body: { "message": "Hello World" }

Gebeurtenissen van een Event Hub gebruiken

Als u gebeurtenissen van een Event Hub-exemplaar wilt gebruiken, moet u ook weten op welke consumentengroep u zich wilt richten. Zodra u dit weet, bent u klaar om een EventHubConsumerClient te maken. Hoewel in het onderstaande voorbeeld één manier wordt getoond om de client te maken, raadpleegt u de sectie De client verifiëren voor meer informatie over andere manieren om de client te instantiëren.

De subscribe methode op de client heeft overbelastingen die, in combinatie met de constructor, geschikt kunnen zijn voor verschillende manieren om gebeurtenissen te gebruiken:

• Gebeurtenissen in één proces gebruiken
• Gebeurtenissen gebruiken met taakverdeling over meerdere processen
• Gebeurtenissen van één partitie gebruiken

De subscribe methode gebruikt een optionele parameter van het type SubscriptionOptions die u kunt gebruiken om opties op te geven, zoals maxBatchSize (aantal gebeurtenissen waarop moet worden gewacht) en maxWaitTimeInSeconds (hoeveelheid tijd die moet worden gewacht tot maxBatchSize-gebeurtenissen binnenkomen).

Gebeurtenissen in één proces gebruiken

Begin met het maken van een exemplaar van de EventHubConsumerClienten roep vervolgens de subscribe() methode aan om gebeurtenissen te gaan gebruiken.

De subscribe methode gebruikt callbacks om gebeurtenissen te verwerken wanneer ze van Azure Event Hubs worden ontvangen. Als u wilt stoppen met het ontvangen van gebeurtenissen, kunt u het object aanroepen close() dat door de subscribe() methode wordt geretourneerd.

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

Gebeurtenissen gebruiken met taakverdeling over meerdere processen

Azure Event Hubs kan miljoenen gebeurtenissen per seconde verwerken. Als u de verwerkingstoepassing wilt schalen, kunt u meerdere exemplaren van uw toepassing uitvoeren en de belasting onderling verdelen.

Begin met het maken van een exemplaar van de EventHubConsumerClient met behulp van een van de constructor-overloads die een CheckpointStorenemen en roep vervolgens de subscribe() methode aan om gebeurtenissen te gaan gebruiken. Met het controlepuntarchief kunnen de abonnees binnen een consumentengroep de verwerking tussen meerdere exemplaren van uw toepassing coördineren.

In dit voorbeeld gebruiken we de BlobCheckpointStore uit het @azure/eventhubs-checkpointstore-blob pakket waarmee de vereiste lees-/schrijfbewerkingen naar een duurzaam archief worden geïmplementeerd met behulp van Azure Blob Storage.

De subscribe methode gebruikt callbacks om gebeurtenissen te verwerken wanneer ze van Azure Event Hubs worden ontvangen. Als u wilt stoppen met het ontvangen van gebeurtenissen, kunt u het object aanroepen close() dat door de subscribe() methode wordt geretourneerd.

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

Zie Partitiebelasting verdelen over meerdere exemplaren van uw toepassing voor meer informatie.

Gebeurtenissen van één partitie gebruiken

Begin met het maken van een exemplaar van de EventHubConsumerClienten roep vervolgens de subscribe() methode aan om gebeurtenissen te gaan gebruiken. Geef de id van de partitie die u wilt targeten door aan de subscribe() methode om alleen van die partitie te gebruiken.

In het onderstaande voorbeeld gebruiken we de eerste partitie.

De subscribe methode gebruikt callbacks om gebeurtenissen te verwerken wanneer ze van Azure Event Hubs worden ontvangen. Als u wilt stoppen met het ontvangen van gebeurtenissen, kunt u het object aanroepen close() dat door de subscribe() methode wordt geretourneerd.

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

EventHubConsumerClient gebruiken om te werken met IotHub

U kunt ook gebruiken EventHubConsumerClient om met IotHub te werken. Dit is handig voor het ontvangen van telemetriegegevens van IotHub van de gekoppelde EventHub. De gekoppelde verbindingsreeks heeft geen verzendclaims, waardoor het verzenden van gebeurtenissen niet mogelijk is.

• Houd er rekening mee dat de verbindingsreeks moet zijn voor een event hub-compatibel eindpunt (bijvoorbeeld '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();

Problemen oplossen

AMQP-afhankelijkheden

De Event Hubs-bibliotheek is afhankelijk van de rhea-promise-bibliotheek voor het beheren van verbindingen, het verzenden en ontvangen van gebeurtenissen via het AMQP-protocol .

Logboekregistratie

U kunt de omgevingsvariabele AZURE_LOG_LEVEL instellen om logboekregistratie in te schakelen op stderr:

export AZURE_LOG_LEVEL=verbose

Voor meer gedetailleerde instructies over het inschakelen van logboeken kunt u de @azure-/loggerpakketdocumenten bekijken.

U kunt ook de DEBUG omgevingsvariabele instellen om logboeken op te halen wanneer u deze bibliotheek gebruikt. Dit kan handig zijn als u ook logboeken van de afhankelijkheden rhea-promiserhea en wilt verzenden.

Opmerking: AZURE_LOG_LEVEL heeft, indien ingesteld, voorrang op FOUTOPSPORING. Geef geen azure bibliotheken op via FOUTOPSPORING wanneer u ook AZURE_LOG_LEVEL opgeeft of setLogLevel aanroept.

• Alleen foutopsporingslogboeken op informatieniveau ophalen uit de Event Hubs SDK.

export DEBUG=azure:*:info

• Logboeken voor foutopsporing ophalen van de Event Hubs SDK en de bibliotheek op protocolniveau.

export DEBUG=azure*,rhea*

• Als u niet geïnteresseerd bent in het weergeven van de onbewerkte gebeurtenisgegevens (die een grote hoeveelheid console-/schijfruimte verbruiken), kunt u de DEBUG omgevingsvariabele als volgt instellen:

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

• Als u alleen geïnteresseerd bent in fouten en SDK-waarschuwingen, kunt u de DEBUGomgevingsvariabele als volgt instellen:

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

Volgende stappen

Meer voorbeeldcode

Bekijk de map met voorbeelden voor gedetailleerde voorbeelden van het gebruik van deze bibliotheek voor het verzenden en ontvangen van gebeurtenissen naar/van Event Hubs.

Bijdragen

Als u een bijdrage wilt leveren aan deze bibliotheek, leest u de handleiding voor bijdragen voor meer informatie over het bouwen en testen van de code.