Kurz: Použití dynamické konfigurace pomocí nabízené aktualizace v aplikaci .NET

Článek
03/05/2024

Klientská knihovna .NET App Configuration podporuje aktualizaci konfigurace na vyžádání, aniž by to způsobilo restartování aplikace. Aplikaci je možné nakonfigurovat tak, aby detekovala změny v konfiguraci aplikace pomocí jednoho nebo obou následujících dvou přístupů.

Model hlasování: Toto je výchozí chování, které používá dotazování k detekci změn v konfiguraci. Jakmile vyprší platnost hodnoty nastavení uložené v mezipaměti, další volání TryRefreshAsync nebo RefreshAsync odeslání požadavku na server, který zkontroluje, jestli se konfigurace změnila, a v případě potřeby vyžádá aktualizovanou konfiguraci.
Model nabízených oznámení: K detekci změn v konfiguraci se používají události konfigurace aplikace. Jakmile je služba App Configuration nastavená tak, aby odesílala události změn klíčové hodnoty do služby Azure Event Grid, může aplikace tyto události použít k optimalizaci celkového počtu požadavků potřebných k aktualizaci konfigurace. Aplikace se můžou přihlásit k odběru buď přímo z Event Gridu, nebo prostřednictvím některého z podporovaných obslužných rutin událostí, jako je webhook, funkce Azure nebo téma služby Service Bus.

V tomto kurzu se dozvíte, jak můžete implementovat dynamické aktualizace konfigurace v kódu pomocí nabízené aktualizace. Sestavuje se v aplikaci představené v tomto kurzu. Než budete pokračovat, dokončete kurz: Nejprve použijte dynamickou konfiguraci v aplikaci .NET.

Kroky v tomto kurzu můžete provést pomocí libovolného editoru kódu. Visual Studio Code je vynikající volbou, která je dostupná na platformách Windows, macOS a Linux.

V tomto kurzu se naučíte:

Nastavení předplatného pro odesílání událostí změn konfigurace ze služby App Configuration do tématu služby Service Bus
Nastavte aplikaci .NET tak, aby aktualizovala konfiguraci v reakci na změny v App Configuration.
Využití nejnovější konfigurace ve vaší aplikaci

Požadavky

Kurz: Použití dynamické konfigurace v aplikaci .NET
Balíček Microsoft.Extensions.Configuration.AzureAppConfiguration NuGet verze 5.0.0 nebo novější

Nastavení tématu a předplatného služby Azure Service Bus

Tento kurz používá integraci služby Service Bus pro Event Grid ke zjednodušení detekce změn konfigurace pro aplikace, které nechtějí dotazovat konfiguraci aplikací na změny nepřetržitě. Sada Azure Service Bus SDK poskytuje rozhraní API pro registraci obslužné rutiny zpráv, která se dá použít k aktualizaci konfigurace při zjištění změn v konfiguraci aplikace. Postupujte podle kroků v rychlém startu : Pomocí webu Azure Portal vytvořte téma a předplatné služby Service Bus a vytvořte obor názvů, téma a předplatné služby Service Bus.

Po vytvoření prostředků přidejte následující proměnné prostředí. Ty se použijí k registraci obslužné rutiny události pro změny konfigurace v kódu aplikace.

Key	Hodnota
ServiceBus Připojení ionString	řetězec Připojení ion pro obor názvů služby Service Bus
ServiceBusTopic	Název tématu služby Service Bus
Podsítě služby ServiceBus	Název předplatného služby Service Bus

Nastavení odběru událostí

Na webu Azure Portal otevřete prostředek App Configuration a potom klikněte + Event Subscription do podokna Events .
Zadejte název Event Subscription a název System Topic.
Vyberte jako Endpoint Type Service Bus Topicpoložku , vyberte téma služby Service Bus a klikněte na Confirm Selectiontlačítko .
Kliknutím vytvoříte Create odběr události.
Event Subscriptions Kliknutím do Events podokna ověřte, že se předplatné úspěšně vytvořilo.

Poznámka:

Při přihlášení k odběru změn konfigurace je možné použít jeden nebo více filtrů ke snížení počtu událostí odeslaných do vaší aplikace. Můžete je nakonfigurovat buď jako filtry odběru služby Event Grid, nebo jako filtry odběru služby Service Bus. Filtr odběru se například dá použít jenom k přihlášení k odběru událostí pro změny v klíči, který začíná konkrétním řetězcem.

Registrace obslužné rutiny události pro opětovné načtení dat z konfigurace aplikace

Otevřete Program.cs a aktualizujte soubor následujícím kódem.

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

Metoda ProcessPushNotification resetuje vypršení platnosti mezipaměti na krátkou náhodnou prodlevu. To způsobí budoucí volání RefreshAsync nebo TryRefreshAsync opětovné ověření hodnot uložených v mezipaměti ve službě App Configuration a jejich aktualizaci podle potřeby. V tomto příkladu se zaregistrujete, abyste mohli monitorovat změny klíče: TestApp:Nastavení:Message s vypršením platnosti mezipaměti jednoho dne. To znamená, že od poslední kontroly se neprodá žádná žádost o konfiguraci aplikace. ProcessPushNotification Zavoláním aplikace odešlete žádosti do konfigurace aplikace během několika sekund. Vaše aplikace načte nové konfigurační hodnoty krátce po změně v App Configuration úložišti, aniž by se museli neustále dotazovat na aktualizace. V případě, že vaše aplikace z nějakého důvodu zmešká oznámení o změně, bude stále kontrolovat změny konfigurace jednou denně.

Krátké náhodné zpoždění vypršení platnosti mezipaměti je užitečné, pokud máte mnoho instancí aplikace nebo mikroslužeb, které se připojují ke stejnému úložišti App Configuration s modelem nabízených oznámení. Bez tohoto zpoždění by všechny instance vaší aplikace mohly odesílat žádosti do vašeho App Configuration Storu současně, jakmile obdrží oznámení o změně. To může způsobit omezení úložiště službou App Configuration Service. Zpoždění vypršení platnosti mezipaměti je ve výchozím nastavení nastavené na náhodné číslo od 0 do maximálně 30 sekund, ale maximální hodnotu můžete změnit pomocí volitelného parametru maxDelay na metodu ProcessPushNotification .

Metoda ProcessPushNotification přebírá PushNotification objekt obsahující informace o tom, která změna v konfiguraci aplikace aktivovala nabízené oznámení. To pomáhá zajistit, aby se všechny změny konfigurace až do události triggeru načetly v následující aktualizaci konfigurace. Tato SetDirty metoda nezaručuje změnu, která aktivuje načtení nabízeného oznámení v okamžité aktualizaci konfigurace. Pokud používáte metodu SetDirty pro model nabízených oznámení, doporučujeme místo toho použít metodu ProcessPushNotification .

Sestavení a místní spuštění aplikace

Nastavte proměnnou prostředí s názvem AppConfiguration Připojení ionString a nastavte ji na přístupový klíč k vašemu App Configuration Storu.
Pokud chcete aplikaci sestavit a spustit místně pomocí příkazového řádku Windows, spusťte následující příkaz a restartujte příkazový řádek, aby se změna projevila:
```
setx AppConfigurationConnectionString "<connection-string-of-your-app-configuration-store>"
```
Pokud používáte Windows PowerShell, spusťte následující příkaz:
```
$Env:AppConfigurationConnectionString = "<connection-string-of-your-app-configuration-store>"
```
Pokud používáte macOS, spusťte následující příkaz:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Pokud používáte Linux, spusťte následující příkaz:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Spuštěním následujícího příkazu sestavte konzolovou aplikaci:
```
dotnet build
```
Po úspěšném dokončení sestavení spusťte aplikaci místně spuštěním následujícího příkazu:
```
dotnet run
```
Přihlaste se k portálu Azure. Vyberte Všechny prostředky a vyberte instanci app Configuration Storu, kterou jste vytvořili v rychlém startu.
Vyberte Configuration Explorer a aktualizujte hodnoty následujících klíčů:

Key Hodnota

TestApp:Nastavení:Message Data z konfigurace Aplikace Azure – aktualizována
Chvíli počkejte, než se událost zpracuje. Zobrazí se aktualizovaná konfigurace.

Key	Hodnota
TestApp:Nastavení:Message	Data z konfigurace Aplikace Azure – aktualizována

Vyčištění prostředků

Pokud nechcete dál používat prostředky vytvořené v tomto článku, odstraňte skupinu prostředků, kterou jste tady vytvořili, abyste se vyhnuli poplatkům.

Důležité

Odstranění skupiny prostředků je nevratné. Skupina prostředků a všechny prostředky v ní se trvale odstraní. Ujistěte se, že omylem neodstraníte nesprávnou skupinu prostředků nebo prostředky. Pokud jste vytvořili prostředky pro tento článek ve skupině prostředků, která obsahuje další prostředky, které chcete zachovat, odstraňte jednotlivé prostředky z příslušného podokna místo odstranění skupiny prostředků.

Přihlaste se k webu Azure Portal a vyberte skupiny prostředků.
Do pole Filtrovat podle názvu zadejte název vaší skupiny prostředků.
V seznamu výsledků vyberte název skupiny prostředků, abyste zobrazili přehled.
Vyberte Odstranit skupinu prostředků.
Zobrazí se výzva k potvrzení odstranění skupiny prostředků. Potvrďte název skupiny prostředků a vyberte Odstranit.

Po chvíli se skupina prostředků a všechny její prostředky odstraní.

Další kroky

V tomto kurzu jste povolili aplikaci .NET tak, aby dynamicky aktualizovala nastavení konfigurace z app Configuration. Pokud chcete zjistit, jak pomocí spravované identity Azure zjednodušit přístup ke službě App Configuration, pokračujte dalším kurzem.

Integrace spravované identity

Sdílet prostřednictvím