Hub eventi di Azure libreria client per JavaScript - versione 5.12.0
Hub eventi di Azure è un servizio pubblica-sottoscrizione altamente scalabile che può inserire milioni di eventi al secondo e trasmetterli a più consumer. In questo modo è possibile elaborare e analizzare le grandi quantità di dati prodotti dai dispositivi e dalle applicazioni connesse. Per altre informazioni su Hub eventi di Azure, è possibile esaminare: Che cos'è Hub eventi?
La libreria client Hub eventi di Azure consente di inviare e ricevere eventi nell'applicazione Node.js.
Collegamenti principali:
- Codice sorgente
- Pacchetto (npm)
- Documentazione di riferimento sulle API
- Documentazione del prodotto
- Esempi
NOTA: se si usa la versione 2.1.0 o versione inferiore e si vuole eseguire la migrazione alla versione più recente di questo pacchetto, vedere la guida alla migrazione per passare da EventHubs V2 a EventHubs V5
Gli esempi per v2 e la documentazione sono ancora disponibili qui:
Codice sorgente per v2.1.0 | Pacchetto per v2.1.0 (npm) | Esempi per v2.1.0
Introduzione
Installare il pacchetto
Installare la libreria client di Hub eventi di Azure tramite npm
npm install @azure/event-hubs
Ambienti attualmente supportati
- Versioni LTS di Node.js
- Ultime versioni di Safari, Chrome, Edge e Firefox.
Per altre informazioni, vedere i criteri di supporto.
Prerequisiti
- Una sottoscrizione di Azure
- Spazio dei nomi di Hub eventi
Configurare TypeScript
Gli utenti TypeScript devono avere installate definizioni di tipo Node:
npm install @types/node
È anche necessario abilitare compilerOptions.allowSyntheticDefaultImports
nel tsconfig.json. Si noti che se è stato abilitato , allowSyntheticDefaultImports
è abilitato compilerOptions.esModuleInterop
per impostazione predefinita. Per altre informazioni, vedere Il manuale delle opzioni del compilatore di TypeScript .
JavaScript Bundle
Per usare questa libreria client nel browser, è prima necessario usare un bundler. Per informazioni dettagliate su come eseguire questa operazione, vedere la documentazione di raggruppamento.
Oltre a quanto descritto in questa libreria, questa libreria necessita anche di polifill aggiuntivi per i moduli predefiniti NodeJS seguenti per funzionare correttamente nei browser:
buffer
os
path
process
Raggruppamento con Webpack
Se si usa Webpack v5, è possibile installare le dipendenze di sviluppo seguenti
npm install --save-dev os-browserify path-browserify
aggiungere quindi quanto segue nel 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"),
+ },
},
Raggruppamento con rollup
Se si usa rollup bundler, installare le dipendenze di sviluppo seguenti
npm install --save-dev @rollup/plugin-commonjs @rollup/plugin-inject @rollup/plugin-node-resolve
Includere quindi quanto segue nel 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"],
+ }),
]
};
Per altre informazioni sull'uso di polifill, consultare la documentazione del bundler preferito.
supporto React Native
Analogamente ai browser, React Native non supporta alcune API JavaScript usate da questa libreria SDK, quindi è necessario fornire polifill per loro. Per altre informazioni, vedere l'esempio di Messaggistica React Native con Expo.
Autenticare il client
L'interazione con Hub eventi inizia con un'istanza della classe EventHubConsumerClient o un'istanza della classe EventHubProducerClient. Esistono overload del costruttore per supportare diversi modi per creare istanze di queste classi, come illustrato di seguito:
Usare stringa di connessione per lo spazio dei nomi hub eventi
Uno degli overload del costruttore accetta un stringa di connessione del nome del modulo Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;
e dell'entità nell'istanza di Hub eventi. È possibile creare un gruppo di consumer e ottenere il stringa di connessione e il nome dell'entità dal portale di Azure.
const { EventHubProducerClient, EventHubConsumerClient } = require("@azure/event-hubs");
const producerClient = new EventHubProducerClient("my-connection-string", "my-event-hub");
const consumerClient = new EventHubConsumerClient(
"my-consumer-group",
"my-connection-string",
"my-event-hub"
);
Usare stringa di connessione per i criteri nell'hub eventi
Un altro overload del costruttore accetta il stringa di connessione corrispondente ai criteri di accesso condiviso definiti direttamente nell'istanza di Hub eventi (e non nello spazio dei nomi Hub eventi).
Questo stringa di connessione sarà del modulo Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name
.
La differenza chiave nel formato stringa di connessione dell'overload del costruttore precedente è .;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"
);
Usare lo spazio dei nomi di Hub eventi e l'identità di Azure
Questo overload del costruttore accetta il nome host e il nome dell'entità dell'istanza di Hub eventi e le credenziali che implementano l'interfaccia TokenCredential. In questo modo è possibile eseguire l'autenticazione usando un'entità Azure Active Directory. Esistono implementazioni dell'interfaccia TokenCredential
disponibili nel pacchetto @azure/identity . Il nome host è del formato <yournamespace>.servicebus.windows.net
. Quando si usa Azure Active Directory, l'entità deve essere assegnata a un ruolo che consente l'accesso a Hub eventi, ad esempio il ruolo Hub eventi di Azure proprietario dei dati. Per altre informazioni sull'uso dell'autorizzazione di Azure Active Directory con Hub eventi, vedere la documentazione associata.
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
);
Concetti chiave
Un produttore di Hub eventi è un'origine di dati di telemetria, informazioni di diagnostica, log di utilizzo o altri dati di log, come parte di una soluzione di dispositivo incorporata, un'applicazione per dispositivi mobili, un titolo di gioco in esecuzione in una console o in un altro dispositivo, una soluzione aziendale basata su client o server o un sito Web.
Un consumer dell'hub eventi raccoglie tali informazioni dall'hub eventi e lo elabora. L'elaborazione può comportare aggregazioni, calcoli complessi e applicazione di filtri. L'elaborazione può anche comportare la distribuzione o l'archiviazione delle informazioni in modo non elaborato o trasformato. I consumer di Hub eventi sono spesso parti di infrastruttura di piattaforma affidabili e su larga scala con funzionalità di analisi predefinite, ad esempio Analisi di flusso di Azure, Apache Spark o Apache Storm.
Una partizione è una sequenza ordinata di eventi che viene mantenuta in un hub eventi. Le partizioni sono un mezzo di organizzazione dei dati associato al parallelismo richiesto dai consumer di eventi. Hub eventi di Azure fornisce il flusso dei messaggi tramite un modello di consumer partizionato in cui ogni consumer legge solo un subset specifico, o partizione, del flusso di messaggi. Man mano che arrivano, i nuovi eventi vengono aggiunti alla fine di questa sequenza. Il numero di partizioni viene specificato al momento della creazione di un hub eventi e non può essere modificato.
Un gruppo di consumer è una visualizzazione di un intero hub eventi. I gruppi di consumer consentono a più applicazioni consumer di avere ognuna una vista separata del flusso di eventi e di leggere il flusso in modo indipendente, in base al proprio ritmo e dalla propria posizione. In una partizione possono esistere al massimo cinque lettori simultanei per gruppo di consumer. È tuttavia consigliabile che sia presente un solo consumer attivo in una specifica partizione e associazione di gruppi di consumer. Ogni lettore attivo riceve tutti gli eventi dalla partizione; Se nella stessa partizione sono presenti più lettori, riceveranno eventi duplicati.
Per altri concetti e discussioni più approfondite, vedere: Funzionalità di Hub eventi
Indicazioni sui tentativi
L'oggetto EventHubConsumerClient
e EventHubProducerClient
accettare options
dove è possibile impostare l'oggetto retryOptions
che consente di ottimizzare il modo in cui l'SDK gestisce gli errori temporanei.
Esempi di errori temporanei includono problemi di rete o servizio temporanei.
Tentativi durante l'utilizzo di eventi
Se si verifica un errore temporaneo (ad esempio un problema di rete temporaneo) mentre l'SDK riceve eventi, riprova a ricevere eventi in base alle opzioni di ripetizione dei tentativi passate all'oggetto EventHubConsumerClient
.
Se vengono esauriti i tentativi massimi, verrà richiamata la processError
funzione.
È possibile usare le impostazioni di ripetizione dei tentativi per controllare la velocità con cui vengono informati sui problemi temporanei, ad esempio un problema di connessione di rete.
Ad esempio, se è necessario sapere quando si verifica un problema di rete immediatamente, è possibile ridurre i valori per maxRetries
e retryDelayInMs
.
Dopo aver eseguito la processError
funzione, il client continua a ricevere eventi dalla partizione finché l'errore è stato riprovabile. In caso contrario, il client richiama la funzione fornita dall'utente processClose
.
Questa funzione viene richiamata anche quando si arresta la sottoscrizione o quando il client smette di leggere gli eventi dalla partizione corrente a causa della raccolta da un'altra istanza dell'applicazione come parte del bilanciamento del carico.
La funzione offre l'opportunità processClose
di aggiornare i checkpoint se necessario.
Dopo aver eseguito processClose
, il client (o nel caso del bilanciamento del carico, un client da un'altra istanza dell'applicazione) richiama la funzione fornita processInitialize
dall'utente per riprendere gli eventi di lettura dall'ultimo checkpoint aggiornato per la stessa partizione.
Se si desidera interrompere il tentativo di lettura degli eventi, è necessario chiamare close()
il subscription
metodo restituito dal subscribe
metodo .
Esempio
Le sezioni seguenti forniscono frammenti di codice che coprono alcune delle attività comuni usando Hub eventi di Azure
- Ispezionare un hub eventi
- Pubblicare eventi in un hub eventi
- Usare gli eventi da un hub eventi
- Usare EventHubConsumerClient per usare IotHub
Ispezionare un hub eventi
Molte operazioni dell'hub eventi vengono eseguite nell'ambito di una partizione specifica.
Poiché le partizioni sono di proprietà dell'hub eventi, i nomi vengono assegnati al momento della creazione.
Per comprendere quali partizioni sono disponibili, eseguire una query su Hub eventi usando uno dei due client disponibili: EventHubProducerClient
o EventHubConsumerClient
Nell'esempio seguente viene usato un EventHubProducerClient
oggetto .
const { EventHubProducerClient } = require("@azure/event-hubs");
async function main() {
const client = new EventHubProducerClient("connectionString", "eventHubName");
const partitionIds = await client.getPartitionIds();
await client.close();
}
main();
Pubblicare eventi in un hub eventi
Per pubblicare eventi, è necessario creare un oggetto EventHubProducerClient
. Mentre nell'esempio seguente viene illustrato un modo per creare il client, vedere la sezione Autenticare il client per apprendere altri modi per creare un'istanza del client.
È possibile pubblicare eventi in una partizione specifica o consentire al servizio Hub eventi di decidere quali eventi di partizione devono essere pubblicati. È consigliabile usare il routing automatico quando la pubblicazione di eventi deve essere a disponibilità elevata o quando i dati degli eventi devono essere distribuiti uniformemente tra le partizioni. Nell'esempio seguente si sfrutta il routing automatico.
- Create un
EventDataBatch
oggetto usando createBatch - Aggiungere eventi al batch usando il metodo tryAdd . È possibile eseguire questa operazione fino al raggiungimento del limite massimo di dimensioni del batch o fino a quando non si aggiunge il numero di eventi che si è piaciuti. Questo metodo restituirà
false
per indicare che non è possibile aggiungere più eventi al batch a causa della dimensione massima del batch raggiunta. - Inviare il batch di eventi usando il metodo sendBatch .
Nell'esempio seguente si tenta di inviare 10 eventi a Hub eventi di Azure.
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();
Esistono opzioni che è possibile passare in fasi diverse per controllare il processo di invio di eventi a Hub eventi di Azure.
- Il
EventHubProducerClient
costruttore accetta un parametro facoltativo di tipoEventHubClientOptions
che è possibile usare per specificare opzioni come il numero di tentativi. - Il
createBatch
metodo accetta un parametro facoltativo di tipoCreateBatchOptions
che è possibile usare per speicificare le dimensioni massime del batch supportate dal batch in fase di creazione. - Il
sendBatch
metodo accetta un parametro facoltativo di tipoSendBatchOptions
che è possibile usare per specificareabortSignal
per annullare l'operazione corrente. - Se si vuole inviare a una partizione specifica, un overload del
sendBatch
metodo consente di passare l'ID della partizione a cui inviare eventi. L'esempio Di controllo di un hub eventi precedente illustra come recuperare gli ID partizioni disponibili.
Nota: quando si usa Azure Stream Analytics, anche il corpo dell'evento inviato deve essere un oggetto JSON.
ad esempio body: { "message": "Hello World" }
Usare gli eventi da un hub eventi
Per utilizzare gli eventi da un'istanza di Hub eventi, è anche necessario conoscere il gruppo di consumer che si vuole assegnare. Dopo aver appreso questo problema, è possibile creare un Oggetto EventHubConsumerClient. Mentre nell'esempio seguente viene illustrato un modo per creare il client, vedere la sezione Autenticare il client per apprendere altri modi per creare un'istanza del client.
Il subscribe
metodo nel client ha overload che, combinati con il costruttore, può soddisfare diversi modi per utilizzare gli eventi:
- Usare gli eventi in un singolo processo
- Usare gli eventi con carico bilanciato tra più processi
- Usare gli eventi da una singola partizione
Il subscribe
metodo accetta un parametro facoltativo di tipo SubscriptionOptions
che è possibile usare per specificare opzioni come maxBatchSize (numero di eventi da attendere) e maxWaitTimeInSeconds (quantità di tempo per attendere l'arrivo degli eventi maxBatchSize).
Usare gli eventi in un singolo processo
Iniziare creando un'istanza EventHubConsumerClient
di e quindi chiamare il subscribe()
metodo su di esso per iniziare a usare gli eventi.
Il subscribe
metodo accetta i callback per elaborare gli eventi quando vengono ricevuti da Hub eventi di Azure.
Per interrompere la ricezione di eventi, è possibile chiamare close()
l'oggetto subscribe()
restituito dal metodo .
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();
Usare gli eventi con carico bilanciato tra più processi
Hub eventi di Azure è in grado di gestire milioni di eventi al secondo. Per ridimensionare l'applicazione di elaborazione, è possibile eseguire più istanze dell'applicazione e bilanciare il carico tra di loro.
Iniziare creando un'istanza dell'oggetto EventHubConsumerClient
usando uno degli overload del costruttore che accettano un CheckpointStore
oggetto e quindi chiamare il subscribe()
metodo per iniziare a usare gli eventi. L'archivio checkpoint consente ai sottoscrittori all'interno di un gruppo di consumer di coordinare l'elaborazione tra più istanze dell'applicazione.
In questo esempio si userà l'oggetto BlobCheckpointStore
@azure/eventhubs-checkpointstore-blob
dal pacchetto che implementa la lettura/scrittura necessaria in un archivio durevole usando Archiviazione BLOB di Azure.
Il subscribe
metodo accetta i callback per elaborare gli eventi quando vengono ricevuti da Hub eventi di Azure.
Per interrompere la ricezione di eventi, è possibile chiamare close()
l'oggetto subscribe()
restituito dal metodo .
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();
Per altre informazioni, vedere Bilanciare il carico di partizione in più istanze dell'applicazione .
Usare gli eventi da una singola partizione
Iniziare creando un'istanza EventHubConsumerClient
di e quindi chiamare il subscribe()
metodo su di esso per iniziare a usare gli eventi. Passare l'ID della partizione di cui si vuole eseguire la destinazione al subscribe()
metodo da utilizzare solo da tale partizione.
Nell'esempio seguente viene usata la prima partizione.
Il subscribe
metodo accetta i callback per elaborare gli eventi quando vengono ricevuti da Hub eventi di Azure.
Per interrompere la ricezione di eventi, è possibile chiamare close()
l'oggetto subscribe()
restituito dal metodo .
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();
Usare EventHubConsumerClient per usare IotHub
È anche possibile usare EventHubConsumerClient
per usare IotHub. Ciò è utile per ricevere i dati di telemetria di IotHub da EventHub collegato.
Il stringa di connessione associato non avrà attestazioni, quindi l'invio di eventi non è possibile.
- Si noti che la stringa di connessione deve essere per un endpoint compatibile con hub eventi ,ad esempio "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();
Risoluzione dei problemi
Dipendenze AMQP
La libreria hub eventi dipende dalla libreria rhea-promise per la gestione delle connessioni, l'invio e la ricezione di eventi tramite il protocollo AMQP .
Registrazione
È possibile impostare la variabile di ambiente per abilitare la AZURE_LOG_LEVEL
registrazione su stderr
:
export AZURE_LOG_LEVEL=verbose
Per istruzioni più dettagliate su come abilitare i log, è possibile esaminare la documentazione del pacchetto @azure/logger.
In alternativa, è possibile impostare la DEBUG
variabile di ambiente per ottenere i log quando si usa questa libreria.
Ciò può essere utile anche se si desidera generare log dalle dipendenze rhea-promise
e rhea
anche.
Nota: AZURE_LOG_LEVEL, se impostato, ha la precedenza su DEBUG.
Non specificare librerie tramite DEBUG quando si specificano azure
anche AZURE_LOG_LEVEL o chiamando setLogLevel.
- Ottenere solo i log di debug a livello di info dall'SDK di Hub eventi.
export DEBUG=azure:*:info
- Recupero dei log di debug dall'SDK di Hub eventi e dalla libreria a livello di protocollo.
export DEBUG=azure*,rhea*
- Se non si è interessati a visualizzare i dati dell'evento non elaborati (che utilizza una grande quantità di spazio console/disco) è possibile impostare la
DEBUG
variabile di ambiente come indicato di seguito:
export DEBUG=azure*,rhea*,-rhea:raw,-rhea:message
- Se si è interessati solo agli errori e agli avvisi dell'SDK, è possibile impostare la
DEBUG
variabile di ambiente come indicato di seguito:
export DEBUG=azure:*:(error|warning),rhea-promise:error,rhea:events,rhea:frames,rhea:io,rhea:flow
Passaggi successivi
Altro codice di esempio
Esaminare la directory degli esempi per esempi di come usare questa libreria per inviare e ricevere eventi da/a Hub eventi.
Contributo
Per contribuire a questa libreria, leggere la guida ai contributi per altre informazioni su come compilare e testare il codice.
Azure SDK for JavaScript