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

Den App Configuration .NET Core-klientbiblioteket stöder uppdatering av konfigurationen på begäran utan att göra så 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.

1. 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 skickar nästa anrop till eller en begäran till servern för att kontrollera om konfigurationen har ändrats och hämtar den uppdaterade konfigurationen TryRefreshAsync RefreshAsync om det behövs.

2. Push-modell: Den här App Configuration händelser för att identifiera ändringar i konfigurationen. När App Configuration har ställts in för att skicka ändringshändelser för nyckelvärden till Azure Event Grid kan programmet använda dessa händelser för att optimera det totala antalet begäranden som krävs för att hålla konfigurationen uppdaterad. Program kan välja att prenumerera på dessa antingen direkt från Event Grid eller via en av de händelsehanterare som stöds, till exempel en webhook, en Azure-funktion eller ett Service Bus ämne.

Program kan välja att prenumerera på dessa händelser antingen direkt från Event Grid eller via en web hook eller genom att vidarebefordra händelser till Azure Service Bus. Azure Service Bus SDK tillhandahåller ett API för att registrera en meddelandehanterare som förenklar den här processen för program som antingen inte har någon HTTP-slutpunkt eller som inte vill avse händelser grid-händelser kontinuerligt.

Den här självstudien visar hur du kan implementera dynamiska konfigurationsuppdateringar i koden med hjälp av push-uppdatering. Den bygger på appen som introducerades i snabbstarterna. Innan du fortsätter slutför du Skapa en .NET Core-app med App Configuration först.

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

I den här guiden får du lära dig att:

Förutsättningar

Om du vill göra den här självstudien installerar du .NET Core SDK.

Om du inte har en Azure-prenumerationkan du skapa ett kostnads fritt konto innan du börjar.

Konfigurera Azure Service Bus ämne och prenumeration

Den här självstudien använder Service Bus-integrering för Event Grid för att förenkla identifieringen av konfigurationsändringar för program som inte vill avse App Configuration efter ä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 Snabbstart: Använd Azure Portal för att skapa ett Service Bus och en prenumeration för att skapa ett Service Bus-namnområde, 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.

Konfigurera händelseprenumeration

1. Öppna App Configuration resurs i Azure Portal och klicka sedan + Event Subscription på i Events fönstret.

   

2. Ange ett namn för Event Subscription och System Topic .

   

3. Välj Endpoint Type som Service Bus Topic , välj det Service Bus ämnet och klicka sedan på Confirm Selection .

   

4. Klicka på Create för att skapa händelseprenumerationen.

5. Klicka på Event Subscriptions i fönstret för att verifiera att Events prenumerationen har skapats.

   

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

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

using Microsoft.Azure.ServiceBus;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;
using System;
using System.Diagnostics;
using System.Text;
using System.Text.Json;
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(30))  // 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);
            SubscriptionClient serviceBusClient = new SubscriptionClient(serviceBusConnectionString, serviceBusTopic, serviceBusSubscription);

            serviceBusClient.RegisterMessageHandler(
                handler: (message, cancellationToken) =>
               {
                   string messageText = Encoding.UTF8.GetString(message.Body);
                   JsonElement messageData = JsonDocument.Parse(messageText).RootElement.GetProperty("data");
                   string key = messageData.GetProperty("key").GetString();
                   Console.WriteLine($"Event received for Key = {key}");

                   _refresher.SetDirty();
                   return Task.CompletedTask;
               },
                exceptionReceivedHandler: (exceptionargs) =>
                {
                    Console.WriteLine($"{exceptionargs.Exception}");
                    return Task.CompletedTask;
                });
        }
    }
}

Metoden SetDirty används för att ange det cachelagrade värdet för nyckelvärden som registrerats för uppdatering som "dirty". Detta säkerställer att nästa anrop RefreshAsync till TryRefreshAsync eller validerar cachelagrade värden på App Configuration och uppdaterar dem om det behövs.

En slumpmässig fördröjning läggs till innan det cachelagrade värdet markeras som felfri för att minska potentiell begränsning om flera instanser uppdateras samtidigt. Standardvärdet för maximal fördröjning innan det cachelagrade värdet markeras som felaktigt är 30 sekunder, men kan åsidosättas genom att skicka en TimeSpan valfri parameter till metoden SetDirty .

Skapa och köra appen lokalt

1. Ange en miljövariabel med namnet AppConfigurationConnectionString och ställ in den på åtkomstnyckeln till App Configuration store. Om du använder Windows 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 eller Linux kör du följande kommando:

    export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
   

2. Kör följande kommando för att skapa konsolappen:

    dotnet build
   

3. När bygget har slutförts kör du följande kommando för att köra appen lokalt:

    dotnet run
   

   

4. Logga in på Azure-portalen. Välj Alla resurser och välj den App Configuration Store-instans som du skapade i snabbstarten.

5. 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

6. Vänta i 30 sekunder så att händelsen kan bearbetas och konfigurationen uppdateras.

   

Rensa resurser

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

1. Logga in på Azure Portaloch välj resurs grupper.
2. I rutan Filtrera efter namn anger du namnet på din resurs grupp.
3. I listan resultat väljer du resurs gruppens namn för att se en översikt.
4. Välj Ta bort resursgrupp.
5. Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resurs gruppen som ska bekräftas och välj ta bort.

Efter en liten stund tas resurs gruppen och alla dess resurser bort.

Nästa steg

I den här självstudien har du aktiverat .NET Core-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 App Configuration kan du fortsätta till nästa självstudie.