Azure Event Hubs Client-Bibliothek für JavaScript - Version 6.0.3

Azure Event Hubs ist ein hochskalierbarer Publish-Subscribe-Service, der Millionen von Ereignissen pro Sekunde aufnehmen und an mehrere Nutzer streamen kann. Auf diese Weise können Sie die massiven Datenmengen verarbeiten und analysieren, die von Ihren verbundenen Geräten und Anwendungen erzeugt werden. Wenn Sie mehr über Azure Event Hubs erfahren möchten, könnten Sie lesen: Was ist Event Hubs?

Die Azure Event Hubs Client-Bibliothek ermöglicht es Ihnen, Ereignisse in Ihrer Node.js Anwendung zu senden und zu empfangen.

Wichtige Links:

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

HINWEIS: Wenn Sie Version 2.1.0 oder niedriger verwenden und auf die neueste Version dieses Pakets migrieren möchten, sehen Sie sich bitte unseren Migrationsleitfaden an, um von EventHubs V2 auf EventHubs V5 umzusteigen

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

Installiere das Paket

Installiere die Azure Event Hubs Client-Bibliothek mit npm

npm install @azure/event-hubs

Derzeit unterstützte Umgebungen

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

Weitere Details finden Sie in unserer Supportrichtlinie .

Voraussetzungen

• Ein Azure-Abonnement
• Ein Event Hubs-Namensraum

TypeScript konfigurieren

TypeScript-Nutzer müssen Node-Typdefinitionen installiert haben:

npm install @types/node

Du musst auch in deinem tsconfig.jsonaktivieren compilerOptions.allowSyntheticDefaultImports . Beachte, dass wenn du aktiviert compilerOptions.esModuleInterophast, allowSyntheticDefaultImports standardmäßig aktiviert ist. Weitere Informationen finden Sie im Compiler-Optionshandbuch von TypeScript .

JavaScript-Bündel

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

Zusätzlich zu den dort Beschriebenen benötigt diese Bibliothek auch zusätzliche Polyfills für die folgenden NodeJS-Kernmodule, damit sie in den Browsern richtig funktioniert:

• buffer
• os
• path
• process

Bündeln mit Webpack

Wenn du Webpack v5 verwendest, kannst du die folgenden Entwicklungsabhängigkeiten installieren

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

Dann fügen Sie Folgendes in Ihr 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 du Rollup Bundler verwendest, installiere die folgenden Entwicklungsabhängigkeiten

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

Dann fügen Sie Folgendes in Ihr 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"],
+    }),
  ]
};

Bitte konsultieren Sie die Dokumentation Ihres Lieblings-Bundlers für weitere Informationen zur Verwendung von Polyfills.

React Native-Unterstützung

Ähnlich wie bei Browsern unterstützt React Native keine JavaScript-API, die von dieser SDK-Bibliothek verwendet wird, daher müssen Sie Polyfills für sie bereitstellen. Bitte sehen Sie sich das Messaging React Native-Beispiel mit Expo für weitere Details an.

Authentifizieren des Clients

Die Interaktion mit Event Hubs beginnt entweder mit einer Instanz der EventHubConsumerClient-Klasse oder einer Instanz der EventHubProducerClient-Klasse . Es gibt Konstruktor-Überlastungen, die verschiedene Möglichkeiten zur Instanzialisierung dieser Klassen unterstützen, wie unten gezeigt:

Verwenden Sie eine Verbindungszeichenkette für den Event Hubs-Namensraum

Einer der Konstruktor-Overloads nimmt eine Verbindungszeichenkette mit Form Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key; und Entitätsnamen zu deiner Event Hub-Instanz. Sie können eine Consumer-Gruppe erstellen und die Verbindungszeichenkette sowie den Entitätsnamen aus dem Azure-Portal erhalten.

import { EventHubProducerClient, EventHubConsumerClient } from "@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 Sie die Verbindungsstring für die Policy auf dem Event Hub

Eine weitere Konstruktor-Überladung nimmt die Verbindungszeichenkette, die der von dir definierten Shared-Access-Policy entspricht, direkt auf der Event Hub-Instanz (und nicht im Event Hubs-Namensraum). Diese Verbindungskette hat die Form Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name. Der entscheidende Unterschied im Verbindungsstring-Format zum vorherigen Konstruktor-Overload ist das ;EntityPath=my-event-hub-name.

import { EventHubProducerClient, EventHubConsumerClient } from "@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 Sie den Event Hubs-Namensraum und Azure Identity

Diese Konstruktor-Überladung nimmt den Host- und Entitätsnamen Ihrer Event Hub-Instanz und der Credential, die die TokenCredential-Schnittstelle implementiert. Dies ermöglicht die Authentifizierung mit einem Azure Active Directory Principal. Es gibt Implementierungen der Schnittstelle TokenCredential im @azure/Identity-Paket . Der Hostname ist das Format <yournamespace>.servicebus.windows.net. Bei der Nutzung von Azure Active Directory muss Ihrem Hauptverantwortlichen eine Rolle zugewiesen werden, die den Zugriff auf Event Hubs ermöglicht, wie zum Beispiel die Azure Event Hubs Data Owner-Rolle. Weitere Informationen zur Nutzung der Azure Active Directory-Autorisierung mit Event Hubs finden Sie in der zugehörigen Dokumentation.

import { DefaultAzureCredential } from "@azure/identity";
import { EventHubProducerClient, EventHubConsumerClient } from "@azure/event-hubs";

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 für Telemetriedaten, Diagnoseinformationen, Nutzungsprotokolle oder andere Logdaten als Teil einer eingebetteten Gerätelösung, einer mobilen Geräteanwendung, eines Spieltitels auf einer Konsole oder einem anderen Gerät, einer clients- oder serverbasierten Geschäftslösung oder einer Website.

• Ein Event-Hub-Nutzer empfängt solche Informationen vom Event Hub und verarbeitet sie. Die Verarbeitung kann Aggregation, komplexe Berechnungen und Filterung umfassen. Die Verarbeitung kann auch die Verteilung oder Speicherung der Informationen in roher oder transformierter Weise umfassen. Event Hub-Nutzer sind oft robuste und hochskalierte Plattforminfrastrukturteile mit integrierten Analysefunktionen, wie Azure Stream Analytics, Apache Spark oder Apache Storm.

• Eine Partition ist eine geordnete Abfolge von Ereignissen, die in einem Event Hub gehalten wird. Partitionen sind eine Form der Datenorganisation, die mit der von Ereigniskonsumenten benötigten Parallelität verbunden ist. Azure Event Hubs bietet Nachrichtenstreaming durch ein partitioniertes Konsumentenmuster, bei dem jeder Konsument nur eine bestimmte Teilmenge oder Partition des Nachrichtenstroms liest. Wenn neue Ereignisse eintreffen, werden sie am Ende dieser Sequenz hinzugefügt. Die Anzahl der Partitionen wird zum Zeitpunkt der Erstellung eines Event Hub angegeben und kann nicht geändert werden.

• Eine Konsumentengruppe ist eine Ansicht eines gesamten Event Hubs. Verbrauchergruppen ermöglichen es mehreren konsumierenden Anwendungen, jeweils eine separate Ansicht des Ereignisstroms zu haben und den Strom unabhängig in ihrem eigenen Tempo und von ihrer eigenen Position aus zu lesen. Auf einer Partition pro Consumer-Gruppe können maximal 5 gleichzeitige Leser vorhanden sein; es wird jedoch empfohlen, dass es nur einen aktiven Consumer für eine bestimmte Partition und eine Consumer-Gruppenpaarung gibt. Jeder aktive Leser erhält alle Ereignisse von seiner Teilung; Wenn sich mehrere Reader auf derselben Partition befinden, erhalten sie doppelte Events.

Für weitere Konzepte und tiefere Diskussionen siehe: Event Hubs Features

Hinweise zu Wiederholungen

Die EventHubConsumerClient und EventHubProducerClient akzeptieren options , wo du die retryOptions einstellen kannst, die es dir ermöglichen, zu optimieren, wie das SDK transiente Fehler handhabt. Beispiele für vorübergehende Fehler sind temporäre Netzwerk- oder Dienstprobleme.

Wiederholte Versuche beim Konsumieren von Ereignissen

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

Sie können die Einstellungen für Wiederholen nutzen, um zu steuern, wie schnell Sie über vorübergehende Probleme wie eine Netzwerkverbindung informiert werden. Wenn Sie zum Beispiel sofort wissen müssen, wann es ein Netzwerkproblem gibt, können Sie die Werte für maxRetries und retryDelayInMssenken.

Nach Ausführung der processError Funktion erhält der Client weiterhin Ereignisse von der Partition, solange der Fehler ein wiederholbarer war. Andernfalls ruft der Client die vom Benutzer bereitgestellte processClose Funktion auf. Diese Funktion wird auch aktiviert, wenn Sie entweder das Abonnement beenden oder wenn der Client aufhört, Ereignisse von der aktuellen Partition zu lesen, weil sie von einer anderen Instanz Ihrer Anwendung im Rahmen der Lastverteilung empfangen werden.

Die processClose Funktion bietet die Möglichkeit, Kontrollpunkte bei Bedarf zu aktualisieren. Nach der Ausführung processClosestartet der Client (oder im Fall der Lastverteilung ein Client aus einer anderen Instanz Ihrer Anwendung) die vom Benutzer bereitgestellte processInitialize Funktion, um das Lesen von Ereignissen vom zuletzt aktualisierten Checkpoint für dieselbe Partition fortzusetzen.

Wenn Sie aufhören möchten, Ereignisse zu lesen, müssen Sie die Zurückgesandten close() per Methode subscription anrufensubscribe.

Examples

Die folgenden Abschnitte bieten Codeschnipsel, die einige der gängigen Aufgaben mit Azure Event Hubs abdecken

• Inspizieren Sie einen Event Hub
• Veröffentlichen Sie Veranstaltungen in einem Event Hub
• Konsumiere Ereignisse von einem Event Hub
• Verwenden Sie EventHubConsumerClient, um mit IotHub zu arbeiten

Inspizieren Sie einen Event Hub

Viele Event Hub-Operationen finden innerhalb des Bereichs einer bestimmten Partition statt. Da Partitionen dem Event Hub gehören, 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 untenstehenden Beispiel verwenden wir ein EventHubProducerClient.

import { EventHubProducerClient } from "@azure/event-hubs";

const client = new EventHubProducerClient("connectionString", "eventHubName");

const partitionIds = await client.getPartitionIds();

await client.close();

Veröffentlichen Sie Veranstaltungen in einem Event Hub

Um Events zu veröffentlichen, musst du eine EventHubProducerClienterstellen. Während das untenstehende Beispiel eine Möglichkeit zeigt, den Client zu erstellen, siehe den Abschnitt "Client authentifizieren ", um weitere Möglichkeiten zur Instanzialisierung des Clients zu erfahren.

Sie können Ereignisse auf eine bestimmte Partition veröffentlichen oder dem Event Hubs-Dienst erlauben, zu entscheiden, auf welche Partitionsereignisse veröffentlicht werden sollen. Es wird empfohlen, automatische Routing zu verwenden, wenn die Veröffentlichung von Ereignissen hoch verfügbar sein muss oder wenn Ereignisdaten gleichmäßig auf die Partitionen verteilt werden sollten. Im untenstehenden Beispiel nutzen wir das automatische Routing.

• Erstellen Sie ein EventDataBatch Objekt mit dem createBatch
• Füge Ereignisse mit der tryAdd-Methode zum Batch hinzu. Du kannst das tun, bis die maximale Chargengröße erreicht ist oder bis du die Anzahl der gewünschten Events hinzugefügt hast, je nachdem, was zuerst eintritt. Diese Methode würde anzeigen false , dass aufgrund der erreichten maximalen Batchgröße keine weiteren Ereignisse mehr zum Batch hinzugefügt werden können.
• Senden Sie den Batch der Ereignisse mit der sendBatch-Methode .

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

import { EventHubProducerClient } from "@azure/event-hubs";

const producerClient = new EventHubProducerClient("connectionString", "eventHubName");

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

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

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

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

• Der EventHubProducerClient Konstruktor nimmt einen optionalen Parameter des Typs EventHubClientOptions , den du verwenden kannst, um Optionen wie die Anzahl der Wiederholungen anzugeben.
• Die Methode createBatch verwendet einen optionalen Parameter vom Typ CreateBatchOptions , den Sie verwenden können, um die maximale Batchgröße zu bestimmen, die vom erstellten Batch unterstützt wird.
• Die Methode sendBatch nimmt einen optionalen Parameter vom Typ SendBatchOptions , den Sie verwenden können, um abortSignal die aktuelle Operation aufzuheben.
• Falls du an eine bestimmte Partition senden möchtest, ermöglicht eine Überladung der sendBatch Methode, die ID der Partition zu übergeben, an die Ereignisse gesendet werden sollen. Das obige Beispiel "Inspect an Event Hub" zeigt, wie man die verfügbaren Partitions-IDs abruft.

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

Konsumiere Ereignisse von einem Event Hub

Um Ereignisse aus einer Event Hub-Instanz zu konsumieren, müssen Sie außerdem wissen, welche Konsumentengruppe Sie ansprechen möchten. Sobald Sie das wissen, sind Sie bereit, einen EventHubConsumerClient zu erstellen. Während das untenstehende Beispiel eine Möglichkeit zeigt, den Client zu erstellen, siehe den Abschnitt "Client authentifizieren ", um weitere Möglichkeiten zur Instanzialisierung des Clients zu erfahren.

Die Methode subscribe im Client hat Überlastungen, die zusammen mit dem Konstruktor mehrere Möglichkeiten zur Erfassung von Ereignissen ermöglichen:

• Ereignisse in einem einzigen Prozess konsumieren
• Verbrauche Ereignisse mit Lastverteilung über mehrere Prozesse hinweg
• Verbrauche Ereignisse von einer einzelnen Partition

Die Methode subscribe verwendet einen optionalen Parameter des Typs SubscriptionOptions , den Sie verwenden können, um Optionen wie maxBatchSize (Anzahl der zu wartenden Ereignisse) und maxWaitTimeInSeconds (Wartezeit, bis maxBatchSize-Ereignisse eintreffen) anzugeben.

Ereignisse in einem einzigen Prozess konsumieren

Beginne damit, eine Instanz der EventHubConsumerClientzu erstellen, und rufe dann die subscribe() Methode darauf auf, um Ereignisse zu konsumieren.

Die Methode subscribe nimmt Rückrufe durch, um Ereignisse zu verarbeiten, sobald sie von Azure Event Hubs empfangen werden. Um den Empfang von Ereignissen zu stoppen, können Sie das von der Methode close() zurückgegebene Objekt aufrufensubscribe().

import { EventHubConsumerClient, earliestEventPosition } from "@azure/event-hubs";

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

Verbrauche Ereignisse mit Lastverteilung über mehrere Prozesse hinweg

Azure Event Hubs ist in der Lage, Millionen von Ereignissen pro Sekunde zu verarbeiten. Um deine Verarbeitungsanwendung zu skalieren, kannst du mehrere Instanzen deiner Anwendung ausführen und sie die Last untereinander ausgleichen lassen.

Beginnen Sie damit, eine Instanz von der EventHubConsumerClient mit einem der Konstruktor-Überlastungen zu erstellen, die einen CheckpointStorebenötigen, und rufen Sie dann die Methode subscribe() auf, um mit dem Konsumieren von Ereignissen zu beginnen. Der Checkpoint-Speicher ermöglicht es den Abonnenten innerhalb einer Konsumentengruppe, die Verarbeitung zwischen mehreren Instanzen Ihrer Anwendung zu koordinieren.

In diesem Beispiel verwenden wir das BlobCheckpointStore From the @azure/eventhubs-checkpointstore-blob Package, das die erforderlichen Lese-/Schreibvorgänge in einen Durable Store mit Azure Blob Storage implementiert.

Die Methode subscribe nimmt Rückrufe durch, um Ereignisse zu verarbeiten, sobald sie von Azure Event Hubs empfangen werden. Um den Empfang von Ereignissen zu stoppen, können Sie das von der Methode close() zurückgegebene Objekt aufrufensubscribe().

import { ContainerClient } from "@azure/storage-blob";
import { BlobCheckpointStore } from "@azure/eventhubs-checkpointstore-blob";
import { EventHubConsumerClient } from "@azure/event-hubs";

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

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

Bitte siehe Partitionsauslastung über mehrere Instanzen Ihrer Anwendung ausbalancieren , um mehr zu erfahren.

Verbrauche Ereignisse von einer einzelnen Partition

Beginne damit, eine Instanz der EventHubConsumerClientzu erstellen, und rufe dann die subscribe() Methode darauf auf, um Ereignisse zu konsumieren. Gib die ID der Partition, die du anvisieren möchtest, an die subscribe() Methode weiter, die sie nur von dieser Partition konsumieren soll.

Im untenstehenden Beispiel verwenden wir die erste Partition.

Die Methode subscribe nimmt Rückrufe durch, um Ereignisse zu verarbeiten, sobald sie von Azure Event Hubs empfangen werden. Um den Empfang von Ereignissen zu stoppen, können Sie das von der Methode close() zurückgegebene Objekt aufrufensubscribe().

import { EventHubConsumerClient, earliestEventPosition } from "@azure/event-hubs";

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

Verwenden Sie EventHubConsumerClient, um mit IotHub zu arbeiten

Du kannst EventHubConsumerClient es auch nutzen, um mit IotHub zu arbeiten. Dies ist nützlich, um Telemetriedaten von IotHub vom verbundenen EventHub zu empfangen. Die zugehörige Verbindungszeichenkette hat keine Send-Ansprüche, daher ist das Senden von Events nicht möglich.

• Bitte beachten Sie, dass die Verbindungszeichenkette 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=mein-iot-hub-name")

import { EventHubConsumerClient } from "@azure/event-hubs";

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

Problembehandlung

AMQP-Abhängigkeiten

Die Event Hubs-Bibliothek ist von der rhea-promise-Bibliothek abhängig, um Verbindungen zu verwalten, Ereignisse zu senden und über das AMQP-Protokoll zu empfangen.

Protokollierung

Sie können die AZURE_LOG_LEVEL Umgebungsvariable so einstellen, dass sie das Logging ermöglicht:stderr

export AZURE_LOG_LEVEL=verbose

Alternativ kann die Protokollierung zur Laufzeit durch Aufrufen von setLogLevel im @azure/loggeraktiviert werden:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Ausführlichere Anweisungen zum Aktivieren von Protokollen finden Sie in den @azure/Logger-Paketdokumenten.

Alternativ kannst du die DEBUG Umgebungsvariable so einstellen, dass sie Logs abruft, wenn du diese Bibliothek nutzt. Das kann nützlich sein, wenn du auch Logs aus den Abhängigkeiten rhea-promise emittieren möchtest rhea .

Hinweis: AZURE_LOG_LEVEL, wenn gesetzt, hat Vorrang vor DEBUG. Spezifizieren Sie keine Bibliotheken azure über DEBUG, wenn Sie auch AZURE_LOG_LEVEL angeben oder setLogLevel aufrufen.

• Ich bekomme nur Info-Level-Debug-Logs vom Event Hubs SDK.

export DEBUG=azure:*:info

• Debug-Logs vom Event Hubs SDK und der Protokollbibliothek zu erhalten.

export DEBUG=azure*,rhea*

• Wenn du nicht daran interessiert bist, die Rohereignisdaten anzusehen (was viel Speicherplatz für Konsolen/Festplatte beansprucht), kannst du die DEBUG Umgebungsvariable wie folgt einstellen:

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

• Wenn Sie sich nur für Fehler und SDK-Warnungen interessieren, können Sie die Umgebungsvariable DEBUG wie folgt festlegen:

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

Nächste Schritte

Weitere Beispielcode

Bitte schauen Sie sich das Musterverzeichnis an, um detaillierte Beispiele zu finden, wie man diese Bibliothek nutzt, um Ereignisse zu/von Event Hubs zu senden und zu empfangen.

Contributing

Wenn Sie an dieser Bibliothek mitwirken möchten, lesen Sie bitte den mitwirkenden Leitfaden, um mehr über das Erstellen und Testen des Codes zu erfahren.