Integration von .NET Aspire Azure Service Bus

2025-06-28

Enthält: Hosting-Integration —&— Client Integration

Azure Service Bus ist ein vollständig verwalteter Nachrichtenbroker für Unternehmen mit Nachrichtenwarteschlangen und Veröffentlichen/Abonnieren-Themen. Mit der .NET AspireAzure Service Bus-Integration können Sie eine Verbindung mit Azure Service Bus Instanzen aus .NET Anwendungen herstellen.

Integration von Hosting

Die .NET.NET AspireAzure Service Bus-Hosting-Integration modelliert die verschiedenen Service-Bus-Ressourcen als die folgenden Typen:

AzureServiceBusResource: Stellt eine Azure Service Bus Ressource dar.
AzureServiceBusQueueResource: Stellt eine Azure Service Bus-Warteschlangenressource dar.
AzureServiceBusSubscriptionResource: Stellt eine Azure Service Bus Abonnementressource dar.
AzureServiceBusTopicResource: Stellt eine Ressource zum Thema Azure Service Bus dar.
AzureServiceBusEmulatorResource: Stellt eine Azure Service Bus Emulatorressource dar.

Um auf diese Typen und APIs zuzugreifen und sie zu verwenden, fügen Sie das 📦Aspire.Hosting.Azure.ServiceBus-NuGet-Paket im App-Host-Projekt hinzu.

.NET CLI
PaketReferenz

dotnet add package Aspire.Hosting.Azure.ServiceBus

<PackageReference Include="Aspire.Hosting.Azure.ServiceBus"
                  Version="*" />

Weitere Informationen finden Sie unter dotnet add package oder Verwalten von Paketabhängigkeiten in .NET-Anwendungen.

Ressource Azure Service Bus hinzufügen

Rufen Sie in Ihrem App-Hostprojekt AddAzureServiceBus auf, um einen Azure Service Bus Ressourcen-Generator hinzuzufügen und zurückzugeben.

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging");

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

Wenn Sie dem App-Host eine AzureServiceBusResource hinzufügen, werden andere nützliche APIs zum Hinzufügen von Warteschlangen und Themen verfügbar gemacht. Mit anderen Worten, Sie müssen eine AzureServiceBusResource hinzufügen, bevor Sie eine der anderen ServiceBus-Ressourcen hinzufügen.

Wichtig

Wenn Sie AddAzureServiceBusaufrufen, wird implizit AddAzureProvisioningaufgerufen, wodurch die Unterstützung für das dynamische Generieren von Azure-Ressourcen während des Anwendungsstarts hinzugefügt wird. Die App muss das entsprechende Abonnement und den entsprechenden Standort konfigurieren. Weitere Informationen finden Sie unter Konfiguration.

Durch Bereitstellung generierte Bicep-Datei

Wenn Sie neu bei Bicep sind, ist es eine domänenspezifische Sprache zum Definieren von Azure-Ressourcen. Mit .NET.NET Aspiremüssen Sie Bicep nicht manuell schreiben, sondern die Bereitstellungs-APIs generieren Bicep für Sie. Wenn Sie Ihre App veröffentlichen, wird die generierte Bicep-Datei zusammen mit der Manifestdatei ausgegeben. Wenn Sie eine Ressource vom Typ Azure Service Bus hinzufügen, wird das folgende Bicep generiert:

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

param sku string = 'Standard'

resource service_bus 'Microsoft.ServiceBus/namespaces@2024-01-01' = {
  name: take('servicebus-${uniqueString(resourceGroup().id)}', 50)
  location: location
  properties: {
    disableLocalAuth: true
  }
  sku: {
    name: sku
  }
  tags: {
    'aspire-resource-name': 'service-bus'
  }
}

output serviceBusEndpoint string = service_bus.properties.serviceBusEndpoint

output name string = service_bus.name

Das vorangehende Bicep ist ein Modul, das eine Azure Service Bus Namespace-Ressource bereitstellt. Darüber hinaus werden Rollenzuweisungen für die Azure Ressource in einem separaten Modul erstellt:

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

param service_bus_outputs_name string

param principalType string

param principalId string

resource service_bus 'Microsoft.ServiceBus/namespaces@2024-01-01' existing = {
  name: service_bus_outputs_name
}

resource service_bus_AzureServiceBusDataOwner 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(service_bus.id, principalId, subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '090c5cfd-751d-490a-894a-3ce6f1109419'))
  properties: {
    principalId: principalId
    roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '090c5cfd-751d-490a-894a-3ce6f1109419')
    principalType: principalType
  }
  scope: service_bus
}

Zusätzlich zum Service Bus-Namespace wird auch eine in Azure RBAC (rollenbasierte Zugriffssteuerung in Azure) integrierte Rolle mit dem Namen „Azure Service Bus Data Owner“ bereitgestellt. Die Rolle wird der Ressourcengruppe des Service Bus-Namespaces zugewiesen. Weitere Informationen finden Sie unter Azure Service Bus Datenverantwortlicher.

Bereitstellungsinfrastruktur anpassen

Alle .NET AspireAzure Ressourcen sind Unterklassen des AzureProvisioningResource Typs. Dieser Typ ermöglicht die Anpassung des generierten Bicep, indem eine Fluent-API bereitgestellt wird, die es ermöglicht, die Azure-Ressourcen mithilfe der ConfigureInfrastructure<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure>)-API zu konfigurieren. Sie können z. B. die SKU, den Speicherort und vieles mehr konfigurieren. Im folgenden Beispiel wird veranschaulicht, wie Sie die Azure Service Bus-Ressource anpassen:

builder.AddAzureServiceBus("service-bus")
    .ConfigureInfrastructure(infra =>
    {
        var serviceBusNamespace = infra.GetProvisionableResources()
                                       .OfType<ServiceBusNamespace>()
                                       .Single();

        serviceBusNamespace.Sku = new ServiceBusSku
        {
            Name = ServiceBusSkuName.Premium
        };
        serviceBusNamespace.Tags.Add("ExampleKey", "Example value");
    });

Der vorherige Code:

Verkettet einen Aufruf an die ConfigureInfrastructure-API.
- Der Infra-Parameter ist eine Instanz des AzureResourceInfrastructure Typs.
- Die bereitstellbaren Ressourcen werden mittels der Methode GetProvisionableResources() abgerufen.
- Der einzelne ServiceBusNamespace wird abgerufen.
- ServiceBusNamespace.Sku wird mit einem ServiceBusSkuTier.Premium erstellt.
- Ein Tag wird dem Service Bus-Namespace mit einem Schlüssel von ExampleKey und einem Wert von Example valuehinzugefügt.

Es stehen viele weitere Konfigurationsoptionen zum Anpassen der Azure Service Bus Ressource zur Verfügung. Weitere Informationen finden Sie unter Azure.Provisioning.ServiceBus. Weitere Informationen finden Sie unter Azure. Bereitstellungsanpassung.

Herstellen einer Verbindung mit einem vorhandenen Azure Service Bus-Namespace

Möglicherweise verfügen Sie über einen vorhandenen Azure Service Bus Namespace, mit dem Sie eine Verbindung herstellen möchten. Verketten Sie einen Aufruf, um zu vermerken, dass Ihre AzureServiceBusResource eine vorhandene Ressource ist:

var builder = DistributedApplication.CreateBuilder(args);

var existingServiceBusName = builder.AddParameter("existingServiceBusName");
var existingServiceBusResourceGroup = builder.AddParameter("existingServiceBusResourceGroup");

var serviceBus = builder.AddAzureServiceBus("messaging")
                        .AsExisting(existingServiceBusName, existingServiceBusResourceGroup);

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

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

Weitere Informationen zum Behandeln von Azure Service Bus Ressourcen als vorhandene Ressourcen finden Sie unter Verwenden vorhandener Azure Ressourcen.

Anmerkung

Alternativ können Sie anstelle einer Azure Service Bus Ressource einen Verbindungsstring zum App-Host hinzufügen. Dieser Ansatz ist schwach typiert und funktioniert nicht mit Rollenzuweisungen oder Infrastrukturanpassungen. Weitere Informationen finden Sie unter Hinzufügen vorhandener Azure Ressourcen mit Verbindungszeichenfolgen.

Azure Service Bus-Warteschlange hinzufügen

Rufen Sie zum Hinzufügen einer Azure Service Bus-Warteschlange die AddServiceBusQueue-Methode für die IResourceBuilder<AzureServiceBusResource>auf:

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging");
var queue = serviceBus.AddServiceBusQueue("queue");

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

Wenn Sie AddServiceBusQueue(IResourceBuilder<AzureServiceBusResource>, String, String)aufrufen, werden Ihre ServiceBus-Ressourcen so konfiguriert, dass sie eine Warteschlange mit dem Namen queuehaben. Dies drückt eine explizite hierarchische Beziehung zwischen der messaging Service Bus-Ressource und ihrer untergeordneten queue. Die Warteschlange wird im Service Bus-Namespace erstellt, der durch die zuvor hinzugefügte AzureServiceBusResource dargestellt wird. Weitere Informationen finden Sie unter Warteschlangen, Themen und Abonnements in Azure Service Bus.

Fügen Sie Azure Service Bus Thema und Abonnement hinzu

Rufen Sie zum Hinzufügen eines Azure Service Bus Themas die AddServiceBusTopic-Methode für die IResourceBuilder<AzureServiceBusResource>auf:

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging");
var topic = serviceBus.AddServiceBusTopic("topic");

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

Wenn Sie AddServiceBusTopic(IResourceBuilder<AzureServiceBusResource>, String, String)aufrufen, werden Ihre Service Bus-Ressourcen so konfiguriert, dass sie ein Topic mit dem Namen topichaben. Das Thema wird im Service Bus-Namespace erstellt, der durch die zuvor hinzugefügte AzureServiceBusResource dargestellt wird.

Um ein Abonnement für das Thema hinzuzufügen, rufen Sie die AddServiceBusSubscription-Methode für die IResourceBuilder<AzureServiceBusTopicResource> auf, und konfigurieren Sie es mithilfe der WithProperties-Methode:

using Aspire.Hosting.Azure;

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging");
var topic = serviceBus.AddServiceBusTopic("topic");
topic.AddServiceBusSubscription("sub1")
     .WithProperties(subscription =>
     {
         subscription.MaxDeliveryCount = 10;
         subscription.Rules.Add(
             new AzureServiceBusRule("app-prop-filter-1")
             {
                 CorrelationFilter = new()
                 {
                     ContentType = "application/text",
                     CorrelationId = "id1",
                     Subject = "subject1",
                     MessageId = "msgid1",
                     ReplyTo = "someQueue",
                     ReplyToSessionId = "sessionId",
                     SessionId = "session1",
                     SendTo = "xyz"
                 }
             });
     });

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

Der vorangehende Code fügt nicht nur ein Thema hinzu und erstellt und konfiguriert ein Abonnement mit dem Namen sub1 für das Thema. Das Abonnement hat eine maximale Liefermenge von 10 und eine Regel mit dem Namen app-prop-filter-1. Die Regel ist ein Korrelationsfilter, der Nachrichten basierend auf den Eigenschaften ContentType, CorrelationId, Subject, MessageId, ReplyTo, ReplyToSessionId, SessionIdund SendTo filtert.

Weitere Informationen finden Sie unter Warteschlangen, Themen und Abonnements in Azure Service Bus.

Azure Service Bus-Emulator-Ressource hinzufügen

Um eine Azure Service Bus-Emulator-Ressource hinzuzufügen, verketten Sie einen Aufruf an eine <IResourceBuilder<AzureServiceBusResource>> mit der RunAsEmulator-API.

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging")
                        .RunAsEmulator();

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

Wenn Sie RunAsEmulatoraufrufen, werden Ihre Service Bus-Ressourcen so konfiguriert, dass sie lokal mit einem Emulator ausgeführt werden. Der Emulator in diesem Fall ist der Azure Service Bus Emulator. Der Azure Service Bus Emulator bietet eine kostenlose lokale Umgebung zum Testen Ihrer Azure Service Bus-Apps und ist ein perfekter Begleiter für die .NET AspireAzure Hostingintegration. Der Emulator ist nicht installiert, sondern stattdessen als Container für .NET.NET Aspire zugänglich. Wenn Sie dem App-Host einen Container hinzufügen, wie im vorherigen Beispiel mit dem mcr.microsoft.com/azure-messaging/servicebus-emulator-Image (und dem Begleit-mcr.microsoft.com/azure-sql-edge-Image) gezeigt, wird der Container erstellt und gestartet, wenn der App-Host gestartet wird. Weitere Informationen finden Sie unter Lebenszyklus der Containerressource.

Konfigurieren des ServiceBus-Emulatorcontainers

Es gibt verschiedene Konfigurationen für Containerressourcen, z. B. können Sie die Ports des Containers konfigurieren oder eine wholistische JSON Konfiguration bereitstellen, die alles außer Kraft setzt.

Konfigurieren des Container-Host-Ports des Service-Bus-Emulators

Standardmäßig macht der Dienstbus-Emulatorcontainer, wenn er von .NET.NET Aspirekonfiguriert wird, die folgenden Endpunkte verfügbar:

Endpunkt	Bild	Containerhafen	Hostport
`emulator`	`mcr.microsoft.com/azure-messaging/servicebus-emulator`	5672	dynamisch
`tcp`	`mcr.microsoft.com/azure-sql-edge`	1433	dynamisch

Der Port, auf dem es lauscht, ist standardmäßig dynamisch. Wenn der Container gestartet wird, wird der Port einem zufälligen Port auf dem Hostcomputer zugeordnet. Um den Endpunktport zu konfigurieren, führen Sie Kettenaufrufe auf dem Containerressourcen-Builder, der von der RunAsEmulator-Methode bereitgestellt wird, und dann dem WithHostPort(IResourceBuilder<AzureServiceBusEmulatorResource>, Nullable<Int32>) aus, wie im folgenden Beispiel gezeigt:

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging").RunAsEmulator(
                         emulator =>
                         {
                             emulator.WithHostPort(7777);
                         });

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

Der obige Code konfiguriert den vorhandenen emulator-Endpunkt des Service Bus-Emulatorcontainers, um an Port 7777 zu lauschen. Der Port des Dienstbus-Emulatorcontainers wird dem Hostport zugeordnet, wie in der folgenden Tabelle dargestellt:

Endpunktname	Portzuordnung (`container:host`)
`emulator`	`5672:7777`

Service Bus-Emulatorcontainer mit JSON-Konfiguration konfigurieren

Der Service Bus-Emulator generiert automatisch eine Konfiguration ähnlich wie diese config.json Datei aus den konfigurierten Ressourcen. Sie können diese generierte Datei vollständig überschreiben oder die JSON Konfiguration mit einer JsonNode Darstellung der Konfiguration aktualisieren.

Rufen Sie die JSON-Methode auf, um eine benutzerdefinierte WithConfigurationFile(IResourceBuilder<AzureServiceBusEmulatorResource>, String) Konfigurationsdatei bereitzustellen:

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging").RunAsEmulator(
                         emulator =>
                         {
                             emulator.WithConfigurationFile(
                                 path: "./messaging/custom-config.json");
                         });

Der vorangehende Code konfiguriert den Service Bus-Emulatorcontainer für die Verwendung einer benutzerdefinierten JSON Konfigurationsdatei, die sich auf ./messaging/custom-config.jsonbefindet. Rufen Sie stattdessen die WithConfiguration(IResourceBuilder<AzureServiceBusEmulatorResource>, Action<JsonNode>)-Methode auf, um bestimmte Eigenschaften in der Standardkonfiguration außer Kraft zu setzen:

var builder = DistributedApplication.CreateBuilder(args);

var serviceBus = builder.AddAzureServiceBus("messaging").RunAsEmulator(
                         emulator =>
                         {
                             emulator.WithConfiguration(
                                 (JsonNode configuration) =>
                                 {
                                     var userConfig = configuration["UserConfig"];
                                     var ns = userConfig["Namespaces"][0];
                                     var firstQueue = ns["Queues"][0];
                                     var properties = firstQueue["Properties"];
                                     
                                     properties["MaxDeliveryCount"] = 5;
                                     properties["RequiresDuplicateDetection"] = true;
                                     properties["DefaultMessageTimeToLive"] = "PT2H";
                                 });
                         });

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

Der vorherige Code ruft den UserConfig Knoten aus der Standardkonfiguration ab. Anschließend werden die Eigenschaften der ersten Warteschlange aktualisiert, um die MaxDeliveryCount auf 5, RequiresDuplicateDetection auf truefestzulegen, und DefaultMessageTimeToLive auf 2 hours.

Durchführung von Integrationsgesundheitsprüfungen

Die Azure Service Bus Hostingintegration fügt automatisch eine Integritätsprüfung für die Service Bus-Ressource hinzu. Die Gesundheitsprüfung überprüft, ob der Service Bus läuft und ob eine Verbindung zu ihm hergestellt werden kann.

Die Hostingintegration basiert auf dem 📦 AspNetCore.HealthChecks.AzureServiceBus NuGet-Paket.

Client-Integration

Um mit der .NET AspireAzure Service Bus-Clientintegration zu beginnen, installieren Sie das 📦Aspire.Azure.Messaging.ServiceBus NuGet-Paket in dem Projekt, das den Client verwendet, also das Projekt für die Anwendung, die den Service Bus-Client verwendet. Die Service Bus-Clientintegration registriert eine ServiceBusClient Instanz, die Sie für die Interaktion mit Service Bus verwenden können.

.NET CLI
PaketReferenz

dotnet add package Aspire.Azure.Messaging.ServiceBus

<PackageReference Include="Aspire.Azure.Messaging.ServiceBus"
                  Version="*" />

Dienstbusclient hinzufügen

Rufen Sie in der Program.cs-Datei Ihres Projekts, das den Client verwendet, die AddAzureServiceBusClient-Erweiterungsmethode für jeden IHostApplicationBuilder auf, um einen ServiceBusClient für die Verwendung über den Dependency Injection-Container zu registrieren. Die Methode verwendet einen Verbindungsnamenparameter.

builder.AddAzureServiceBusClient(connectionName: "messaging");

Tipp

Der parameter connectionName muss mit dem Namen übereinstimmen, der beim Hinzufügen der Service Bus-Ressource im App-Hostprojekt verwendet wird. Anders ausgedrückt: Wenn Sie AddAzureServiceBus aufrufen und einen Namen von messaging angeben, sollte dieser Name beim Aufrufen von AddAzureServiceBusClientverwendet werden. Weitere Informationen finden Sie unter Hinzufügen der Azure Service Bus-Ressource.

Anschließend können Sie die Instanz ServiceBusClient mithilfe der Abhängigkeitsinjektion abrufen. Um beispielsweise die Verbindung von einem Beispieldienst abzurufen:

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

Weitere Informationen zur Abhängigkeitsinjektion finden Sie unter .NET Abhängigkeitsinjektion.

Schlüsselbasierten Service Bus-Client hinzufügen

Es kann Situationen geben, in denen Sie mehrere ServiceBusClient Instanzen mit unterschiedlichen Verbindungsnamen registrieren möchten. Rufen Sie die AddKeyedAzureServiceBusClient-Methode auf, um Service Bus-Clientanwendungen mit Schlüsseln zu registrieren.

builder.AddKeyedAzureServiceBusClient(name: "mainBus");
builder.AddKeyedAzureServiceBusClient(name: "loggingBus");

Wichtig

Bei der Verwendung von benannten Diensten wird erwartet, dass Ihre Service Bus-Ressource zwei benannte Busse konfiguriert hat, eine für die mainBus und eine für die loggingBus.

Anschließend können Sie die ServiceBusClient-Instanzen mithilfe der Abhängigkeitsinjektion abrufen. Um beispielsweise die Verbindung von einem Beispieldienst abzurufen:

public class ExampleService(
    [FromKeyedServices("mainBus")] ServiceBusClient mainBusClient,
    [FromKeyedServices("loggingBus")] ServiceBusClient loggingBusClient)
{
    // Use clients...
}

Weitere Informationen zu schlüsselbasierten Diensten finden Sie unter .NET Abhängigkeitsinjektion: schlüsselbasierte Dienste.

Konfiguration

Die .NET AspireAzure Service Bus-Integration bietet mehrere Optionen zum Konfigurieren der Verbindung basierend auf den Anforderungen und Konventionen Ihres Projekts.

Verwenden Sie eine Verbindungszeichenfolge

Wenn Sie eine Verbindungszeichenfolge aus dem Konfigurationsabschnitt ConnectionStrings verwenden, können Sie beim Aufrufen der AddAzureServiceBusClient-Methode den Namen der Verbindungszeichenfolge angeben:

builder.AddAzureServiceBusClient("messaging");

Aus dem Konfigurationsabschnitt ConnectionStrings wird anschließend die Verbindungszeichenfolge abgerufen.

{
  "ConnectionStrings": {
    "messaging": "Endpoint=sb://{namespace}.servicebus.windows.net/;SharedAccessKeyName={keyName};SharedAccessKey={key};"
  }
}

Weitere Informationen zum Formatieren dieser Verbindungszeichenfolge finden Sie in der ConnectionString-Dokumentation.

Verwendung von Konfigurationsanbietern

Die .NET Aspire-Azure Service Bus-Integration unterstützt Microsoft.Extensions.Configuration. Sie lädt die AzureMessagingServiceBusSettings mithilfe des Aspire:Azure:Messaging:ServiceBus-Schlüssels aus der Konfiguration. Der folgende Codeausschnitt ist ein Beispiel für eine appsettings.json Datei, die einige der Optionen konfiguriert:

{
  "Aspire": {
    "Azure": {
      "Messaging": {
        "ServiceBus": {
          "ConnectionString": "Endpoint=sb://{namespace}.servicebus.windows.net/;SharedAccessKeyName={keyName};SharedAccessKey={key};",
          "DisableTracing": false
        }
      }
    }
  }
}

Das vollständige Schema der Service Bus-Clientintegration JSON finden Sie unter Aspire.Azure.Messaging.ServiceBus/ConfigurationSchema.json.

Inline-Delegaten verwenden

Sie können auch den Action<AzureMessagingServiceBusSettings> configureSettings-Delegaten übergeben, um einige oder alle Optionen inline einzurichten, beispielsweise um die Ablaufverfolgung im Code zu deaktivieren:

builder.AddAzureServiceBusClient(
    "messaging",
    static settings => settings.DisableTracing = true);

Sie können die Azure.Messaging.ServiceBus.ServiceBusClientOptions auch mithilfe des optionalen Parameters Action<ServiceBusClientOptions> configureClientOptions der AddAzureServiceBusClient-Methode einrichten. Beispielsweise legen Sie das Benutzer-Agent-Headersuffix ServiceBusClientOptions.Identifier für alle Anforderungen, die von diesem Client ausgegeben werden, wie folgt fest:

builder.AddAzureServiceBusClient(
    "messaging",
    configureClientOptions:
        clientOptions => clientOptions.Identifier = "myapp");

Client Integrationsgesundheitsprüfungen

Standardmäßig ermöglichen die .NET-.NET Aspire-Integrationen Gesundheitsprüfungen für alle Dienste. Weitere Informationen finden Sie unter .NET.NET Aspire Integrationsübersicht.

Die Integration von .NET AspireAzure Service Bus:

Fügt die Gesundheitsprüfung hinzu, wenn AzureMessagingServiceBusSettings.DisableTracingfalse ist, wobei versucht wird, eine Verbindung mit dem Service Bus herzustellen.
Integriert sich in den /health HTTP-Endpunkt, der spezifiziert, dass alle registrierten Gesundheitsprüfungen erfolgreich sein müssen, damit die App bereit ist, Datenverkehr anzunehmen.

Observabilität und Telemetrie

.NET.NET Aspire Integrationen richten automatisch Protokollierungs-, Tracing- und Metrikkonfigurationen ein, die manchmal als den Säulen der Observierbarkeitbezeichnet werden. Weitere Informationen zur Integrations-Observability und Telemetrie finden Sie unter .NET.NET Aspire Integrationen-Übersicht. Abhängig vom Backend-Dienst unterstützen einige Integrationen möglicherweise nur bestimmte dieser Funktionen. Beispielsweise unterstützen einige Integrationen Protokollierung und Ablaufverfolgung, aber keine Metriken. Telemetrie-Features können auch mithilfe der Techniken deaktiviert werden, die im Abschnitt Konfiguration dargestellt werden.

Protokollierung

Die .NET AspireAzure Service Bus-Integration verwendet die folgenden Protokollkategorien:

Azure.Core
Azure.Identity
Azure-Messaging-ServiceBus

Zusätzlich zum Abrufen von Azure Service Bus Anforderungsdiagnosen für fehlerhafte Anforderungen können Sie Latenzschwellenwerte konfigurieren, um zu bestimmen, welche der erfolgreichen Azure Service Bus Anforderungsdiagnosen protokolliert werden. Die Standardwerte sind 100 ms für Punktvorgänge und 500 ms für Vorgänge ohne Punkt.

builder.AddAzureServiceBusClient(
    "messaging",
    configureClientOptions:
        clientOptions => {
            clientOptions.ServiceBusClientTelemetryOptions = new()
            {
                ServiceBusThresholdOptions = new()
                {
                    PointOperationLatencyThreshold = TimeSpan.FromMilliseconds(50),
                    NonPointOperationLatencyThreshold = TimeSpan.FromMilliseconds(300)
                }
            };
        });

Ablaufverfolgung

Die .NET AspireAzure Service Bus-Integration wird die folgenden Verfolgungsaktivitäten mithilfe von OpenTelemetryausgeben:

Message
ServiceBusSender.Send
ServiceBusSender.Schedule
ServiceBusSender.Cancel
ServiceBusReceiver.Receive
ServiceBusReceiver.ReceiveDeferred
ServiceBusReceiver.Peek
ServiceBusReceiver.Abandon
ServiceBusReceiver.Complete
ServiceBusReceiver.DeadLetter
ServiceBusReceiver.Defer
ServiceBusReceiver.RenewMessageLock
ServiceBusSessionReceiver.RenewSessionLock
ServiceBusSessionReceiver.GetSessionState
ServiceBusSessionReceiver.SetSessionState
ServiceBusProcessor.ProcessMessage
ServiceBusSessionProcessor.ProcessSessionMessage
ServiceBusRuleManager.CreateRule
ServiceBusRuleManager.DeleteRule
ServiceBusRuleManager.GetRules

Die Ablaufverfolgung von Azure Service Bus befindet sich derzeit in der Vorschauphase, daher müssen Sie den Experimentiermodus aktivieren, um die Ausgabe von Ablaufverfolgungen zu gewährleisten.

AppContext.SetSwitch("Azure.Experimental.EnableActivitySource", true);

Weitere Informationen finden Sie unter Azure Service Bus: Verteilte Ablaufverfolgung und Korrelation über Service Bus-Messaging.

Kennzahlen

Die .NET AspireAzure Service Bus-Integration unterstützt derzeit Metriken nicht standardmäßig aufgrund von Einschränkungen mit dem Azure SDK.

Siehe auch

Azure Service Bus
Überblick über Integrationen .NET.NET Aspire
Überblick über Integrationen .NET AspireAzure
.NET AspireGitHub Repository

Freigeben über