Tutorial: Nutzen der dynamischen Konfiguration per Pushaktualisierung in einer .NET-App

Artikel
02/20/2024

Die .NET-Clientbibliothek von App Configuration unterstützt die bedarfsgesteuerte Aktualisierung der Konfigurationseinstellungen, ohne dass eine Anwendung neu gestartet werden muss. Eine Anwendung kann mit einem oder beiden der folgenden Ansätze so konfiguriert werden, dass App Configuration-Änderungen erkannt werden.

Abrufmodell: Dies ist das Standardverhalten, bei dem Änderungen an der Konfiguration per Abruf erkannt werden. Nachdem der zwischengespeicherte Wert einer Einstellung abgelaufen ist, wird beim nächsten Aufruf von TryRefreshAsync oder RefreshAsync eine Anforderung an den Server gesendet, um zu überprüfen, ob sich die Konfiguration geändert hat. Bei Bedarf wird die aktualisierte Konfiguration dann per Pullvorgang übertragen.
Pushmodell: Hierbei werden App Configuration-Ereignisse verwendet, um Änderungen an der Konfiguration zu erkennen. Nachdem für App Configuration das Senden von Ereignissen mit Schlüsselwertänderungen an Azure Event Grid eingerichtet wurde, können diese Ereignisse von der Anwendung genutzt werden, um die Gesamtzahl von Anforderungen zu optimieren, mit denen die Konfiguration auf dem aktuellen Stand gehalten werden kann. Diese können von Anwendungen entweder direkt von Event Grid abonniert werden, oder es können unterstützte Ereignishandler, z. B. ein Webhook, eine Azure-Funktion oder ein Service Bus-Thema genutzt werden.

In diesem Tutorial wird veranschaulicht, wie Sie dynamische Konfigurationsupdates in Ihrem Code per Pushaktualisierung implementieren können. Dies baut auf der App auf, die in dem Tutorial vorgestellt wurde. Bevor Sie fortfahren, beenden Sie zunächst das Tutorial: Verwenden der dynamischen Konfiguration in einer .NET-App.

Für die Ausführung der Schritte dieses Tutorials können Sie einen beliebigen Code-Editor verwenden. Visual Studio Code ist eine hervorragende Option, die auf Windows-, macOS- und Linux-Plattformen verfügbar ist.

In diesem Tutorial lernen Sie Folgendes:

Einrichten eines Abonnements zum Senden von Ereignissen zu Konfigurationsänderungen von App Configuration an ein Service Bus-Thema
Einrichten Ihrer .NET-App für die Aktualisierung der Konfiguration als Reaktion auf Änderungen in App Configuration.
Verwenden der aktuellen Konfiguration in Ihrer Anwendung

Voraussetzungen

Tutorial: Verwenden der dynamischen Konfiguration in einer .NET-App
Version 5.0.0 oder höher des NuGet-Pakets Microsoft.Extensions.Configuration.AzureAppConfiguration

Einrichten eines Azure Service Bus-Themas und -Abonnements

In diesem Tutorial wird die Service Bus-Integration für Event Grid verwendet, um die Erkennung von Konfigurationsänderungen für Anwendungen zu vereinfachen, bei denen App Configuration nicht ständig nach Änderungen abgefragt werden soll. Das Azure Service Bus SDK verfügt über eine API zum Registrieren eines Meldungshandlers, mit dem die Konfiguration aktualisiert werden kann, wenn in App Configuration Änderungen erkannt werden. Befolgen Sie die Schritte im Schnellstart: Verwenden Sie das Azure-Portal zum Erstellen eines Service Bus-Themas und eines -Abonnements, um einen Namespace, ein Thema und ein Abonnement für Service Bus zu erstellen.

Fügen Sie nach der Erstellung der Ressourcen die folgenden Umgebungsvariablen hinzu. Sie werden verwendet, um einen Ereignishandler für Konfigurationsänderungen im Anwendungscode zu registrieren.

Schlüssel	Wert
ServiceBusConnectionString	Verbindungszeichenfolge für den Service Bus-Namespace
ServiceBusTopic	Name des Service Bus-Themas
ServiceBusSubscription	Name des Service Bus-Abonnements

Einrichten des Ereignisabonnements

Öffnen Sie die App Configuration-Ressource im Azure-Portal, und klicken Sie anschließend im Bereich Events (Ereignisse) auf + Event Subscription (+ Ereignisabonnement).
Geben Sie einen Namen für Event Subscription (Ereignisabonnement) und System Topic (Systemthema) ein.
Wählen Sie unter Endpoint Type (Endpunkttyp) die Option Service Bus Topic (Service Bus-Thema) und dann das Service Bus-Thema aus, und klicken Sie anschließend auf Confirm Selection (Auswahl bestätigen).
Klicken Sie auf Create (Erstellen), um das Ereignisabonnement zu erstellen.
Klicken Sie im Bereich Events (Ereignisse) auf Event Subscriptions (Ereignisabonnements), um sich zu vergewissern, dass die Erstellung des Abonnements erfolgreich war.

Hinweis

Beim Abonnieren von Konfigurationsänderungen können ein oder mehrere Filter genutzt werden, um die Anzahl von Ereignissen zu reduzieren, die an Ihre Anwendung gesendet werden. Diese können entweder als Event Grid-Abonnementfilter oder Service Bus-Abonnementfilter konfiguriert werden. Beispielsweise kann ein Abonnementfilter nur verwendet werden, um Ereignisse zu Änderungen in einem Schlüssel zu abonnieren, der mit einer bestimmten Zeichenfolge beginnt.

Registrieren eines Ereignishandlers zum erneuten Laden von Daten aus App Configuration

Öffnen Sie die Datei Program.cs, und aktualisieren Sie sie mit folgendem Code.

using Azure.Messaging.EventGrid;
using Azure.Messaging.ServiceBus;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;
using Microsoft.Extensions.Configuration.AzureAppConfiguration.Extensions;
using System;
using System.Threading.Tasks;

namespace TestConsole
{
    class Program
    {
        private const string AppConfigurationConnectionStringEnvVarName = "AppConfigurationConnectionString";
        // e.g. Endpoint=https://{store_name}.azconfig.io;Id={id};Secret={secret}
        
        private const string ServiceBusConnectionStringEnvVarName = "ServiceBusConnectionString";
        // e.g. Endpoint=sb://{service_bus_name}.servicebus.windows.net/;SharedAccessKeyName={key_name};SharedAccessKey={key}
        
        private const string ServiceBusTopicEnvVarName = "ServiceBusTopic";
        private const string ServiceBusSubscriptionEnvVarName = "ServiceBusSubscription";

        private static IConfigurationRefresher _refresher = null;

        static async Task Main(string[] args)
        {
            string appConfigurationConnectionString = Environment.GetEnvironmentVariable(AppConfigurationConnectionStringEnvVarName);

            IConfiguration configuration = new ConfigurationBuilder()
                .AddAzureAppConfiguration(options =>
                {
                    options.Connect(appConfigurationConnectionString);
                    options.ConfigureRefresh(refresh =>
                        refresh
                            .Register("TestApp:Settings:Message")
                            .SetCacheExpiration(TimeSpan.FromDays(1))  // Important: Reduce poll frequency
                    );

                    _refresher = options.GetRefresher();
                }).Build();

            RegisterRefreshEventHandler();
            var message = configuration["TestApp:Settings:Message"];
            Console.WriteLine($"Initial value: {configuration["TestApp:Settings:Message"]}");

            while (true)
            {
                await _refresher.TryRefreshAsync();

                if (configuration["TestApp:Settings:Message"] != message)
                {
                    Console.WriteLine($"New value: {configuration["TestApp:Settings:Message"]}");
                    message = configuration["TestApp:Settings:Message"];
                }

                await Task.Delay(TimeSpan.FromSeconds(1));
            }
        }

        private static void RegisterRefreshEventHandler()
        {
            string serviceBusConnectionString = Environment.GetEnvironmentVariable(ServiceBusConnectionStringEnvVarName);
            string serviceBusTopic = Environment.GetEnvironmentVariable(ServiceBusTopicEnvVarName);
            string serviceBusSubscription = Environment.GetEnvironmentVariable(ServiceBusSubscriptionEnvVarName);
            ServiceBusClient serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
            ServiceBusProcessor serviceBusProcessor = serviceBusClient.CreateProcessor(serviceBusTopic, serviceBusSubscription);

            serviceBusProcessor.ProcessMessageAsync += (processMessageEventArgs) =>
                {
                    // Build EventGridEvent from notification message
                    EventGridEvent eventGridEvent = EventGridEvent.Parse(BinaryData.FromBytes(processMessageEventArgs.Message.Body));

                    // Create PushNotification from eventGridEvent
                    eventGridEvent.TryCreatePushNotification(out PushNotification pushNotification);

                    // Prompt Configuration Refresh based on the PushNotification
                    _refresher.ProcessPushNotification(pushNotification);

                    return Task.CompletedTask;
                };

            serviceBusProcessor.ProcessErrorAsync += (exceptionargs) =>
                {
                    Console.WriteLine($"{exceptionargs.Exception}");
                    return Task.CompletedTask;
                };
        }
    }
}

Die ProcessPushNotification-Methode setzt den Cacheablauf auf eine kurze zufällige Verzögerung zurück. Dies führt dazu, dass zukünftige Aufrufe von RefreshAsync oder TryRefreshAsync die zwischengespeicherten Werte gegen App Configuration erneut überprüfen und bei Bedarf aktualisieren. In diesem Beispiel registrieren Sie sich, um Änderungen am Schlüssel zu überwachen: TestApp:Settings:Message mit einem Cacheablauf von einem Tag. Dies bedeutet, dass erst nach Ablauf eines Tags seit der letzten Überprüfung eine Anforderung an App Configuration gesendet wird. Wenn Sie ProcessPushNotification aufrufen, sendet Ihre Anwendung in den nächsten Sekunden Anforderungen an App Configuration. Ihre Anwendung lädt die neuen Konfigurationswerte kurz nach dem Auftreten von Änderungen im App Configuration-Speicher, ohne dass ständig Updates abgerufen werden müssen. Falls Ihre Anwendung die Änderungsbenachrichtigung aus irgendeinem Grund verpasst, überprüft sie aber immer noch einmal täglich auf Konfigurationsänderungen.

Die kurze zufällige Verzögerung für den Cacheablauf ist hilfreich, wenn viele Instanzen Ihrer Anwendung oder Microservices mithilfe des Pushmodells eine Verbindung mit demselben App Configuration-Speicher herstellen. Ohne diese Verzögerung könnten alle Instanzen Ihrer Anwendung Anforderungen gleichzeitig an Ihren App Configuration-Speicher senden, sobald sie eine Änderungsbenachrichtigung erhalten. Dies kann dazu führen, dass der App Configuration-Dienst Ihren Speicher drosselt. Die Cacheablaufverzögerung ist standardmäßig auf eine Zufallszahl zwischen 0 und maximal 30 Sekunden festgelegt, aber Sie können den Höchstwert über den optionalen Parameter maxDelay der ProcessPushNotification-Methode ändern.

Die ProcessPushNotification-Methode akzeptiert ein PushNotification-Objekt als Eingabe, das Informationen darüber enthält, welche Änderung in App Configuration die Pushbenachrichtigung ausgelöst hat. Dadurch wird sichergestellt, dass alle Konfigurationsänderungen bis zum auslösenden Ereignis in der folgenden Konfigurationsaktualisierung geladen werden. Die SetDirty-Methode garantiert nicht, dass die Änderung, die die Pushbenachrichtigung ausgelöst hat, in eine sofortige Konfigurationsaktualisierung geladen wird. Wenn Sie die SetDirty-Methode für das Pushmodell verwenden, empfehlen wir, stattdessen die ProcessPushNotification-Methode zu verwenden.

Lokales Erstellen und Ausführen der App

Legen Sie eine Umgebungsvariable mit dem Namen AppConfigurationConnectionString auf den Zugriffsschlüssel für Ihren App Configuration-Speicher fest.
Um die App lokal zu erstellen und auszuführen, führen Sie bei Verwendung einer Windows-Eingabeaufforderung den folgenden Befehl aus, und starten Sie die Eingabeaufforderung neu, damit die Änderung wirksam wird:
```
setx AppConfigurationConnectionString "connection-string-of-your-app-configuration-store"
```
Führen Sie bei Verwendung von Windows PowerShell den folgenden Befehl aus:
```
$Env:AppConfigurationConnectionString = "connection-string-of-your-app-configuration-store"
```
Führen Sie bei Verwendung von macOS den folgenden Befehl aus:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Führen Sie bei Verwendung von Linux den folgenden Befehl aus:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Führen Sie den folgenden Befehl aus, um die Konsolen-App zu erstellen:
```
dotnet build
```
Führen Sie nach der erfolgreichen Erstellung den folgenden Befehl aus, um die App lokal auszuführen:
```
dotnet run
```
Melden Sie sich beim Azure-Portal an. Klicken Sie auf Alle Ressourcen, und wählen Sie dann die Instanz des App Configuration-Speichers aus, die Sie in der Schnellstartanleitung erstellt haben.
Wählen Sie den Konfigurations-Explorer aus, und aktualisieren Sie die Werte der folgenden Schlüssel:

Schlüssel Wert

TestApp:Settings:Message Daten aus Azure App Configuration: Aktualisiert
Warten Sie einige Augenblicke, bis das Ereignis verarbeitet werden kann. Ihnen wird die aktualisierte Konfiguration angezeigt.

Schlüssel	Wert
TestApp:Settings:Message	Daten aus Azure App Configuration: Aktualisiert

Bereinigen von Ressourcen

Wenn Sie die in diesem Artikel erstellten Ressourcen nicht mehr verwenden möchten, löschen Sie die erstellte Ressourcengruppe, um Kosten zu vermeiden.

Wichtig

Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Die Ressourcengruppe und alle darin enthaltenen Ressourcen werden unwiderruflich gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Falls Sie die Ressourcen für diesen Artikel in einer Ressourcengruppe erstellt haben, die andere beizubehaltende Ressourcen enthält, löschen Sie die Ressourcen einzeln über den entsprechenden Bereich, statt die Ressourcengruppe zu löschen.

Melden Sie sich beim Azure-Portal an, und klicken Sie auf Ressourcengruppen.
Geben Sie im Feld Nach Name filtern den Namen Ihrer Ressourcengruppe ein.
Wählen Sie in der Ergebnisliste den Ressourcengruppennamen aus, um eine Übersicht anzuzeigen.
Wählen Sie die Option Ressourcengruppe löschen.
Sie werden aufgefordert, das Löschen der Ressourcengruppe zu bestätigen. Geben Sie zur Bestätigung den Namen Ihrer Ressourcengruppe ein, und klicken Sie auf Löschen.

Daraufhin werden die Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht.

Nächste Schritte

In diesem Tutorial haben Sie Ihre .NET-App aktiviert, um Konfigurationseinstellungen dynamisch aus App Configuration zu aktualisieren. Fahren Sie mit dem nächsten Tutorial fort, um zu erfahren, wie Sie eine von Azure verwaltete Identität hinzufügen, um den Zugriff auf App Configuration zu optimieren.

Integration der verwalteten Identität