Partager via

intégration de .NET AspireAzure Event Hubs

  • Article

Azure Event Hubs est un service de streaming de données natif dans le cloud qui peut diffuser des millions d’événements par seconde, avec une faible latence, de n’importe quelle source à n’importe quelle destination. L’intégration .NET AspireAzure Event Hubs vous permet de vous connecter à des instances Azure Event Hubs à partir de vos applications .NET.

Intégration de l’hébergement

Le modèle d'intégration d'hébergement .NET.NET AspireAzure Event Hubs modélise les différentes ressources Event Hub comme les types suivants :

Pour accéder à ces types et à leurs API afin de les exprimer dans votre projet d'hôte d'application , installez le package NuGet 📦Aspire.Hosting.Azure.EventHubs :

dotnet add package Aspire.Hosting.Azure.EventHubs

Pour plus d’informations, consultez dotnet add package ou Gérer les dépendances de package dans les applications .NET.

Ajouter une ressource Azure Event Hubs

Pour ajouter un AzureEventHubsResource à votre projet hôte d’application, appelez la méthode AddAzureEventHubs en fournissant un nom, puis appelez AddHub:

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs");
eventHubs.AddHub("messages");

builder.AddProject<Projects.ExampleService>()
       .WithReference(eventHubs);

// After adding all resources, run the app...

Lorsque vous ajoutez une ressource Azure Event Hubs à l’hôte de l’application, elle expose d’autres API utiles pour ajouter des ressources Event Hub, des groupes de consommateurs, une configuration d’approvisionnement explicite rapide et permet l’utilisation de l’émulateur de Azure Event Hubs. Le code précédent ajoute une ressource Azure Event Hubs nommée event-hubs et un hub d’événements nommé messages au projet hôte de l’application. La méthode WithReference transmet les informations de connexion au projet ExampleService.

Important

Lorsque vous appelez AddAzureEventHubs, il appelle implicitement AddAzureProvisioning(IDistributedApplicationBuilder), ce qui ajoute la prise en charge de la génération dynamique de ressources Azure pendant le démarrage de l’application. L’application doit configurer l’abonnement et l’emplacement appropriés. Pour plus d’informations, consultez Provisionnement local : configuration

Provisionnement généré Bicep

Si vous êtes nouveau dans le domaine de Bicep, sachez qu'il s'agit d'un langage spécifique au domaine pour définir les ressources Azure. Avec .NET.NET Aspire, vous n’avez pas besoin d’écrire Bicep manuellement, au lieu de cela, les API d’approvisionnement génèrent Bicep pour vous. Lorsque vous publiez votre application, le fichier Bicep généré est livré en même temps que le fichier manifeste. Lorsque vous ajoutez une ressource Azure Event Hubs, bicep suivant est généré :

@description('The location for the resource(s) to be deployed.')
param location string = resourceGroup().location

param sku string = 'Standard'

param principalType string

param principalId string

resource event_hubs 'Microsoft.EventHub/namespaces@2024-01-01' = {
  name: take('event_hubs-${uniqueString(resourceGroup().id)}', 256)
  location: location
  sku: {
    name: sku
  }
  tags: {
    'aspire-resource-name': 'event-hubs'
  }
}

resource event_hubs_AzureEventHubsDataOwner 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(event_hubs.id, principalId, subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'f526a384-b230-433a-b45c-95f59c4a2dec'))
  properties: {
    principalId: principalId
    roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'f526a384-b230-433a-b45c-95f59c4a2dec')
    principalType: principalType
  }
  scope: event_hubs
}

resource messages 'Microsoft.EventHub/namespaces/eventhubs@2024-01-01' = {
  name: 'messages'
  parent: event_hubs
}

output eventHubsEndpoint string = event_hubs.properties.serviceBusEndpoint

Bicep précédent est un module qui provisionne une ressource Azure Event Hubs avec les valeurs par défaut suivantes :

  • location: emplacement du groupe de ressources.
  • sku: La référence SKU de la ressource Event Hubs est, par défaut, Standard.
  • principalId: ID principal de la ressource Event Hubs.
  • principalType: type principal de la ressource Event Hubs.
  • event_hubs: La ressource du namespace Event Hubs.
  • event_hubs_AzureEventHubsDataOwner: Le propriétaire de la ressource Event Hubs, basé sur le rôle intégré Azure Event Hubs Data Owner. Pour plus d’informations, consultez Azure Event Hubs propriétaire des données.
  • messages: ressource Event Hub.
  • eventHubsEndpoint: point de terminaison de la ressource Event Hubs.

Bicep généré est un point de départ et peut être personnalisé pour répondre à vos besoins spécifiques.

Personnaliser l’infrastructure d’approvisionnement

Toutes les ressources .NET AspireAzure sont des sous-classes du type AzureProvisioningResource. Ce type permet de personnaliser le Bicep généré en fournissant une API fluente pour configurer les ressources Azure à l’aide de l’API ConfigureInfrastructure<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure>). Par exemple, vous pouvez configurer le kind, consistencyPolicy, locations, etc. L’exemple suivant montre comment personnaliser la ressource AzureAzure Cosmos DB :

builder.AddAzureEventHubs("event-hubs")
    .ConfigureInfrastructure(infra =>
    {
        var eventHubs = infra.GetProvisionableResources()
                             .OfType<EventHubsNamespace>()
                             .Single();

        eventHubs.Sku = new EventHubsSku()
        {
            Name = EventHubsSkuName.Premium,
            Tier = EventHubsSkuTier.Premium,
            Capacity = 7,
        };
        eventHubs.PublicNetworkAccess = EventHubsPublicNetworkAccess.SecuredByPerimeter;
        eventHubs.Tags.Add("ExampleKey", "Example value");
    });

Code précédent :

Il existe de nombreuses autres options de configuration disponibles pour personnaliser la ressource de ressource Event Hubs. Pour plus d’informations, consultez Azure.Provisioning.PostgreSql. Pour plus d’informations, consultez Azure.Provisioningde personnalisation.

Se connecter à un espace de noms Azure Event Hubs existant

Vous pouvez avoir un espace de noms Azure Event Hubs existant auquel vous souhaitez vous connecter. Au lieu de représenter une nouvelle ressource Azure Event Hubs, vous pouvez ajouter une chaîne de connexion à l’hôte de l’application. Pour ajouter une connexion à un espace de noms Azure Event Hubs existant, appelez la méthode AddConnectionString :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddConnectionString("event-hubs");

builder.AddProject<Projects.WebApplication>("web")
       .WithReference(eventHubs);

// After adding all resources, run the app...

Remarque

Les chaînes de connexion sont utilisées pour représenter un large éventail d’informations de connexion, notamment les connexions de base de données, les répartiteurs de messages, les URI de point de terminaison et d’autres services. Dans .NET.NET Aspire nomenclature, le terme « chaîne de connexion » est utilisé pour représenter n’importe quel type d’informations de connexion.

La chaîne de connexion est configurée dans la configuration de l’hôte d’application, généralement sous secrets utilisateur, sous la section ConnectionStrings. L’hôte de l’application injecte cette chaîne de connexion en tant que variable d’environnement dans toutes les ressources dépendantes, par exemple :

{
  "ConnectionStrings": {
    "event-hubs": "{your_namespace}.servicebus.windows.net"
  }
}

La ressource dépendante peut accéder à la chaîne de connexion injectée en appelant la méthode GetConnectionString et en passant le nom de connexion en tant que paramètre, dans ce cas "event-hubs". L’API GetConnectionString est abrégée pour IConfiguration.GetSection("ConnectionStrings")[name].

Ajouter un groupe de consommateurs Event Hub

Pour ajouter un groupe de consommateurs, enchaînez un appel vers l'API AddConsumerGroup à partir de IResourceBuilder<AzureEventHubsResource> :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs");
var messages = eventHubs.AddHub("messages");
messages.AddConsumerGroup("messagesConsumer");

builder.AddProject<Projects.ExampleService>()
       .WithReference(eventHubs);

// After adding all resources, run the app...

Lorsque vous appelez AddConsumerGroup, il configure votre ressource Event Hub messages pour qu’un groupe de consommateurs soit créé et soit appelé messagesConsumer. Le groupe de consommateurs est créé dans l’espace de noms Azure Event Hubs représenté par le AzureEventHubsResource que vous avez ajouté précédemment. Pour plus d’informations, consultez Azure Event Hubs: Groupes de consommateurs.

Ajouter la ressource d’émulateur Azure Event Hubs

L’intégration d’hébergement .NET AspireAzure Event Hubs prend en charge l’exécution de la ressource Event Hubs en tant qu’émulateur localement, en fonction de l’image conteneur mcr.microsoft.com/azure-messaging/eventhubs-emulator/latest. Cela est bénéfique pour les situations où vous souhaitez exécuter la ressource Event Hubs localement à des fins de développement et de test, en évitant la nécessité de provisionner une ressource Azure ou de vous connecter à un serveur Azure Event Hubs existant.

Pour exécuter la ressource Event Hubs en tant qu’émulateur, appelez la méthode RunAsEmulator :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs")
                       .RunAsEmulator();

eventHubs.AddHub("messages");

var exampleProject = builder.AddProject<Projects.ExampleProject>()
                            .WithReference(eventHubs);

// After adding all resources, run the app...

Le code précédent configure une ressource Azure Event Hubs pour qu’elle s’exécute localement dans un conteneur. Pour plus d’informations, consultez Azure Event Hubs émulateur.

Configurer le conteneur d’émulateur Event Hubs

Il existe différentes configurations disponibles pour les ressources de conteneur, par exemple, vous pouvez configurer les ports du conteneur, les montages de liaison de données, les volumes de données, ou bien fournir une configuration holistique JSON qui remplace tout.

Configurer le port hôte du conteneur de l’émulateur Event Hubs

Par défaut, le conteneur de l’émulateur Event Hubs lorsqu’il est configuré par .NET.NET Aspireexpose les points de terminaison suivants :

Point de terminaison Image Port de conteneur Port hôte
emulator mcr.microsoft.com/azure-messaging/eventhubs-emulator/latest 5672 dynamique

Le port sur lequel il écoute est dynamique par défaut. Au démarrage du conteneur, le port est mappé à un port aléatoire sur l’ordinateur hôte. Pour configurer le port du point de terminaison, enchaînez les appels avec le générateur de ressources de conteneur fourni par la méthode RunAsEmulator, puis le WithHostPort(IResourceBuilder<AzureEventHubsEmulatorResource>, Nullable<Int32>), comme illustré dans l’exemple suivant :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs")
                       .RunAsEmulator(emulator =>
                       {
                           emulator.WithHostPort(7777);
                       });

eventHubs.AddHub("messages");

builder.AddProject<Projects.ExampleService>()
       .WithReference(eventHubs);

// After adding all resources, run the app...

Le code précédent configure le point de terminaison emulator existant de l’émulateur d’événements Azure pour écouter le port 7777. Le port de l’émulateur d’événements Azure est mappé au port hôte, comme indiqué dans le tableau suivant :

Nom du point de terminaison Mappage de ports (container:host)
emulator 5672:7777
Ajouter un émulateur Event Hubs avec un volume de données

Pour ajouter un volume de données à la ressource de l’émulateur Event Hubs, appelez la méthode WithDataVolume sur la ressource de l’émulateur Event Hubs :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs")
                       .RunAsEmulator(emulator =>
                       {
                           emulator.WithDataVolume();
                       });

eventHubs.AddHub("messages");

builder.AddProject<Projects.ExampleService>()
       .WithReference(eventHubs);

// After adding all resources, run the app...

Le volume de données est utilisé pour conserver les données de l’émulateur Event Hubs en dehors du cycle de vie de son conteneur. Le volume de données est monté sur le répertoire /data dans le conteneur. Un nom est généré au hasard, sauf si vous fournissez une valeur pour le paramètre name. Pour plus d’informations sur les volumes de données et sur la raison pour laquelle ils sont préférés par rapport aux montages de liaison , consultez la documentation Docker : Volumes.

Ajouter l’émulateur Event Hubs avec montage de liaison de données

Ajoutez un montage de liaison au conteneur de l’émulateur Event Hubs en enchaînant un appel à l’API WithDataBindMount, comme illustré dans l’exemple suivant :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs")
                       .RunAsEmulator(emulator =>
                       {
                           emulator.WithDataBindMount("/path/to/data");
                       });

eventHubs.AddHub("messages");

builder.AddProject<Projects.ExampleService>()
       .WithReference(eventHubs);

// After adding all resources, run the app...

Important

Les montages de liaison de données ont des fonctionnalités limitées par rapport aux volumes , qui offrent de meilleures performances, une meilleure portabilité et une plus grande sécurité, ce qui les rend plus adaptés aux environnements de production. Toutefois, les montages par lien autorisent l’accès direct et la modification des fichiers sur le système hôte, idéal pour le développement et les tests où des modifications en temps réel sont nécessaires.

Les montages de liaison de données s’appuient sur le système de fichiers de l’ordinateur hôte pour conserver les données de ressources de l’émulateur Azure Event Hubs entre les redémarrages de conteneur. Le montage de liaison de données est monté sur le chemin d’accès /path/to/data sur l’ordinateur hôte du conteneur. Pour plus d’informations sur les montages de liaison de données, consultez les documents Docker : Montages de liaison.

Configurer la configuration du conteneur d’émulateur Event Hubs JSON

Le conteneur de l’émulateur Event Hubs s’exécute avec un fichier de config.json par défaut. Vous pouvez remplacer entièrement ce fichier ou mettre à jour la configuration JSON avec une représentation JsonNode de la configuration.

Pour fournir un fichier de configuration JSON personnalisé, appelez la méthode WithConfigurationFile(IResourceBuilder<AzureEventHubsEmulatorResource>, String) :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs")
                       .RunAsEmulator(emulator =>
                       {
                           emulator.WithConfigurationFile("./messaging/custom-config.json");
                       });

eventHubs.AddHub("messages");

builder.AddProject<Projects.ExampleService>()
       .WithReference(eventHubs);

// After adding all resources, run the app...

Le code précédent configure le conteneur de l’émulateur Event Hubs pour utiliser un fichier de configuration de JSON personnalisé situé à ./messaging/custom-config.json. Cela sera monté sur le chemin /Eventhubs_Emulator/ConfigFiles/Config.json du conteneur, en tant que fichier en lecture seule. Pour remplacer plutôt des propriétés spécifiques dans la configuration par défaut, appelez la méthode WithConfiguration(IResourceBuilder<AzureEventHubsEmulatorResource>, Action<JsonNode>) :

var builder = DistributedApplication.CreateBuilder(args);

var eventHubs = builder.AddAzureEventHubs("event-hubs")
                       .RunAsEmulator(emulator =>
                       {
                           emulator.WithConfiguration(
                               (JsonNode configuration) =>
                               {
                                   var userConfig = configuration["UserConfig"];
                                   var ns = userConfig["NamespaceConfig"][0];
                                   var firstEntity = ns["Entities"][0];
                                   
                                   firstEntity["PartitionCount"] = 5;
                               });
                       });

eventHubs.AddHub("messages");

builder.AddProject<Projects.ExampleService>()
       .WithReference(eventHubs);

// After adding all resources, run the app...

Le code précédent récupère le nœud UserConfig de la configuration par défaut. Il met ensuite à jour le PartitionCount de la première entité en un 5.

Vérifications de l’intégrité des intégrations d'hébergement

L’intégration d’hébergement Azure Event Hubs ajoute automatiquement un contrôle d’intégrité pour la ressource Event Hubs. La vérification de l'état de santé vérifie que Event Hubs est en cours d’exécution et qu’une connexion peut être établie avec celui-ci.

L’intégration de l’hébergement s’appuie sur les 📦 AspNetCore.HealthChecks.Azure.Messaging.EventHubs paquet NuGet.

Intégration de Client

Pour commencer à utiliser l'intégration du client .NET AspireAzure Event Hubs, installez le package NuGet 📦Aspire.Azure.Messaging.EventHubs dans le projet consommateur, c'est-à-dire le projet de l'application qui utilise le client Event Hubs.

dotnet add package Aspire.Azure.Messaging.EventHubs

Types de clients Event Hubs pris en charge

Les clients Event Hub suivants sont pris en charge par la bibliothèque, ainsi que leurs options et classes de paramètres correspondantes :

type de client Azure classe options Azure classe de paramètres .NET.NET Aspire
EventHubProducerClient EventHubProducerClientOptions AzureMessagingEventHubsProducerSettings
EventHubBufferedProducerClient EventHubBufferedProducerClientOptions AzureMessagingEventHubsBufferedProducerSettings
EventHubConsumerClient EventHubConsumerClientOptions AzureMessagingEventHubsConsumerSettings
EventProcessorClient EventProcessorClientOptions AzureMessagingEventHubsProcessorSettings
PartitionReceiver PartitionReceiverOptions AzureMessagingEventHubsPartitionReceiverSettings

Les types de clients proviennent du kit SDK Azure pour .NET, comme les classes d’options correspondantes. Les classes de paramètres sont fournies par l'.NET.NET Aspire. Les classes de paramètres sont utilisées pour configurer les instances clientes.

Ajouter un client de producteur Event Hubs

Dans le fichier Program.cs de votre projet client-consommateur, appelez la méthode d’extension AddAzureEventHubProducerClient sur un(e) IHostApplicationBuilder pour enregistrer un(e) EventHubProducerClient à utiliser via le conteneur d’injection de dépendances. La méthode prend un paramètre de nom de connexion.

builder.AddAzureEventHubProducerClient(connectionName: "event-hubs");

Conseil / Astuce

Le paramètre connectionName doit correspondre au nom utilisé lors de l’ajout de la ressource Event Hubs dans le projet hôte d’application. Pour plus d’informations, consultez Ajouter une ressource Azure Event Hubs.

Après avoir ajouté le EventHubProducerClient, vous pouvez récupérer l’instance cliente à l’aide de l’injection de dépendances. Par exemple, pour récupérer votre objet source de données à partir d’un exemple de service, définissez-le en tant que paramètre de constructeur et vérifiez que la classe ExampleService est inscrite auprès du conteneur d’injection de dépendances :

public class ExampleService(EventHubProducerClient client)
{
    // Use client...
}

Pour plus d’informations, consultez :

API supplémentaires à prendre en compte

L’intégration du client fournit des API supplémentaires pour configurer des instances clientes. Lorsque vous devez inscrire un client Event Hubs, tenez compte des API suivantes :

type de client Azure API d’inscription
EventHubProducerClient AddAzureEventHubProducerClient
EventHubBufferedProducerClient AddAzureEventHubBufferedProducerClient
EventHubConsumerClient AddAzureEventHubConsumerClient
EventProcessorClient AddAzureEventProcessorClient
PartitionReceiver AddAzurePartitionReceiverClient

Toutes les API mentionnées ci-dessus incluent des paramètres facultatifs pour configurer les instances clientes.

Ajouter un client producteur Event Hubs avec clé

Il peut arriver que vous souhaitiez inscrire plusieurs instances de EventHubProducerClient avec différents noms de connexion. Pour enregistrer des clients Event Hubs par clé, appelez la méthode AddKeyedAzureServiceBusClient :

builder.AddKeyedAzureEventHubProducerClient(name: "messages");
builder.AddKeyedAzureEventHubProducerClient(name: "commands");

Important

Lorsque vous utilisez des services à clés, il est attendu que votre ressource Event Hubs ait configuré deux hubs nommés, un pour le messages et un pour le commands.

Vous pouvez ensuite récupérer les instances clientes à l’aide de l’injection de dépendances. Par exemple, pour récupérer les clients à partir d’un service :

public class ExampleService(
    [KeyedService("messages")] EventHubProducerClient messagesClient,
    [KeyedService("commands")] EventHubProducerClient commandsClient)
{
    // Use clients...
}

Pour plus d’informations, consultez les services clés dans de .NET.

API supplémentaires avec clé à prendre en compte

L’intégration du client fournit des API supplémentaires pour configurer des instances clientes à clé. Lorsque vous devez inscrire un client Event Hubs avec une clé, tenez compte des API suivantes :

type de client Azure API d’inscription
EventHubProducerClient AddKeyedAzureEventHubProducerClient
EventHubBufferedProducerClient AddKeyedAzureEventHubBufferedProducerClient
EventHubConsumerClient AddKeyedAzureEventHubConsumerClient
EventProcessorClient AddKeyedAzureEventProcessorClient
PartitionReceiver AddKeyedAzurePartitionReceiverClient

Toutes les API mentionnées ci-dessus incluent des paramètres facultatifs pour configurer les instances clientes.

Configuration

La bibliothèque .NET AspireAzure Event Hubs fournit plusieurs options pour configurer la connexion Azure Event Hubs en fonction des exigences et des conventions de votre projet. Soit un FullyQualifiedNamespace, soit un ConnectionString est obligatoire.

Utiliser une chaîne de connexion

Lorsque vous utilisez une chaîne de connexion à partir de la section de configuration ConnectionStrings, indiquez le nom de la chaîne de connexion lors de l’appel de builder.AddAzureEventHubProducerClient() et d’autres clients Event Hubs pris en charge. Dans cet exemple, la chaîne de connexion n’inclut pas la propriété EntityPath. Par conséquent, la propriété EventHubName doit être définie dans le rappel des paramètres :

builder.AddAzureEventHubProducerClient(
    "event-hubs",
    static settings =>
    {
        settings.EventHubName = "MyHub";
    });

Ensuite, les informations de connexion sont récupérées à partir de la section de configuration ConnectionStrings. Deux formats de connexion sont pris en charge :

Espace de noms complet (FQN)

L’approche recommandée consiste à utiliser un espace de noms complet, qui fonctionne avec la propriété AzureMessagingEventHubsSettings.Credential pour établir une connexion. Si aucune information d’identification n’est configurée, la DefaultAzureCredential est utilisée.

{
  "ConnectionStrings": {
    "event-hubs": "{your_namespace}.servicebus.windows.net"
  }
}

Chaîne de connexion

Vous pouvez également utiliser une chaîne de connexion :

{
  "ConnectionStrings": {
    "event-hubs": "Endpoint=sb://mynamespace.servicebus.windows.net/;SharedAccessKeyName=accesskeyname;SharedAccessKey=accesskey;EntityPath=MyHub"
  }
}

Utiliser des fournisseurs de configuration

La bibliothèque .NET AspireAzure Event Hubs prend en charge Microsoft.Extensions.Configuration. Il charge les AzureMessagingEventHubsSettings et les options associées, par exemple, EventProcessorClientOptions, à partir de la configuration à l’aide du préfixe de clé Aspire:Azure:Messaging:EventHubs:, suivi du nom du client spécifique en cours d’utilisation. Par exemple, considérez l'appsettings.json qui configure certaines des options d’un EventProcessorClient:

{
  "Aspire": {
    "Azure": {
      "Messaging": {
        "EventHubs": {
          "EventProcessorClient": {
            "EventHubName": "MyHub",
            "ClientOptions": {
              "Identifier": "PROCESSOR_ID"
            }
          }
        }
      }
    }
  }
}

Vous pouvez également configurer le type Options à l’aide du paramètre facultatif Action<IAzureClientBuilder<EventProcessorClient, EventProcessorClientOptions>> configureClientBuilder de la méthode AddAzureEventProcessorClient. Par exemple, pour définir l’ID client du processeur pour ce client :

builder.AddAzureEventProcessorClient(
    "event-hubs",
    configureClientBuilder: clientBuilder => clientBuilder.ConfigureOptions(
        options => options.Identifier = "PROCESSOR_ID"));

Observabilité et télémétrie

.NET .NET Aspire intégrations configurent automatiquement les configurations de journalisation, de suivi et de métriques, parfois appelées les piliers de l’observabilité. Pour plus d’informations sur l’observabilité de l’intégration et la télémétrie, consultez .NET.NET Aspire vue d’ensemble des intégrations. Selon le service de stockage, certaines intégrations peuvent uniquement prendre en charge certaines de ces fonctionnalités. Par exemple, certaines intégrations prennent en charge la journalisation et le suivi, mais pas les métriques. Les fonctionnalités de télémétrie peuvent également être désactivées à l’aide des techniques présentées dans la section Configuration.

Exploitation forestière

L’intégration .NET AspireAzure Event Hubs utilise les catégories de journaux suivantes :

  • Azure.Core
  • Azure.Identity

Traçage

L’intégration .NET AspireAzure Event Hubs émet les activités de suivi suivantes à l’aide de OpenTelemetry:

  • Azure.Messaging.EventHubs.*

Métriques

L’intégration .NET AspireAzure Event Hubs ne prend actuellement pas en charge les métriques par défaut en raison de limitations avec le SDK Azure pour .NET. Si ces modifications seront apportées à l’avenir, cette section sera mise à jour pour refléter ces modifications.

Voir aussi