Samouczek: używanie konfiguracji dynamicznej przy użyciu odświeżania wypychanego w aplikacji .NET

Artykuł
02/28/2024

Biblioteka kliencka .NET usługi App Configuration obsługuje aktualizowanie konfiguracji na żądanie bez powodowania ponownego uruchomienia aplikacji. Aplikację można skonfigurować do wykrywania zmian w usłudze App Configuration przy użyciu jednego lub obu poniższych metod.

Model sondowania: jest to domyślne zachowanie, które używa sondowania do wykrywania zmian w konfiguracji. Po wygaśnięciu buforowanej wartości ustawienia następne wywołanie TryRefreshAsync lub RefreshAsync wysłanie żądania do serwera w celu sprawdzenia, czy konfiguracja uległa zmianie, i w razie potrzeby ściąga zaktualizowaną konfigurację.
Model wypychania: używa zdarzeń konfiguracji aplikacji do wykrywania zmian w konfiguracji. Po skonfigurowaniu usługi App Configuration w celu wysyłania zdarzeń zmiany wartości klucza do usługi Azure Event Grid aplikacja może użyć tych zdarzeń, aby zoptymalizować łączną liczbę żądań wymaganych do zachowania aktualizacji konfiguracji. Aplikacje mogą subskrybować te elementy bezpośrednio z usługi Event Grid lub za pośrednictwem jednego z obsługiwanych programów obsługi zdarzeń, takich jak element webhook, funkcja platformy Azure lub temat usługi Service Bus.

W tym samouczku pokazano, jak wdrożyć aktualizacje dynamicznej konfiguracji w kodzie przy użyciu odświeżania wypychanych. Jest ona oparta na aplikacji wprowadzonej w samouczku. Przed kontynuowaniem zakończ samouczek: najpierw użyj konfiguracji dynamicznej w aplikacji .NET.

Aby wykonać kroki opisane w tym samouczku, możesz użyć dowolnego edytora kodu. Program Visual Studio Code to doskonała opcja dostępna na platformach Windows, macOS i Linux.

Z tego samouczka dowiesz się, jak wykonywać następujące czynności:

Konfigurowanie subskrypcji w celu wysyłania zdarzeń zmiany konfiguracji z usługi App Configuration do tematu usługi Service Bus
Skonfiguruj aplikację .NET, aby zaktualizować jej konfigurację w odpowiedzi na zmiany w usłudze App Configuration.
Korzystanie z najnowszej konfiguracji w aplikacji.

Wymagania wstępne

Samouczek: używanie konfiguracji dynamicznej w aplikacji .NET
Pakiet Microsoft.Extensions.Configuration.AzureAppConfiguration NuGet w wersji 5.0.0 lub nowszej

Konfigurowanie tematu i subskrypcji usługi Azure Service Bus

W tym samouczku użyto integracji usługi Service Bus dla usługi Event Grid, aby uprościć wykrywanie zmian konfiguracji dla aplikacji, które nie chcą sondować usługi App Configuration pod kątem zmian w sposób ciągły. Zestaw SDK usługi Azure Service Bus udostępnia interfejs API służący do rejestrowania procedury obsługi komunikatów, która może służyć do aktualizowania konfiguracji po wykryciu zmian w usłudze App Configuration. Wykonaj kroki opisane w przewodniku Szybki start: tworzenie tematu i subskrypcji usługi Service Bus przy użyciu witryny Azure Portal w celu utworzenia przestrzeni nazw, tematu i subskrypcji usługi Service Bus.

Po utworzeniu zasobów dodaj następujące zmienne środowiskowe. Będą one używane do rejestrowania programu obsługi zdarzeń w celu zmiany konfiguracji w kodzie aplikacji.

Key	Wartość
ServiceBus Połączenie ionString	ciąg Połączenie ion dla przestrzeni nazw usługi Service Bus
ServiceBusTopic	Nazwa tematu usługi Service Bus
ServiceBusSubscription	Nazwa subskrypcji usługi Service Bus

Konfigurowanie subskrypcji zdarzeń

Otwórz zasób App Configuration w witrynie Azure Portal, a następnie kliknij + Event Subscription w okienku Events .
Wprowadź nazwę elementu Event Subscription i System Topic.
Wybierz element Endpoint Type jako Service Bus Topic, wybierz temat usługi Service Bus, a następnie kliknij pozycję Confirm Selection.
Kliknij, Create aby utworzyć subskrypcję zdarzeń.
Event Subscriptions Kliknij w okienku, Events aby sprawdzić, czy subskrypcja została utworzona pomyślnie.

Uwaga

Podczas subskrybowania zmian konfiguracji można użyć co najmniej jednego filtru w celu zmniejszenia liczby zdarzeń wysyłanych do aplikacji. Można je skonfigurować jako filtry subskrypcji usługi Event Grid lub filtry subskrypcji usługi Service Bus. Na przykład filtr subskrypcji może służyć tylko do subskrybowania zdarzeń pod kątem zmian w kluczu rozpoczynającym się od określonego ciągu.

Rejestrowanie programu obsługi zdarzeń w celu ponownego załadowania danych z usługi App Configuration

Otwórz Program.cs i zaktualizuj plik przy użyciu następującego kodu.

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 wygaśnięcie pamięci podręcznej do krótkiego losowego opóźnienia. Powoduje to przyszłe wywołania RefreshAsync metody lub TryRefreshAsync ponowne zweryfikowanie buforowanych wartości w usłudze App Configuration i zaktualizowanie ich w razie potrzeby. W tym przykładzie rejestrujesz się w celu monitorowania zmian klucza: TestApp:Ustawienia:Message z wygaśnięciem pamięci podręcznej jednego dnia. Oznacza to, że nie zostanie wykonane żadne żądanie do usługi App Configuration przed upływem dnia od ostatniego sprawdzenia. Wywołanie ProcessPushNotification aplikacji spowoduje wysłanie żądań do usługi App Configuration w ciągu najbliższych kilku sekund. Aplikacja załaduje nowe wartości konfiguracji wkrótce po wprowadzeniu zmian w App Configuration magazynie bez konieczności ciągłego sondowania pod kątem aktualizacji. Jeśli aplikacja przegapi powiadomienie o zmianie z jakiegokolwiek powodu, nadal będzie sprawdzać zmiany konfiguracji raz dziennie.

Krótkie losowe opóźnienie wygaśnięcia pamięci podręcznej jest przydatne, jeśli masz wiele wystąpień aplikacji lub mikrousług łączących się z tym samym magazynem App Configuration z modelem wypychania. Bez tego opóźnienia wszystkie wystąpienia aplikacji mogą wysyłać żądania do sklepu App Configuration jednocześnie po otrzymaniu powiadomienia o zmianie. Może to spowodować ograniczenie magazynu przez usługę App Configuration Service. Opóźnienie wygaśnięcia pamięci podręcznej jest domyślnie ustawiona na losową liczbę z zakresu od 0 do maksymalnie 30 sekund, ale można zmienić maksymalną wartość za pomocą opcjonalnego parametru maxDelay na metodę ProcessPushNotification .

Metoda ProcessPushNotification przyjmuje PushNotification obiekt zawierający informacje o tym, które zmiany w usłudze App Configuration wyzwoliły powiadomienie wypychane. Pomaga to upewnić się, że wszystkie zmiany konfiguracji do zdarzenia wyzwalania są ładowane w następującym odświeżeniu konfiguracji. Metoda SetDirty nie gwarantuje zmiany wyzwalanej przez powiadomienie wypychane do załadowania w ramach natychmiastowego odświeżania konfiguracji. Jeśli używasz SetDirty metody dla modelu wypychania, zalecamy użycie ProcessPushNotification metody .

Lokalne kompilowanie i uruchamianie aplikacji

Ustaw zmienną środowiskową o nazwie AppConfiguration Połączenie ionString i ustaw ją na klucz dostępu do magazynu App Configuration.
Aby skompilować i uruchomić aplikację lokalnie przy użyciu wiersza polecenia systemu Windows, uruchom następujące polecenie i uruchom ponownie wiersz polecenia, aby umożliwić wprowadzenie zmiany:
```
setx AppConfigurationConnectionString "<connection-string-of-your-app-configuration-store>"
```
Jeśli używasz programu Windows PowerShell, uruchom następujące polecenie:
```
$Env:AppConfigurationConnectionString = "<connection-string-of-your-app-configuration-store>"
```
Jeśli używasz systemu macOS, uruchom następujące polecenie:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Jeśli używasz systemu Linux, uruchom następujące polecenie:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Uruchom następujące polecenie, aby skompilować aplikację konsolową:
```
dotnet build
```
Po pomyślnym zakończeniu kompilacji uruchom następujące polecenie, aby uruchomić aplikację lokalnie:
```
dotnet run
```
Zaloguj się w witrynie Azure Portal. Wybierz pozycję Wszystkie zasoby i wybierz wystąpienie sklepu App Configuration utworzone w przewodniku Szybki start.
Wybierz pozycję Eksplorator konfiguracji i zaktualizuj wartości następujących kluczy:

Key Wartość

TestApp:Settings:Message Dane z konfiguracji aplikacja systemu Azure — zaktualizowano
Poczekaj chwilę, aby zezwolić na przetworzenie zdarzenia. Zostanie wyświetlona zaktualizowana konfiguracja.

Key	Wartość
TestApp:Settings:Message	Dane z konfiguracji aplikacja systemu Azure — zaktualizowano

Czyszczenie zasobów

Jeśli nie chcesz nadal korzystać z zasobów utworzonych w tym artykule, usuń utworzoną tutaj grupę zasobów, aby uniknąć naliczania opłat.

Ważne

Usunięcie grupy zasobów jest nieodwracalne. Grupa zasobów i wszystkie zasoby w niej są trwale usuwane. Upewnij się, że nie usuniesz przypadkowo nieprawidłowej grupy zasobów ani zasobów. Jeśli zasoby dla tego artykułu zostały utworzone w grupie zasobów zawierającej inne zasoby, które chcesz zachować, usuń każdy zasób oddzielnie z odpowiedniego okienka zamiast usuwać grupę zasobów.

Zaloguj się do witryny Azure Portal i wybierz pozycję Grupy zasobów.
W polu Filtruj według nazwy wprowadź nazwę grupy zasobów.
Na liście wyników wybierz nazwę grupy zasobów, aby wyświetlić przegląd.
Wybierz pozycję Usuń grupę zasobów.
Zobaczysz prośbę o potwierdzenie usunięcia grupy zasobów. Wprowadź nazwę grupy zasobów, aby potwierdzić, a następnie wybierz pozycję Usuń.

Po kilku chwilach grupa zasobów i wszystkie jej zasoby zostaną usunięte.

Następne kroki

W tym samouczku włączono aplikację .NET w celu dynamicznego odświeżania ustawień konfiguracji z poziomu usługi App Configuration. Aby dowiedzieć się, jak używać tożsamości zarządzanej platformy Azure w celu usprawnienia dostępu do usługi App Configuration, przejdź do następnego samouczka.

Integracja tożsamości zarządzanej

Udostępnij za pośrednictwem