Självstudie: Använda dynamisk konfiguration med push-uppdatering i en .NET-app

Artikel
02/28/2024

Klientbiblioteket för App Configuration .NET stöder uppdatering av konfigurationen på begäran utan att ett program startas om. Ett program kan konfigureras för att identifiera ändringar i App Configuration med hjälp av en eller båda av följande två metoder.

Avsökningsmodell: Det här är standardbeteendet som använder avsökning för att identifiera ändringar i konfigurationen. När det cachelagrade värdet för en inställning upphör att gälla anropar eller RefreshAsync skickar nästa begäran till TryRefreshAsync servern för att kontrollera om konfigurationen har ändrats och hämtar den uppdaterade konfigurationen om det behövs.
Push-modell: Detta använder appkonfigurationshändelser för att identifiera ändringar i konfigurationen. När App Configuration har konfigurerats för att skicka viktiga värdeändringshändelser till Azure Event Grid kan programmet använda dessa händelser för att optimera det totala antalet begäranden som behövs för att hålla konfigurationen uppdaterad. Program kan välja att prenumerera på dessa antingen direkt från Event Grid eller via någon av de händelsehanterare som stöds, till exempel en webhook, en Azure-funktion eller ett Service Bus-ämne.

Den här självstudien visar hur du kan implementera dynamiska konfigurationsuppdateringar i koden med push-uppdatering. Den bygger på appen som introducerades i självstudien. Innan du fortsätter slutför du Självstudie: Använd dynamisk konfiguration i en .NET-app först.

Du kan använda valfri kodredigerare för att utföra stegen i den här självstudien. Visual Studio Code är ett utmärkt alternativ som är tillgängligt på Plattformarna Windows, macOS och Linux.

I den här självstudien lär du dig att:

Konfigurera en prenumeration för att skicka konfigurationsändringshändelser från App Configuration till ett Service Bus-ämne
Konfigurera .NET-appen för att uppdatera konfigurationen som svar på ändringar i App Configuration.
Använd den senaste konfigurationen i ditt program.

Förutsättningar

Självstudie: Använda dynamisk konfiguration i en .NET-app
NuGet-paketversion Microsoft.Extensions.Configuration.AzureAppConfiguration 5.0.0 eller senare

Konfigurera Azure Service Bus-ämne och prenumeration

I den här självstudien används Service Bus-integreringen för Event Grid för att förenkla identifieringen av konfigurationsändringar för program som inte vill avsöka App Configuration för ändringar kontinuerligt. Azure Service Bus SDK tillhandahåller ett API för att registrera en meddelandehanterare som kan användas för att uppdatera konfigurationen när ändringar identifieras i App Configuration. Följ stegen i snabbstarten : Använd Azure-portalen för att skapa ett Service Bus-ämne och en prenumeration för att skapa en Service Bus-namnrymd, ett ämne och en prenumeration.

När resurserna har skapats lägger du till följande miljövariabler. Dessa används för att registrera en händelsehanterare för konfigurationsändringar i programkoden.

Tangent	Värde
ServiceBus Anslut ionString	Anslut ionssträng för Service Bus-namnområdet
ServiceBusTopic	Namn på Service Bus-ämnet
ServiceBusSubscription	Namnet på Service Bus-prenumerationen

Konfigurera händelseprenumeration

Öppna appkonfigurationsresursen i Azure-portalen och klicka sedan på + Event Subscription i fönstret Events .
Ange ett namn för Event Subscription och System Topic.
Endpoint Type Välj som Service Bus Topic, välj avsnittet Service Bus och klicka sedan på Confirm Selection.
Klicka på Create för att skapa händelseprenumerationen.
Klicka på Event Subscriptions i fönstret Events för att verifiera att prenumerationen har skapats.

Kommentar

När du prenumererar på konfigurationsändringar kan ett eller flera filter användas för att minska antalet händelser som skickas till ditt program. Dessa kan konfigureras antingen som Event Grid-prenumerationsfilter eller Service Bus-prenumerationsfilter. Ett prenumerationsfilter kan till exempel bara användas för att prenumerera på händelser för ändringar i en nyckel som börjar med en specifik sträng.

Registrera händelsehanteraren för att läsa in data igen från App Configuration

Öppna Program.cs och uppdatera filen med följande kod.

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

Metoden ProcessPushNotification återställer cachens giltighetstid till en kort slumpmässig fördröjning. Detta gör att framtida anrop till RefreshAsync eller TryRefreshAsync validerar om cachelagrade värden mot App Configuration och uppdaterar dem efter behov. I det här exemplet registrerar du dig för att övervaka ändringar av nyckeln: TestApp:Inställningar:Message med en cachetid på en dag. Det innebär att ingen begäran till App Configuration görs innan en dag har passerat sedan den senaste kontrollen. Genom att anropa ProcessPushNotification ditt program skickas begäranden till App Configuration inom de närmaste sekunderna. Programmet läser in de nya konfigurationsvärdena strax efter att ändringar inträffat i arkivet App Configuration utan att ständigt behöva söka efter uppdateringar. Om ditt program av någon anledning missar ändringsmeddelandet kommer det fortfarande att söka efter konfigurationsändringar en gång om dagen.

Den korta slumpmässiga fördröjningen för cacheförfallotid är användbar om du har många instanser av ditt program eller dina mikrotjänster som ansluter till samma App Configuration Store med push-modellen. Utan denna fördröjning kan alla instanser av ditt program skicka begäranden till appkonfigurationsarkivet samtidigt så snart de får ett ändringsmeddelande. Detta kan göra att App Configuration Service begränsar din butik. Cacheförfallofördröjningen är inställd på ett slumpmässigt tal mellan 0 och högst 30 sekunder som standard, men du kan ändra det maximala värdet via den valfria parametern maxDelay till ProcessPushNotification metoden.

Metoden ProcessPushNotification tar in ett PushNotification objekt som innehåller information om vilken ändring i App Configuration som utlöste push-meddelandet. Detta säkerställer att alla konfigurationsändringar fram till utlösande händelsen läses in i följande konfigurationsuppdatering. Metoden SetDirty garanterar inte den ändring som utlöser att push-meddelandet läses in i en omedelbar konfigurationsuppdatering. Om du använder SetDirty metoden för push-modellen rekommenderar vi att du använder ProcessPushNotification metoden i stället.

Skapa och köra appen lokalt

Ange en miljövariabel med namnet AppConfiguration Anslut ionString och ange åtkomstnyckeln till appkonfigurationsarkivet.
Om du vill skapa och köra appen lokalt med hjälp av Windows-kommandotolken kör du följande kommando och startar om kommandotolken så att ändringen börjar gälla:
```
setx AppConfigurationConnectionString "<connection-string-of-your-app-configuration-store>"
```
Om du använder Windows PowerShell kör du följande kommando:
```
$Env:AppConfigurationConnectionString = "<connection-string-of-your-app-configuration-store>"
```
Om du använder macOS kör du följande kommando:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Om du använder Linux kör du följande kommando:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Kör följande kommando för att skapa konsolappen:
```
dotnet build
```
När bygget har slutförts kör du följande kommando för att köra appen lokalt:
```
dotnet run
```
Logga in på Azure-portalen. Välj Alla resurser och välj den App Configuration Store-instans som du skapade i snabbstarten.
Välj Configuration Explorer och uppdatera värdena för följande nycklar:

Tangent Värde

TestApp:Settings:Message Data från Azure App Configuration – Uppdaterad
Vänta en stund så att händelsen kan bearbetas. Du ser den uppdaterade konfigurationen.

Tangent	Värde
TestApp:Settings:Message	Data från Azure App Configuration – Uppdaterad

Rensa resurser

Om du inte vill fortsätta använda resurserna som skapas i den här artikeln tar du bort resursgruppen som du skapade här för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. Resursgruppen och alla resurser i den tas bort permanent. Se till att du inte oavsiktligt tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för den här artikeln i en resursgrupp som innehåller andra resurser som du vill behålla tar du bort varje resurs individuellt från respektive fönster i stället för att ta bort resursgruppen.

Logga in på Azure-portalen och välj Resursgrupper.
I rutan Filtrera efter namn anger du namnet på resursgruppen.
I resultatlistan väljer du resursgruppens namn för att se en översikt.
Välj Ta bort resursgrupp.
Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och alla dess resurser bort.

Nästa steg

I den här självstudien har du aktiverat .NET-appen för att dynamiskt uppdatera konfigurationsinställningarna från App Configuration. Om du vill lära dig hur du använder en hanterad Azure-identitet för att effektivisera åtkomsten till App Configuration fortsätter du till nästa självstudie.

Integrering av hanterad identitet

Dela via