.NET Aspire-Azure Service Bus-Integration

Artikel
02/27/2025

umfasst: Hostingintegration und Client Integration

Azure Service Bus ist ein vollständig gemanagter Enterprise-Nachrichtenvermittler mit Warteschlangen und Themen für das Publish-Subscribe-Modell. 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.
AzureServiceBusEmulatorResource: Stellt eine Azure Service Bus Emulatorressource dar.

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

.NET CLI
PackageReference

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.

Generierte Bereitstellungs-Bicep-Skripte

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'

param principalType string

param principalId string

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'
  }
}

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
}

output serviceBusEndpoint string = service_bus.properties.serviceBusEndpoint

Das vorherige Bicep ist ein Modul, das ein Azure Service Bus-Namespace mit den folgenden Standardeinstellungen bereitstellt:

sku: Die SKU des Service-Bus-Namespaces. Der Standardwert ist "Standard".
location: Der Speicherort für den Service Bus-Namespace. Die Standardeinstellung ist der Ort der Ressourcengruppe.

Zusätzlich zum Service Bus-Namespace stellt es auch eine Azure rollenbasierte Zugriffssteuerung (Azure RBAC) integrierte Rolle von Azure Service Bus Datenbesitzer bereit. 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 der generierten Bicep durch Bereitstellung einer flüssigen API zum Konfigurieren der Azure-Ressourcen—mithilfe der ConfigureInfrastructure<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure>)-API. 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
        {
            Tier = ServiceBusSkuTier.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.
- Das einzelne ServiceBusNamespace wird abgerufen.
- Das mit einem ServiceBusNamespace.Sku erstellte ServiceBusSkuTier.Premium
- 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. Anstatt eine neue Azure Service Bus-Ressource darzustellen, können Sie dem App-Host eine Verbindungszeichenfolge hinzufügen. Rufen Sie die Azure Service Bus-Methode auf, um eine Verbindung zu einem vorhandenen AddConnectionString-Namespace hinzuzufügen:

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

Anmerkung

Verbindungszeichenfolgen werden verwendet, um eine Vielzahl von Verbindungsinformationen darzustellen, einschließlich Datenbankverbindungen, Nachrichtenbroker, Endpunkt-URIs und andere Dienste. In der .NET.NET Aspire Nomenklatur wird der Begriff "Verbindungsstring" verwendet, um jede Art von Verbindungsinformationen darzustellen.

Die Verbindungszeichenfolge wird in der Konfiguration des App-Hosts konfiguriert, in der Regel unter Benutzergeheimnisse, unter dem Abschnitt ConnectionStrings. Der App-Host fügt diese Verbindungszeichenfolge als Umgebungsvariable in alle abhängigen Ressourcen ein, z. B.:

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

Die abhängige Ressource kann auf die eingefügte Verbindungszeichenfolge zugreifen, indem sie die GetConnectionString Methode aufruft und den Verbindungsnamen als Parameter übergibt, in diesem Fall "messaging". Die GetConnectionString-API ist eine Abkürzung für IConfiguration.GetSection("ConnectionStrings")[name].

Hinzufügen der Warteschlange Azure Service Bus

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");
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. 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");
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 Topic 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 Emulatorressource hinzufügen

Um eine Azure Service Bus Emulatorressource hinzuzufügen, verketten Sie einen Aufruf an ein <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-Generator aus, der von der RunAsEmulator-Methode bereitgestellt wird, und dann der WithHostPort(IResourceBuilder<AzureServiceBusEmulatorResource>, Nullable<Int32>), 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 vorangehende Code konfiguriert den vorhandenen emulator-Endpunkt des Service Bus-Emulators, um auf Port 7777zu lauschen. Der Port des Dienstbus-Emulatorcontainers wird dem Hostport zugeordnet, wie in der folgenden Tabelle dargestellt:

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

Konfigurieren Sie die Konfiguration des Service-Bus-Emulator-Containers JSON

Der Service Bus-Emulatorcontainer wird mit einer Standarddatei config.json ausgeführt. Sie können diese 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
PackageReference

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 einen Client verwendet, die AddAzureServiceBusClient-Erweiterungsmethode für jedes IHostApplicationBuilder auf, um eine 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.

Hinzufügen eines Keyed Service Bus-Clients

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. Es lädt die AzureMessagingServiceBusSettings aus der Konfiguration mithilfe des Schlüssels Aspire:Azure:Messaging:ServiceBus. 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 Delegat übergeben, um einige oder alle Optionen inline einzurichten, z. B. zum Deaktivieren der Ablaufverfolgung aus Code:

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. Wenn Sie beispielsweise das Benutzer-Agent-Headersuffix ServiceBusClientOptions.Identifier für alle Anforderungen, die von diesem Client ausgegeben werden, festlegen möchten:

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 .NET Aspire- undAzure Service Bus-Integration:

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.

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

Nachverfolgung

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

Azure Service Bus Die Nachverfolgung befindet sich derzeit in der Testphase, sodass Sie die experimentelle Einstellung aktivieren müssen, um sicherzustellen, dass Nachverfolgungsdaten ausgegeben werden.

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 Aspire GitHub Repository

Freigeben über