Azure Event Hubs Clientbibliothek für JavaScript – Version 5.12.0

Azure Event Hubs ist ein hochgradig skalierbarer Publish-Subscribe-Dienst, der Millionen von Ereignissen pro Sekunde erfassen und an mehrere Verbraucher streamen kann. Auf diese Weise können Sie die enormen Datenmengen verarbeiten und analysieren, die von Ihren verbundenen Geräten und Anwendungen erzeugt werden. Wenn Sie mehr über Azure Event Hubs erfahren möchten, sollten Sie folgendes lesen: Was ist Event Hubs?

Mit der Azure Event Hubs Clientbibliothek können Sie Ereignisse in Ihrer Node.js-Anwendung senden und empfangen.

Wichtige Links:

• Quellcode
• Paket (npm)
• API-Referenzdokumentation
• Produktdokumentation
• Beispiele

HINWEIS: Wenn Sie Version 2.1.0 oder niedriger verwenden und zur neuesten Version dieses Pakets migrieren möchten, sehen Sie sich unseren Migrationsleitfaden an, um von EventHubs V2 zu EventHubs V5 zu wechseln.

Beispiele für v2 und Dokumentation sind hier noch verfügbar:

Quellcode für v2.1.0 | Paket für v2.1.0 (npm) | Beispiele für v2.1.0

Erste Schritte

Installieren des Pakets

Installieren der Azure Event Hubs-Clientbibliothek mithilfe von npm

npm install @azure/event-hubs

Die derzeitig unterstützten Umgebungen

• LTS-Versionen von Node.js
• Neueste Versionen von Safari, Chrome, Edge und Firefox.

Ausführlichere Informationen finden Sie in der Supportrichtlinie.

Voraussetzungen

• Ein Azure-Abonnement
• Ein Event Hubs-Namespace

Konfigurieren von TypeScript

TypeScript-Benutzer müssen Knotentypdefinitionen installiert haben:

npm install @types/node

Sie müssen auch in Ihrem tsconfig.json aktivieren compilerOptions.allowSyntheticDefaultImports . Beachten Sie, dass , allowSyntheticDefaultImports wenn Sie aktiviert compilerOptions.esModuleInterophaben, standardmäßig aktiviert ist. Weitere Informationen finden Sie im Handbuch für Compileroptionen von TypeScript .

JavaScript-Bundle

Um diese Clientbibliothek im Browser zu verwenden, müssen Sie zunächst einen Bundler verwenden. Ausführliche Informationen dazu finden Sie in unserer Bündelungsdokumentation.

Zusätzlich zu dem, was dort beschrieben wird, benötigt diese Bibliothek auch zusätzliche Polyfills für die folgenden integrierten NodeJS-Core-Module, um in den Browsern ordnungsgemäß zu funktionieren:

• buffer
• os
• path
• process

Bündelung mit Webpack

Wenn Sie Webpack v5 verwenden, können Sie die folgenden Dev-Abhängigkeiten installieren.

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

fügen Sie dann Folgendes zu Ihrem 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"),
+    },
   },

Bündelung mit Rollup

Wenn Sie rollup bundler verwenden, installieren Sie die folgenden Dev-Abhängigkeiten

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

Fügen Sie dann Folgendes in Ihre 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"],
+    }),
  ]
};

Weitere Informationen zur Verwendung von Polyfills finden Sie in der Dokumentation Ihres bevorzugten Bundlers.

React Native Support

Ähnlich wie Browser unterstützt React Native keine JavaScript-API, die von dieser SDK-Bibliothek verwendet wird, sodass Sie Polyfills für sie bereitstellen müssen. Weitere Informationen finden Sie im Beispiel messaging React Native mit Expo.

Authentifizieren des Clients

Die Interaktion mit Event Hubs beginnt entweder mit einem instance der EventHubConsumerClient-Klasse oder mit einem instance der EventHubProducerClient-Klasse. Es gibt Konstruktorüberladungen, die verschiedene Methoden zum Instanziieren dieser Klassen unterstützen, wie unten gezeigt:

Verwenden Verbindungszeichenfolge für den Event Hubs-Namespace

Eine der Konstruktorüberladungen übernimmt eine Verbindungszeichenfolge des Formular- Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key; und Entitätsnamens an Ihre Event Hub-instance. Sie können eine Consumergruppe erstellen und die Verbindungszeichenfolge sowie den Entitätsnamen aus dem Azure-Portal abrufen.

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

Verwenden von Verbindungszeichenfolge für die Richtlinie im Event Hub

Eine andere Konstruktorüberladung übernimmt die Verbindungszeichenfolge, die der Shared Access-Richtlinie entspricht, die Sie direkt im Event Hub-instance (und nicht im Event Hubs-Namespace) definiert haben. Diese Verbindungszeichenfolge hat das Format Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name. Der Hauptunterschied im Verbindungszeichenfolge-Format zur vorherigen Konstruktorüberladung ist die ;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"
);

Verwenden des Event Hubs-Namespaces und der Azure Identity

Diese Konstruktorüberladung übernimmt den Hostnamen und Entitätsnamen Ihrer Event Hub-instance und Anmeldeinformationen, die die TokenCredential-Schnittstelle implementiert. Dadurch können Sie sich mit einem Azure Active Directory-Prinzipal authentifizieren. Es sind Implementierungen der TokenCredential Schnittstelle im @azure-/Identitätspaket verfügbar. Der Hostname hat das Format <yournamespace>.servicebus.windows.net. Bei Verwendung von Azure Active Directory muss Ihrem Prinzipal eine Rolle zugewiesen werden, die den Zugriff auf Event Hubs ermöglicht, z. B. die Rolle Azure Event Hubs Datenbesitzer. Weitere Informationen zur Verwendung der Azure Active Directory-Autorisierung mit Event Hubs finden Sie in der zugehörigen Dokumentation.

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

Wichtige Begriffe

• Ein Event Hub-Produzent ist eine Quelle von Telemetriedaten, Diagnose Informationen, Nutzungsprotokollen oder anderen Protokolldaten als Teil einer eingebetteten Gerätelösung, einer Mobilen Geräteanwendung, eines Spieltitels, der auf einer Konsole oder einem anderen Gerät ausgeführt wird, einer client- oder serverbasierten Geschäftslösung oder einer Website.

• Ein Event Hub-Consumer erfasst solche Informationen aus dem Event Hub und verarbeitet sie. Die Verarbeitung kann Aggregation, komplexe Berechnung und Filterung umfassen. Die Verarbeitung kann auch eine unformatierte oder transformierte Verteilung oder Speicherung der Informationen umfassen. Event Hub-Consumer sind häufig robuste und umfangreiche Komponenten der Plattforminfrastruktur mit integrierten Analysefunktionen wie Azure Stream Analytics, Apache Spark oder Apache Storm.

• Eine Partition ist eine geordnete Sequenz Abfolge von Ereignissen, die in einem Event Hub erfolgt. Partitionen sind ein Mittel der Datenorganisation, die mit der von Ereignisconsumer geforderten Parallelität verbunden ist. Azure Event Hubs ermöglicht Nachrichtenstreaming über ein partitioniertes Consumermuster, bei dem jeder Consumer nur eine bestimmte Teilmenge oder Partition des Nachrichtendatenstroms liest. Neu eingehende Ereignisse werden am Ende dieser Sequenz hinzugefügt. Die Anzahl der Partitionen wird zum Zeitpunkt der Erstellung eines Event Hubs angegeben und kann nicht geändert werden.

• Eine Consumergruppe ist eine Ansicht eines vollständigen Event Hubs. Consumergruppen ermöglichen es mehreren verarbeitenden Anwendungen, jeweils eine eigene Ansicht des Ereignisdatenstroms zu verwenden und den Datenstrom unabhängig voneinander in ihrem eigenen Tempo und von ihrer eigenen Position aus zu lesen. Pro Consumergruppe können höchstens fünf gleichzeitige Leser auf einer Partition vorhanden sein. Es wird jedoch empfohlen, nur einen aktiven Consumer für eine bestimmte Partitions- und Consumergruppenkopplung zu verwenden. Jeder aktive Reader empfängt alle Ereignisse von seiner Partition; Wenn mehrere Reader auf derselben Partition vorhanden sind, erhalten sie doppelte Ereignisse.

Weitere Konzepte und ausführlichere Diskussionen finden Sie unter Event Hubs-Features

Anleitung zu Wiederholungen

Und EventHubConsumerClient akzeptierenoptions, wo Sie festlegen retryOptions können, damit Sie optimieren können, wie das SDK vorübergehende EventHubProducerClient Fehler behandelt. Beispiele für vorübergehende Fehler sind temporäre Netzwerk- oder Dienstprobleme.

Wiederholungen beim Verwenden von Ereignissen

Wenn ein vorübergehender Fehler (z. B. ein temporäres Netzwerkproblem) auftritt, während das SDK Ereignisse empfängt, versucht es, Ereignisse basierend auf den an EventHubConsumerClientden übergebenen Wiederholungsoptionen zu empfangen. Wenn die maximalen Wiederholungsversuche erschöpft sind, wird die processError Funktion aufgerufen.

Sie können die Wiederholungseinstellungen verwenden, um zu steuern, wie schnell Sie über temporäre Probleme wie ein Netzwerkverbindungsproblem informiert werden. Wenn Sie beispielsweise wissen müssen, wann sofort ein Netzwerkproblem vorliegt, können Sie die Werte für maxRetries und retryDelayInMssenken.

Nach dem Ausführen der processError Funktion empfängt der Client weiterhin Ereignisse von der Partition, solange der Fehler wiederholt werden kann. Andernfalls ruft der Client die vom Benutzer bereitgestellte Funktion auf processClose . Diese Funktion wird auch aufgerufen, wenn Sie entweder das Abonnement beenden oder wenn der Client das Lesen von Ereignissen aus der aktuellen Partition beendet, da sie von einem anderen instance Ihrer Anwendung im Rahmen des Lastenausgleichs abgerufen wird.

Die processClose Funktion bietet die Möglichkeit, prüfpunkte bei Bedarf zu aktualisieren. Nach dem Ausführen processCloseruft der Client (oder im Fall des Lastenausgleichs ein Client aus einem anderen instance Ihrer Anwendung) die vom Benutzer bereitgestellte processInitialize Funktion auf, um das Lesen von Ereignissen aus dem zuletzt aktualisierten Prüfpunkt für dieselbe Partition fortzusetzen.

Wenn Sie den Versuch beenden möchten, Ereignisse zu lesen, müssen Sie das subscription von der subscribe -Methode zurückgegebene aufrufenclose().

Beispiele

In den folgenden Abschnitten finden Sie Codeausschnitte, die einige der häufigen Aufgaben mit Azure Event Hubs

• Untersuchen eines Event Hubs
• Veröffentlichen von Ereignissen für einen Event Hub
• Nutzen von Ereignissen aus einem Event Hub
• Verwenden von EventHubConsumerClient für die Arbeit mit IotHub

Untersuchen eines Event Hubs

Viele Event Hub-Vorgänge finden im Bereichs einer bestimmten Partition statt. Da sich Partitionen im Besitz des Event Hubs befinden, werden ihre Namen zum Zeitpunkt der Erstellung zugewiesen. Um zu verstehen, welche Partitionen verfügbar sind, fragen Sie den Event Hub mit einem der beiden verfügbaren Clients ab: EventHubProducerClient oder EventHubConsumerClient

Im folgenden Beispiel wird ein EventHubProducerClientverwendet.

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

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

  const partitionIds = await client.getPartitionIds();

  await client.close();
}

main();

Veröffentlichen von Ereignissen für einen Event Hub

Um Ereignisse zu veröffentlichen, müssen Sie einen EventHubProducerClient erstellen. Während das folgende Beispiel eine Möglichkeit zum Erstellen des Clients zeigt, finden Sie im Abschnitt Authentifizieren des Clients weitere Möglichkeiten zum Instanziieren des Clients.

Sie können Ereignisse auf einer bestimmten Partition veröffentlichen oder dem Event Hubs-Dienst erlauben, zu entscheiden, in welchen Partitionsereignissen veröffentlicht werden sollen. Es wird empfohlen, automatisches Routing zu verwenden, wenn die Veröffentlichung von Ereignissen hochverfügbar sein muss oder wenn Ereignisdaten gleichmäßig auf die Partitionen verteilt werden sollen. Im folgenden Beispiel nutzen wir das automatische Routing.

• Create eines EventDataBatch Objekts mithilfe von createBatch
• Fügen Sie dem Batch mithilfe der tryAdd-Methode Ereignisse hinzu. Sie können dies tun, bis die maximale Batchgröße erreicht ist oder bis Sie die Anzahl der Ereignisse hinzugefügt haben, die Ihnen gefallen haben, je nachdem, was zuerst eintritt. Diese Methode gibt zurück false , um anzugeben, dass dem Batch aufgrund der maximalen Batchgröße keine weiteren Ereignisse hinzugefügt werden können.
• Senden Sie den Batch von Ereignissen mithilfe der sendBatch-Methode .

Im folgenden Beispiel versuchen wir, 10 Ereignisse an Azure Event Hubs zu senden.

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

Es gibt Optionen, die Sie in verschiedenen Phasen übergeben können, um den Prozess des Sendens von Ereignissen an Azure Event Hubs zu steuern.

• Der EventHubProducerClient Konstruktor verwendet einen optionalen Parameter vom Typ EventHubClientOptions , den Sie verwenden können, um Optionen wie die Anzahl der Wiederholungen anzugeben.
• Die createBatch -Methode verwendet einen optionalen Parameter vom Typ CreateBatchOptions , den Sie verwenden können, um die maximale Batchgröße zu ermitteln, die vom erstellten Batch unterstützt wird.
• Die sendBatch -Methode verwendet einen optionalen Parameter vom Typ SendBatchOptions , den Sie verwenden können, um den abortSignal aktuellen Vorgang abzubrechen.
• Wenn Sie an eine bestimmte Partition senden möchten, können Sie durch eine Überladung der sendBatch Methode die ID der Partition übergeben, an die Ereignisse gesendet werden sollen. Im obigen Beispiel Zum Überprüfen eines Event Hubs wird gezeigt, wie die verfügbaren Partitions-IDs abgerufen werden.

Hinweis: Bei der Arbeit mit Azure Stream Analytics sollte auch der Textkörper des gesendeten Ereignisses ein JSON-Objekt sein. Beispiel: body: { "message": "Hello World" }

Nutzen von Ereignissen aus einem Event Hub

Um Ereignisse aus einem Event Hub-instance nutzen zu können, müssen Sie auch wissen, auf welche Consumergruppe Sie abzielen möchten. Sobald Sie dies wissen, können Sie einen EventHubConsumerClient erstellen. Während das folgende Beispiel eine Möglichkeit zum Erstellen des Clients zeigt, finden Sie im Abschnitt Authentifizieren des Clients weitere Möglichkeiten zum Instanziieren des Clients.

Die subscribe -Methode auf dem Client verfügt über Überladungen, die in Kombination mit dem Konstruktor mehrere Möglichkeiten zum Nutzen von Ereignissen bieten können:

• Nutzen von Ereignissen in einem einzelnen Prozess
• Nutzen von Ereignissen mit Lastenausgleich über mehrere Prozesse hinweg
• Nutzen von Ereignissen von einer einzelnen Partition

Die subscribe -Methode verwendet einen optionalen Parameter vom Typ SubscriptionOptions , den Sie verwenden können, um Optionen wie maxBatchSize (Anzahl der zu wartenden Ereignisse) und maxWaitTimeInSeconds (Wartezeit bis zum Eintreffen von maxBatchSize-Ereignissen) anzugeben.

Nutzen von Ereignissen in einem einzelnen Prozess

Erstellen Sie zunächst eine instance von EventHubConsumerClient, und rufen Sie dann die subscribe() -Methode auf, um Ereignisse zu nutzen.

Die subscribe -Methode akzeptiert Rückrufe, um Ereignisse zu verarbeiten, wenn sie von Azure Event Hubs empfangen werden. Um den Empfang von Ereignissen zu beenden, können Sie das von der subscribe() -Methode zurückgegebene Objekt aufrufenclose().

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

Nutzen von Ereignissen mit Lastenausgleich über mehrere Prozesse hinweg

Azure Event Hubs ist in der Lage, Millionen von Ereignissen pro Sekunde zu verarbeiten. Um Ihre Verarbeitungsanwendung zu skalieren, können Sie mehrere Instanzen Ihrer Anwendung ausführen und die Last untereinander ausgleichen lassen.

Erstellen Sie zunächst eine instance von EventHubConsumerClient mit einer der Konstruktorüberladungen, die einen CheckpointStoreannehmen, und rufen Sie dann die -Methode auf, um mit der subscribe() Nutzung von Ereignissen zu beginnen. Der Prüfpunktspeicher ermöglicht es den Abonnenten innerhalb einer Consumergruppe, die Verarbeitung zwischen mehreren Instanzen Ihrer Anwendung zu koordinieren.

In diesem Beispiel verwenden wir das BlobCheckpointStore aus dem @azure/eventhubs-checkpointstore-blob Paket, das die erforderlichen Lese-/Schreibvorgänge mit Azure Blob Storage in einen dauerhaften Speicher implementiert.

Die subscribe -Methode akzeptiert Rückrufe, um Ereignisse zu verarbeiten, wenn sie von Azure Event Hubs empfangen werden. Um den Empfang von Ereignissen zu beenden, können Sie das von der subscribe() -Methode zurückgegebene Objekt aufrufenclose().

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

Weitere Informationen finden Sie unter Ausgleich der Partitionslast über mehrere Instanzen Ihrer Anwendung hinweg.

Nutzen von Ereignissen von einer einzelnen Partition

Erstellen Sie zunächst eine instance von EventHubConsumerClient, und rufen Sie dann die subscribe() -Methode auf, um Ereignisse zu nutzen. Übergeben Sie die ID der Partition, die Sie als Ziel verwenden möchten, an die subscribe() -Methode, damit sie nur von dieser Partition aus verwendet wird.

Im folgenden Beispiel verwenden wir die erste Partition.

Die subscribe -Methode akzeptiert Rückrufe, um Ereignisse zu verarbeiten, wenn sie von Azure Event Hubs empfangen werden. Um den Empfang von Ereignissen zu beenden, können Sie das von der subscribe() -Methode zurückgegebene Objekt aufrufenclose().

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

Verwenden von EventHubConsumerClient für die Arbeit mit IotHub

Sie können auch verwenden EventHubConsumerClient , um mit IotHub zu arbeiten. Dies ist nützlich, um Telemetriedaten von IotHub vom verknüpften EventHub zu empfangen. Die zugeordnete Verbindungszeichenfolge verfügt nicht über Sendeansprüche, daher ist das Senden von Ereignissen nicht möglich.

• Beachten Sie, dass die Verbindungszeichenfolge für einen Event Hub-kompatiblen Endpunkt sein muss (z. B. "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();

Problembehandlung

AMQP-Abhängigkeiten

Die Event Hubs-Bibliothek hängt von der rhea-promise-Bibliothek zum Verwalten von Verbindungen sowie zum Senden und Empfangen von Ereignissen über das AMQP-Protokoll ab.

Protokollierung

Sie können die Umgebungsvariable AZURE_LOG_LEVEL so festlegen, dass die Protokollierung für aktiviert wird stderr:

export AZURE_LOG_LEVEL=verbose

Ausführlichere Anweisungen zum Aktivieren von Protokollen finden Sie in der Paketdokumentation zu @azure/logger.

Alternativ können Sie die Umgebungsvariable DEBUG so festlegen, dass protokolle abgerufen werden, wenn Sie diese Bibliothek verwenden. Dies kann nützlich sein, wenn Sie auch Protokolle aus den Abhängigkeiten rhea-promise und rhea ausgeben möchten.

Hinweis: AZURE_LOG_LEVEL, sofern festgelegt, hat Vorrang vor DEBUG. Geben Sie keine azure Bibliotheken über DEBUG an, wenn Sie auch AZURE_LOG_LEVEL angeben oder setLogLevel aufrufen.

• Abrufen nur Debugprotokolle auf Infoebene aus dem Event Hubs SDK.

export DEBUG=azure:*:info

• Abrufen von Debugprotokollen aus dem Event Hubs SDK und der Bibliothek auf Protokollebene.

export DEBUG=azure*,rhea*

• Wenn Sie nicht an der Anzeige der Unformatierten Ereignisdaten interessiert sind (die eine große Menge an Konsolen-/Datenträgerspeicher belegen), können Sie die DEBUG Umgebungsvariable wie folgt festlegen:

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

• Wenn Sie nur an Fehlern und SDK-Warnungen interessiert sind, können Sie die DEBUG Umgebungsvariable wie folgt festlegen:

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

Nächste Schritte

Weiterer Beispielcode

Sehen Sie sich das Beispielverzeichnis an, um detaillierte Beispiele für die Verwendung dieser Bibliothek zum Senden und Empfangen von Ereignissen an/von Event Hubs zu erhalten.

Mitwirken

Wenn Sie an dieser Bibliothek mitwirken möchten, lesen Sie die Anleitung für Mitwirkende, um mehr darüber zu erfahren, wie Sie den Code erstellen und testen können.