biblioteka klienta Azure Event Hubs dla języka JavaScript — wersja 5.12.0

Azure Event Hubs to wysoce skalowalna usługa publikowania-subskrybowania, która może pozyskiwać miliony zdarzeń na sekundę i przesyłać je strumieniowo do wielu użytkowników. Umożliwia to przetwarzanie i analizowanie ogromnych ilości danych generowanych przez połączone urządzenia i aplikacje. Jeśli chcesz dowiedzieć się więcej na temat Azure Event Hubs, możesz przejrzeć: Co to jest usługa Event Hubs?

Biblioteka klienta Azure Event Hubs umożliwia wysyłanie i odbieranie zdarzeń w aplikacji Node.js.

Kluczowe linki:

• Kod źródłowy
• Pakiet (npm)
• Dokumentacja interfejsu API
• Dokumentacja produktu
• Samples

UWAGA: Jeśli używasz wersji 2.1.0 lub nowszej i chcesz przeprowadzić migrację do najnowszej wersji tego pakietu, zapoznaj się z naszym przewodnikiem migracji, aby przejść z usługi EventHubs V2 do usługi EventHubs V5

Przykłady dla wersji 2 i dokumentacja są nadal dostępne tutaj:

Kod źródłowy wersji 2.1.0 | Pakiet dla wersji 2.1.0 (npm) | Przykłady dla wersji 2.1.0

Wprowadzenie

Instalowanie pakietu

Instalowanie biblioteki klienta Azure Event Hubs przy użyciu narzędzia npm

npm install @azure/event-hubs

Obecnie obsługiwane środowiska

• Wersje ltS Node.js
• Najnowsze wersje przeglądarek Safari, Chrome, Edge i Firefox.

Aby uzyskać więcej informacji, zobacz nasze zasady pomocy technicznej .

Wymagania wstępne

• Subskrypcja platformy Azure
• Przestrzeń nazw usługi Event Hubs

Konfigurowanie języka TypeScript

Użytkownicy języka TypeScript muszą mieć zainstalowane definicje typu węzła:

npm install @types/node

Należy również włączyć compilerOptions.allowSyntheticDefaultImports w tsconfig.json. Pamiętaj, że jeśli włączono compilerOptions.esModuleInteropusługę , allowSyntheticDefaultImports jest domyślnie włączona. Aby uzyskać więcej informacji, zobacz podręcznik dotyczący opcji kompilatora języka TypeScript .

Pakiet JavaScript

Aby użyć tej biblioteki klienta w przeglądarce, najpierw musisz użyć pakietu. Aby uzyskać szczegółowe informacje na temat tego, jak to zrobić, zapoznaj się z naszą dokumentacją dotyczącą tworzenia pakietów.

Oprócz opisanych w tym miejscu elementów ta biblioteka wymaga również dodatkowych poliwypełnień dla następujących wbudowanych modułów nodeJS w celu poprawnego działania w przeglądarkach:

• buffer
• os
• path
• process

Tworzenie pakietów za pomocą pakietu webpack

Jeśli używasz pakietu Webpack w wersji 5, możesz zainstalować następujące zależności deweloperskie

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

następnie dodaj następujące elementy do 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"),
+    },
   },

Łączenie z pakietem zbiorczym

Jeśli używasz pakietu zbiorczego, zainstaluj następujące zależności deweloperskie

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

Następnie uwzględnij następujące elementy w 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"],
+    }),
  ]
};

Aby uzyskać więcej informacji na temat korzystania z technologii polyfill, zapoznaj się z dokumentacją ulubionego pakietu.

obsługa React Native

Podobnie jak w przypadku przeglądarek, React Native nie obsługuje niektórych interfejsów API języka JavaScript używanych przez tę bibliotekę zestawu SDK, dlatego należy podać dla nich wielowypełnianie. Aby uzyskać więcej informacji, zobacz przykład Messaging React Native z expo.

Uwierzytelnianie klienta

Interakcja z usługą Event Hubs rozpoczyna się od wystąpienia klasy EventHubConsumerClient lub wystąpienia klasy EventHubProducerClient . Istnieją przeciążenia konstruktorów do obsługi różnych sposobów tworzenia wystąpień tych klas, jak pokazano poniżej:

Używanie parametry połączenia dla przestrzeni nazw usługi Event Hubs

Jedno z przeciążeń konstruktora przyjmuje parametry połączenia formularza Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key; i nazwy jednostki do wystąpienia centrum zdarzeń. Grupę odbiorców można utworzyć i pobrać parametry połączenia oraz nazwę jednostki z 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"
);

Używanie parametry połączenia dla zasad w centrum zdarzeń

Inne przeciążenie konstruktora pobiera parametry połączenia odpowiadające zasadom dostępu współdzielonego zdefiniowanym bezpośrednio w wystąpieniu centrum zdarzeń (a nie w przestrzeni nazw usługi Event Hubs). Ta parametry połączenia będzie mieć postać Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name. Kluczową różnicą w formacie parametry połączenia z poprzedniego przeciążenia konstruktora jest ;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"
);

Używanie przestrzeni nazw usługi Event Hubs i tożsamości platformy Azure

To przeciążenie konstruktora przyjmuje nazwę hosta i nazwę jednostki wystąpienia centrum zdarzeń i poświadczenia, które implementuje interfejs TokenCredential. Umożliwia to uwierzytelnianie przy użyciu jednostki usługi Azure Active Directory. Istnieją implementacje interfejsu TokenCredential dostępne w pakiecie @azure/tożsamości . Nazwa hosta ma format <yournamespace>.servicebus.windows.net. W przypadku korzystania z usługi Azure Active Directory podmiot zabezpieczeń musi mieć przypisaną rolę, która umożliwia dostęp do usługi Event Hubs, takiej jak rola właściciela danych Azure Event Hubs. Aby uzyskać więcej informacji na temat używania autoryzacji usługi Azure Active Directory z usługą Event Hubs, zapoznaj się z skojarzona dokumentacja.

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

Kluczowe pojęcia

• Producent centrum zdarzeń jest źródłem danych telemetrycznych, informacji diagnostycznych, dzienników użycia lub innych danych dziennika, w ramach rozwiązania urządzenia osadzonego, aplikacji urządzenia przenośnego, tytułu gry uruchomionego na konsoli lub innym urządzeniu, niektórych klienta lub serwera opartego na rozwiązaniu biznesowym lub witrynie sieci Web.

• Odbiorca centrum zdarzeń pobiera takie informacje z centrum zdarzeń i przetwarza je. Przetwarzanie może obejmować agregację, złożone obliczenia i filtrowanie. Przetwarzanie może również obejmować dystrybucję lub przechowywanie informacji w sposób nieprzetworzony lub przekształcony. Użytkownicy usługi Event Hub są często niezawodnymi i wysokoskalowymi częściami infrastruktury platformy z wbudowanymi możliwościami analitycznymi, takimi jak Azure Stream Analytics, Apache Spark lub Apache Storm.

• Partycja to uporządkowana sekwencja zdarzeń przechowywanych w centrum zdarzeń. Partycje są środkami organizacji danych skojarzonymi z równoległością wymaganą przez odbiorców zdarzeń. Azure Event Hubs zapewnia przesyłanie strumieniowe komunikatów za pośrednictwem partycjonowanego wzorca konsumenta, w którym każdy odbiorca odczytuje tylko określony podzbiór lub partycję strumienia komunikatów. Po nadejściu nowszych zdarzeń są one dodawane na końcu sekwencji. Liczba partycji jest określona w momencie utworzenia centrum zdarzeń i nie można jej zmienić.

• Grupa odbiorców jest widokiem całego centrum zdarzeń. Grupy odbiorców umożliwiają korzystanie z wielu aplikacji do każdego z nich ma oddzielny widok strumienia zdarzeń i odczytywanie strumienia niezależnie we własnym tempie i z własnej pozycji. W partycji na grupę odbiorców może znajdować się co najwyżej 5 równoczesnych czytelników; zaleca się jednak, aby dla danej partycji i grupy odbiorców istniał tylko jeden aktywny konsument. Każdy aktywny czytelnik otrzymuje wszystkie zdarzenia z partycji; Jeśli na tej samej partycji znajduje się wiele czytelników, będą otrzymywać zduplikowane zdarzenia.

Aby uzyskać więcej pojęć i głębszą dyskusję, zobacz: Funkcje usługi Event Hubs

Wskazówki dotyczące ponownych prób

I EventHubConsumerClientEventHubProducerClient zaakceptuj options , gdzie można ustawić retryOptions , które umożliwiają dostrojenie sposobu obsługi błędów przejściowych przez zestaw SDK. Przykłady błędów przejściowych obejmują tymczasowe problemy z siecią lub usługą.

Ponawianie prób podczas korzystania ze zdarzeń

Jeśli wystąpi błąd przejściowy (np. tymczasowy problem z siecią) podczas odbierania zdarzeń przez zestaw SDK, ponowi próbę odebrania zdarzeń na podstawie opcji ponawiania próby przekazanych do EventHubConsumerClientelementu . Jeśli maksymalna liczba prób ponawiania prób zostanie wyczerpana, processError funkcja zostanie wywołana.

Możesz użyć ustawień ponawiania prób, aby kontrolować, jak szybko informujesz o tymczasowych problemach, takich jak problem z połączeniem sieciowym. Jeśli na przykład musisz wiedzieć, kiedy występuje problem z siecią, możesz od razu obniżyć wartości wartości i maxRetriesretryDelayInMs.

Po wykonaniu processError funkcji klient nadal odbiera zdarzenia z partycji, o ile błąd był ponawiany. W przeciwnym razie klient wywołuje funkcję udostępnioną przez processClose użytkownika. Ta funkcja jest również wywoływana, gdy zatrzymasz subskrypcję lub gdy klient przestanie odczytywać zdarzenia z bieżącej partycji z powodu jego odebrania przez inne wystąpienie aplikacji w ramach równoważenia obciążenia.

Funkcja processClose umożliwia aktualizowanie punktów kontrolnych w razie potrzeby. Po wykonaniu processClosepolecenia klient (lub w przypadku równoważenia obciążenia klient z innego wystąpienia aplikacji) wywoła funkcję udostępnioną processInitialize przez użytkownika, aby wznowić odczytywanie zdarzeń z ostatniego zaktualizowanego punktu kontrolnego dla tej samej partycji.

Jeśli chcesz przestać próbować odczytywać zdarzenia, musisz wywołać metodę close() zwróconą subscription przez metodę subscribe .

Przykłady

W poniższych sekcjach przedstawiono fragmenty kodu, które obejmują niektóre typowe zadania korzystające z Azure Event Hubs

• Inspekcja centrum zdarzeń
• Publikowanie zdarzeń w centrum zdarzeń
• Korzystanie ze zdarzeń z centrum zdarzeń
• Korzystanie z usługi EventHubConsumerClient do pracy z usługą IotHub

Inspekcja centrum zdarzeń

Wiele operacji centrum zdarzeń odbywa się w zakresie określonej partycji. Ponieważ partycje są własnością centrum zdarzeń, ich nazwy są przypisywane podczas tworzenia. Aby zrozumieć, jakie partycje są dostępne, należy wykonać zapytanie względem centrum zdarzeń przy użyciu jednego z dwóch dostępnych klientów: EventHubProducerClient lub EventHubConsumerClient

W poniższym przykładzie używamy elementu 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();

Publikowanie zdarzeń w centrum zdarzeń

Aby opublikować zdarzenia, należy utworzyć element EventHubProducerClient. Poniższy przykład przedstawia jeden ze sposobów tworzenia klienta, ale zobacz sekcję Uwierzytelnianie klienta , aby dowiedzieć się więcej na temat innych sposobów tworzenia wystąpienia klienta.

Zdarzenia można publikować w określonej partycji lub zezwolić usłudze Event Hubs na podjęcie decyzji o tym, które zdarzenia partycji powinny zostać opublikowane. Zaleca się używanie automatycznego routingu, gdy publikowanie zdarzeń musi być wysoce dostępne lub gdy dane zdarzeń powinny być równomiernie dystrybuowane między partycjami. W poniższym przykładzie skorzystamy z automatycznego routingu.

• EventDataBatch Twórca obiektu przy użyciu polecenia createBatch
• Dodaj zdarzenia do partii przy użyciu metody tryAdd . Można to zrobić do momentu osiągnięcia maksymalnego limitu rozmiaru partii lub do momentu dodania liczby polubień zdarzeń, w zależności od tego, co nastąpi wcześniej. Ta metoda powróci false , aby wskazać, że nie można dodać więcej zdarzeń do partii z powodu osiągnięcia maksymalnego rozmiaru partii.
• Wyślij partię zdarzeń przy użyciu metody sendBatch .

W poniższym przykładzie próbujemy wysłać 10 zdarzeń do 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();

Istnieją opcje, które można przekazać na różnych etapach, aby kontrolować proces wysyłania zdarzeń do Azure Event Hubs.

• Konstruktor EventHubProducerClient przyjmuje opcjonalny parametr typu EventHubClientOptions , którego można użyć do określenia opcji, takich jak liczba ponownych prób.
• Metoda createBatch przyjmuje opcjonalny parametr typu CreateBatchOptions , którego można użyć do speicify maksymalnego rozmiaru partii obsługiwanego przez tworzoną partię.
• Metoda sendBatch przyjmuje opcjonalny parametr typu SendBatchOptions , którego można użyć do określenia abortSignal , aby anulować bieżącą operację.
• Jeśli chcesz wysłać do określonej partycji, przeciążenie sendBatch metody umożliwia przekazanie identyfikatora partycji do wysyłania zdarzeń. W powyższym przykładzie Inspekcja centrum zdarzeń pokazano, jak pobrać dostępne identyfikatory partycji.

Uwaga: Podczas pracy z usługą Azure Stream Analytics treść wysyłanego zdarzenia powinna być również obiektem JSON. Na przykład: body: { "message": "Hello World" }

Korzystanie ze zdarzeń z centrum zdarzeń

Aby korzystać ze zdarzeń z wystąpienia centrum zdarzeń, musisz również wiedzieć, która grupa odbiorców ma być docelowa. Gdy już to wiesz, możesz utworzyć element EventHubConsumerClient. Poniższy przykład przedstawia jeden ze sposobów tworzenia klienta, ale zobacz sekcję Uwierzytelnianie klienta , aby dowiedzieć się więcej na temat innych sposobów tworzenia wystąpienia klienta.

Metoda subscribe na kliencie ma przeciążenia, które w połączeniu z konstruktorem mogą obsługiwać kilka sposobów korzystania z zdarzeń:

• Używanie zdarzeń w jednym procesie
• Używanie zdarzeń ze zrównoważonym obciążeniem w wielu procesach
• Korzystanie ze zdarzeń z jednej partycji

Metoda subscribe przyjmuje opcjonalny parametr typu SubscriptionOptions , którego można użyć do określenia opcji, takich jak maxBatchSize (liczba zdarzeń do oczekiwania) i maxWaitTimeInSeconds (ilość czasu oczekiwania na zdarzenia maxBatchSize do odebrania).

Używanie zdarzeń w jednym procesie

Zacznij od utworzenia wystąpienia klasy EventHubConsumerClient, a następnie wywołaj metodę subscribe() , aby rozpocząć korzystanie z zdarzeń.

Metoda subscribe pobiera wywołania zwrotne do przetwarzania zdarzeń w miarę ich odbierania z Azure Event Hubs. Aby zatrzymać odbieranie zdarzeń, można wywołać close() obiekt zwrócony przez metodę subscribe() .

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

Używanie zdarzeń ze zrównoważonym obciążeniem w wielu procesach

Azure Event Hubs może radzić sobie z milionami zdarzeń na sekundę. Aby skalować aplikację przetwarzania, możesz uruchomić wiele wystąpień aplikacji i równoważyć obciążenie między sobą.

Zacznij od utworzenia wystąpienia EventHubConsumerClient przy użyciu jednego z przeciążeń konstruktora, które przyjmują metodę , a następnie wywołaj subscribe() metodę CheckpointStore, aby rozpocząć korzystanie z zdarzeń. Magazyn punktów kontrolnych umożliwi subskrybentom w grupie odbiorców koordynowanie przetwarzania między wieloma wystąpieniami aplikacji.

W tym przykładzie użyjemy BlobCheckpointStore elementu z @azure/eventhubs-checkpointstore-blob pakietu, który implementuje wymagane operacje odczytu/zapisu w trwałym magazynie przy użyciu Azure Blob Storage.

Metoda subscribe pobiera wywołania zwrotne do przetwarzania zdarzeń w miarę ich odbierania z Azure Event Hubs. Aby zatrzymać odbieranie zdarzeń, można wywołać close() obiekt zwrócony przez metodę subscribe() .

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

Aby dowiedzieć się więcej, zobacz Równoważenie obciążenia partycji w wielu wystąpieniach aplikacji .

Korzystanie ze zdarzeń z jednej partycji

Zacznij od utworzenia wystąpienia klasy EventHubConsumerClient, a następnie wywołaj metodę subscribe() , aby rozpocząć korzystanie z zdarzeń. Przekaż identyfikator partycji, którą chcesz kierować do subscribe() metody, aby używać tylko z tej partycji.

W poniższym przykładzie używamy pierwszej partycji.

Metoda subscribe pobiera wywołania zwrotne do przetwarzania zdarzeń w miarę ich odbierania z Azure Event Hubs. Aby zatrzymać odbieranie zdarzeń, można wywołać close() obiekt zwrócony przez metodę subscribe() .

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

Korzystanie z usługi EventHubConsumerClient do pracy z usługą IotHub

Możesz również użyć EventHubConsumerClient funkcji do pracy z usługą IotHub. Jest to przydatne w przypadku odbierania danych telemetrycznych usługi IotHub z połączonej usługi EventHub. Skojarzone parametry połączenia nie będą miały oświadczeń wysyłania, dlatego wysyłanie zdarzeń nie jest możliwe.

• Zwróć uwagę, że parametry połączenia musi być punktem końcowym zgodnym z centrum zdarzeń (np. "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();

Rozwiązywanie problemów

Zależności amQP

Biblioteka usługi Event Hubs zależy od biblioteki rhea-promise do zarządzania połączeniami, wysyłania i odbierania zdarzeń za pośrednictwem protokołu AMQP .

Rejestrowanie

Zmienną środowiskową można ustawić tak AZURE_LOG_LEVEL , aby włączyć rejestrowanie na stderr:

export AZURE_LOG_LEVEL=verbose

Aby uzyskać bardziej szczegółowe instrukcje dotyczące włączania dzienników, zapoznaj się z dokumentami dotyczącymi pakietu @azure/rejestratora.

Możesz też ustawić zmienną środowiskową, DEBUG aby pobierać dzienniki podczas korzystania z tej biblioteki. Może to być przydatne, jeśli chcesz również emitować dzienniki z zależności rhea-promise i rhea jak również.

Uwaga: AZURE_LOG_LEVEL, jeśli ustawiono, ma pierwszeństwo przed debugowaniem. Nie należy określać żadnych azure bibliotek za pomocą debugowania podczas określania AZURE_LOG_LEVEL ani wywoływania polecenia setLogLevel.

• Pobieranie tylko dzienników debugowania na poziomie informacji z zestawu SDK usługi Event Hubs.

export DEBUG=azure:*:info

• Pobieranie dzienników debugowania z zestawu SDK usługi Event Hubs i biblioteki poziomu protokołu.

export DEBUG=azure*,rhea*

• Jeśli nie interesuje Cię wyświetlanie nieprzetworzonych danych zdarzeń (które zużywa dużą ilość konsoli/miejsca na dysku), możesz ustawić DEBUG zmienną środowiskową w następujący sposób:

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

• Jeśli interesuje Cię tylko błędy i ostrzeżenia zestawu SDK, możesz ustawić zmienną DEBUG środowiskową w następujący sposób:

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

Następne kroki

Więcej przykładów kodu

Zapoznaj się z katalogiem przykładów , aby uzyskać szczegółowe przykłady użycia tej biblioteki do wysyłania i odbierania zdarzeń do/z usługi Event Hubs.

Współtworzenie

Jeśli chcesz współtworzyć tę bibliotekę, przeczytaj przewodnik współtworzenia , aby dowiedzieć się więcej na temat sposobu kompilowania i testowania kodu.