Zelfstudie: Dynamische configuratie gebruiken met pushvernieuwing in een .NET-app

Artikel
02/28/2024

De .NET-clientbibliotheek van App Configuration ondersteunt het bijwerken van configuratie op aanvraag zonder dat een toepassing opnieuw wordt opgestart. Een toepassing kan worden geconfigureerd om wijzigingen in App Configuration te detecteren met behulp van een of beide van de volgende twee benaderingen.

Poll-model: dit is het standaardgedrag dat polling gebruikt om wijzigingen in de configuratie te detecteren. Zodra de waarde van een instelling in de cache is verlopen, wordt bij de volgende aanroep een TryRefreshAsyncRefreshAsync aanvraag naar de server verzonden om te controleren of de configuratie is gewijzigd en wordt de bijgewerkte configuratie zo nodig opgehaald.
Push-model: dit maakt gebruik van App Configuration-gebeurtenissen om wijzigingen in de configuratie te detecteren. Zodra App Configuration is ingesteld voor het verzenden van belangrijke waardewijzigingsevenementen naar Azure Event Grid, kan de toepassing deze gebeurtenissen gebruiken om het totale aantal aanvragen te optimaliseren dat nodig is om de configuratie bijgewerkt te houden. Toepassingen kunnen ervoor kiezen om zich rechtstreeks vanuit Event Grid aan deze te abonneren, of via een van de ondersteunde gebeurtenis-handlers , zoals een webhook, een Azure-functie of een Service Bus-onderwerp.

Deze zelfstudie laat zien hoe u dynamische configuratie-updates in uw code kunt implementeren met behulp van pushvernieuwing. Het bouwt voort op de app die in de zelfstudie is geïntroduceerd. Voordat u doorgaat, voltooit u de zelfstudie: Gebruik eerst een dynamische configuratie in een .NET-app .

U kunt elke code-editor gebruiken om de stappen in deze zelfstudie uit te voeren. Visual Studio Code is een uitstekende optie die beschikbaar is op de Windows-, macOS- en Linux-platforms.

In deze zelfstudie leert u het volgende:

Een abonnement instellen voor het verzenden van gebeurtenissen voor configuratiewijziging van App Configuration naar een Service Bus-onderwerp
Stel uw .NET-app in om de configuratie bij te werken als reactie op wijzigingen in App Configuration.
De meest recente configuratie in uw toepassing gebruiken.

Vereisten

Zelfstudie: Dynamische configuratie gebruiken in een .NET-app
NuGet-pakketversie Microsoft.Extensions.Configuration.AzureAppConfiguration 5.0.0 of hoger

Azure Service Bus-onderwerp en -abonnement instellen

In deze zelfstudie wordt de Service Bus-integratie voor Event Grid gebruikt om de detectie van configuratiewijzigingen te vereenvoudigen voor toepassingen die App Configuration niet continu willen controleren op wijzigingen. De Azure Service Bus SDK biedt een API voor het registreren van een berichthandler die kan worden gebruikt om de configuratie bij te werken wanneer wijzigingen worden gedetecteerd in App Configuration. Volg de stappen in de quickstart: Gebruik Azure Portal om een Service Bus-onderwerp en -abonnement te maken om een Service Bus-naamruimte, onderwerp en abonnement te maken.

Zodra de resources zijn gemaakt, voegt u de volgende omgevingsvariabelen toe. Deze worden gebruikt om een gebeurtenis-handler te registreren voor configuratiewijzigingen in de toepassingscode.

Sleutel	Weergegeven als
ServiceBus Verbinding maken ionString	Verbinding maken iontekenreeks voor de Service Bus-naamruimte
ServiceBusTopic	Naam van het Service Bus-onderwerp
ServiceBusSubscription	Naam van het Service Bus-abonnement

Gebeurtenisabonnement instellen

Open de App Configuration-resource in Azure Portal en klik vervolgens + Event Subscription in het Events deelvenster.
Voer een naam in voor de Event Subscription en de System Topic.
Selecteer de Endpoint Type optie als Service Bus Topic, kies het Service Bus-onderwerp en klik vervolgens op Confirm Selection.
Klik op Create om het gebeurtenisabonnement te maken.
Klik in Event Subscriptions het Events deelvenster om te controleren of het abonnement is gemaakt.

Notitie

Wanneer u zich abonneert op configuratiewijzigingen, kunnen een of meer filters worden gebruikt om het aantal gebeurtenissen dat naar uw toepassing wordt verzonden, te verminderen. Deze kunnen worden geconfigureerd als Event Grid-abonnementsfilters of Service Bus-abonnementsfilters. Een abonnementsfilter kan bijvoorbeeld worden gebruikt om alleen te abonneren op gebeurtenissen voor wijzigingen in een sleutel die begint met een specifieke tekenreeks.

Gebeurtenis-handler registreren om gegevens opnieuw te laden vanuit App Configuration

Open Program.cs en werk het bestand bij met de volgende 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")
                            // Important: Reduce poll frequency
                            .SetCacheExpiration(TimeSpan.FromDays(1))  
                    );

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

            await 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 async Task 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;
            };

            await serviceBusProcessor.StartProcessingAsync();
        }
    }
}

De ProcessPushNotification methode stelt de verlooptijd van de cache opnieuw in op een korte willekeurige vertraging. Dit zorgt ervoor dat toekomstige aanroepen naar RefreshAsync of TryRefreshAsync opnieuw valideren van de waarden in de cache voor App Configuration en deze indien nodig bijwerken. In dit voorbeeld registreert u zich om wijzigingen in de sleutel te controleren: TestApp:Instellingen:Message met een cacheverlooptijd van één dag. Dit betekent dat er geen aanvraag voor App Configuration wordt gedaan voordat een dag is verstreken sinds de laatste controle. Als u uw toepassing aanroept ProcessPushNotification , worden in de komende seconden aanvragen verzonden naar App Configuration. Uw toepassing laadt de nieuwe configuratiewaarden kort nadat wijzigingen in het App Configuration archief zijn aangebracht, zonder dat u voortdurend naar updates hoeft te peilen. Als uw toepassing de wijzigingsmelding om welke reden dan ook mist, wordt er nog steeds één keer per dag gecontroleerd op configuratiewijzigingen.

De korte willekeurige vertraging voor het verlopen van de cache is handig als u veel exemplaren van uw toepassing of microservices hebt die verbinding maken met hetzelfde App Configuration-archief met het pushmodel. Zonder deze vertraging kunnen alle exemplaren van uw toepassing aanvragen verzenden naar uw App Configuration-archief zodra ze een wijzigingsmelding ontvangen. Dit kan ertoe leiden dat de App Configuration Service uw archief beperkt. De verloopvertraging van de cache is standaard ingesteld op een willekeurig getal tussen 0 en maximaal 30 seconden, maar u kunt de maximumwaarde via de optionele parameter maxDelay wijzigen in de ProcessPushNotification methode.

De ProcessPushNotification methode neemt een PushNotification object met informatie over welke wijziging in App Configuration de pushmelding heeft geactiveerd. Dit helpt ervoor te zorgen dat alle configuratiewijzigingen tot de triggergebeurtenis worden geladen in de volgende configuratievernieuwing. De SetDirty methode garandeert niet dat de wijziging die de pushmelding activeert, wordt geladen tijdens een onmiddellijke configuratievernieuwing. Als u de SetDirty methode voor het pushmodel gebruikt, raden we u aan in plaats daarvan de ProcessPushNotification methode te gebruiken.

De app lokaal bouwen en uitvoeren

Stel een omgevingsvariabele in met de naam AppConfiguration Verbinding maken ionString en stel deze in op de toegangssleutel voor uw App Configuration-archief.
Als u de app lokaal wilt bouwen en uitvoeren met behulp van de Windows-opdrachtprompt, voert u de volgende opdracht uit en start u de opdrachtprompt opnieuw om de wijziging van kracht te laten worden:
```
setx AppConfigurationConnectionString "connection-string-of-your-app-configuration-store"
```
Als u Windows PowerShell gebruikt, voert u de volgende opdracht uit:
```
$Env:AppConfigurationConnectionString = "connection-string-of-your-app-configuration-store"
```
Als u macOS gebruikt, voert u de volgende opdracht uit:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Als u Linux gebruikt, voert u de volgende opdracht uit:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Voer de volgende opdracht uit om de console-app te bouwen:
```
dotnet build
```
Nadat het bouwen is voltooid, voert u de volgende opdracht uit om de app lokaal uit te voeren:
```
dotnet run
```
Meld u aan bij het Azure-portaal. Selecteer Alle resources en selecteer de instantie van het App Configuration-archief dat u in de quickstart hebt gemaakt.
Selecteer Configuratieverkenner en werk de waarde van de volgende sleutels bij:

Sleutel Weergegeven als

TestApp:Settings:Message Gegevens van Azure App Configuration - bijgewerkt
Wacht even totdat de gebeurtenis kan worden verwerkt. U ziet de bijgewerkte configuratie.

Sleutel	Weergegeven als
TestApp:Settings:Message	Gegevens van Azure App Configuration - bijgewerkt

Resources opschonen

Als u de resources die in dit artikel zijn gemaakt niet wilt blijven gebruiken, verwijdert u de resourcegroep die u hier hebt gemaakt om kosten te voorkomen.

Belangrijk

Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. De resourcegroep en alle resources daarin worden permanent verwijderd. Zorg ervoor dat u niet per ongeluk de verkeerde resourcegroep of resources verwijdert. Als u de resources voor dit artikel in een resourcegroep hebt gemaakt die andere resources bevat die u wilt behouden, moet u elke resource afzonderlijk verwijderen uit het deelvenster in plaats van dat u de resourcegroep verwijdert.

Meld u aan bij de Azure-portal en selecteer Resourcegroepen.
Voer de naam van de resourcegroep in het vak Filteren op naam in.
Selecteer in de resultatenlijst de resourcegroepnaam om een overzicht te bekijken.
Selecteer Resourcegroep verwijderen.
U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Voer de naam van de resourcegroep in ter bevestiging en selecteer Verwijderen.

Na enkele ogenblikken worden de resourcegroep en alle bijbehorende resources verwijderd.

Volgende stappen

In deze zelfstudie hebt u uw .NET-app ingeschakeld om configuratie-instellingen dynamisch te vernieuwen vanuit App Configuration. Als u wilt weten hoe u een door Azure beheerde identiteit kunt gebruiken om de toegang tot App Configuration te stroomlijnen, gaat u verder met de volgende zelfstudie.

Integratie van beheerde identiteit

Share via