Oktatóanyag: Dinamikus konfiguráció használata leküldéses frissítéssel egy .NET-alkalmazásban

Cikk
03/05/2024

Az alkalmazáskonfiguráció .NET-ügyfélkódtára támogatja a konfiguráció igény szerinti frissítését anélkül, hogy az alkalmazás újraindulhat. Az alkalmazás konfigurálható úgy, hogy az alkalmazáskonfiguráció változásait az alábbi két módszer egyikével vagy mindkettővel észlelje.

Lekérdezési modell: Ez az alapértelmezett viselkedés, amely lekérdezés használatával észleli a konfiguráció változásait. Ha egy beállítás gyorsítótárazott értéke lejár, a következő hívás vagy TryRefreshAsyncRefreshAsync kérés küldése a kiszolgálónak annak ellenőrzésére, hogy a konfiguráció megváltozott-e, és szükség esetén lekéri a frissített konfigurációt.
Leküldéses modell: Alkalmazáskonfigurációs események használatával észleli a konfiguráció változásait. Miután az alkalmazáskonfiguráció be van állítva, hogy kulcsértékváltozási eseményeket küldjön az Azure Event Gridnek, az alkalmazás ezeket az eseményeket használhatja a konfiguráció frissítéséhez szükséges kérések teljes számának optimalizálására. Az alkalmazások közvetlenül az Event Gridből vagy az egyik támogatott eseménykezelőn keresztül, például webhookon, Azure-függvényen vagy Service Bus-témakörön keresztül is feliratkozhatnak ezekre.

Ez az oktatóanyag bemutatja, hogyan implementálhat dinamikus konfigurációs frissítéseket a kódban leküldéses frissítéssel. Az oktatóanyagban bemutatott alkalmazásra épül. A folytatás előtt fejezze be az oktatóanyagot: Először használjon dinamikus konfigurációt egy .NET-alkalmazásban .

Az oktatóanyag lépéseit bármely kódszerkesztővel elvégezheti. A Visual Studio Code kiváló lehetőség, amely Windows, macOS és Linux platformokon érhető el.

Ebben az oktatóanyagban az alábbiakkal fog megismerkedni:

Előfizetés beállítása a konfigurációváltozási események alkalmazáskonfigurációból Service Bus-témakörbe való küldéséhez
Állítsa be a .NET-alkalmazást úgy, hogy az alkalmazáskonfiguráció változásaira reagálva frissítse a konfigurációját.
Használja az alkalmazás legújabb konfigurációját.

Előfeltételek

Oktatóanyag: Dinamikus konfiguráció használata .NET-alkalmazásban
NuGet-csomag Microsoft.Extensions.Configuration.AzureAppConfiguration 5.0.0-s vagy újabb verziója

Az Azure Service Bus-témakör és -előfizetés beállítása

Ez az oktatóanyag az Event Grid Service Bus-integrációjával egyszerűsíti az olyan alkalmazások konfigurációs változásainak észlelését, amelyek nem kívánják folyamatosan lekérdezni az alkalmazáskonfigurációt a módosításokhoz. Az Azure Service Bus SDK egy API-t biztosít egy üzenetkezelő regisztrálásához, amely a konfiguráció frissítésére használható, amikor a rendszer módosításokat észlel az Alkalmazáskonfigurációban. Kövesse a rövid útmutató lépéseit: Service Bus-témakör és -előfizetés létrehozásához használja az Azure Portalt service bus-névtér, témakör és előfizetés létrehozásához.

Az erőforrások létrehozása után adja hozzá a következő környezeti változókat. Ezekkel regisztrál egy eseménykezelőt az alkalmazáskód konfigurációs változásaihoz.

Kulcs	Érték
ServiceBus Csatlakozás ionString	a service bus névterének Csatlakozás ion sztringje
ServiceBusTopic	A Service Bus-témakör neve
ServiceBusSubscription	A service bus-előfizetés neve

Esemény-előfizetés beállítása

Nyissa meg az Alkalmazáskonfiguráció erőforrást az Azure Portalon, majd kattintson a Events panelen+ Event Subscription.
Adja meg a Event Subscription név és a System Topic.
Válassza ki a Endpoint Type as elemet Service Bus Topic, válassza ki a Service Bus-témakört, majd kattintson a gombra Confirm Selection.
Kattintson ide Create az esemény-előfizetés létrehozásához.
Kattintson a panelre Event Subscriptions annak Events ellenőrzéséhez, hogy az előfizetés sikeresen létrejött-e.

Feljegyzés

A konfigurációváltozásokra való feliratkozáskor egy vagy több szűrő használatával csökkenthető az alkalmazásnak küldött események száma. Ezek event Grid-előfizetési szűrőkként vagy Service Bus-előfizetés-szűrőkként konfigurálhatók. Az előfizetési szűrővel például csak egy adott sztringgel kezdődő kulcs módosításaira lehet előfizetni az eseményekre.

Eseménykezelő regisztrálása az adatok alkalmazáskonfigurációból való újratöltéséhez

Nyissa meg Program.cs , és frissítse a fájlt az alábbi kóddal.

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

A ProcessPushNotification metódus rövid véletlenszerű késleltetésre állítja vissza a gyorsítótár lejáratát. Ez a gyorsítótárazott értékek alkalmazáskonfigurációval való későbbi hívását RefreshAsync vagy TryRefreshAsync újbóli érvényesítését eredményezi, és szükség szerint frissíti őket. Ebben a példában regisztrál a következő kulcs módosításainak figyeléséhez: TestApp:Gépház:Message with a cache expiration of one day. Ez azt jelenti, hogy az utolsó ellenőrzés óta egy nap leteltéig nem lesz kérelem az alkalmazáskonfigurációra. Az alkalmazás meghívásával ProcessPushNotification a következő néhány másodpercben kéréseket küld az alkalmazáskonfigurációnak. Az alkalmazás röviddel a módosítások után betölti az új konfigurációs értékeket az App Configuration áruházban anélkül, hogy folyamatosan le kellene keresnie a frissítéseket. Ha az alkalmazás bármilyen okból elmulasztja a változásértesítést, naponta egyszer még mindig ellenőrzi a konfigurációs módosításokat.

A gyorsítótár lejáratának rövid véletlenszerű késleltetése akkor hasznos, ha az alkalmazás vagy a mikroszolgáltatások számos példánya csatlakozik ugyanahhoz az alkalmazáskonfigurációs áruházhoz a leküldéses modellel. E késedelem nélkül az alkalmazás összes példánya egyszerre küldhet kéréseket az Alkalmazáskonfigurációs áruházba, amint változásértesítést kapnak. Ez azt okozhatja, hogy az App Configuration Service szabályozni tudja az áruházat. A gyorsítótár lejárati késleltetése alapértelmezés szerint véletlenszerű számra van 0 és legfeljebb 30 másodperc között, de a maximális értéket az opcionális paraméterrel maxDelay módosíthatja a ProcessPushNotification metódusra.

A ProcessPushNotification metódus egy PushNotification olyan objektumot vesz fel, amely információkat tartalmaz arról, hogy az Alkalmazáskonfiguráció mely módosítása váltotta ki a leküldéses értesítést. Ez segít biztosítani, hogy az eseményindító esemény összes konfigurációmódosítása be legyen töltve a következő konfigurációfrissítésbe. A SetDirty metódus nem garantálja az azonnali konfigurációfrissítésbe betöltendő leküldéses értesítést aktiváló módosítást. Ha a leküldéses modellhez használja a SetDirty metódust, javasoljuk, hogy inkább a metódust ProcessPushNotification használja.

Az alkalmazás helyi létrehozása és futtatása

Állítson be egy AppConfiguration Csatlakozás ionString nevű környezeti változót, és állítsa be az App Configuration Store hozzáférési kulcsára.
Ha helyileg szeretné létrehozni és futtatni az alkalmazást a Windows parancssorával, futtassa a következő parancsot, majd indítsa újra a parancssort a módosítás érvénybe lépésének engedélyezéséhez:
```
setx AppConfigurationConnectionString "connection-string-of-your-app-configuration-store"
```
Windows PowerShell használata esetén futtassa a következő parancsot:
```
$Env:AppConfigurationConnectionString = "connection-string-of-your-app-configuration-store"
```
MacOS használata esetén futtassa a következő parancsot:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Linux használata esetén futtassa a következő parancsot:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Futtassa a következő parancsot a konzolalkalmazás létrehozásához:
```
dotnet build
```
A build sikeres befejezése után futtassa a következő parancsot az alkalmazás helyi futtatásához:
```
dotnet run
```
Jelentkezzen be az Azure Portalra. Válassza az Összes erőforrás lehetőséget, és válassza ki a rövid útmutatóban létrehozott App Configuration Store-példányt.
Válassza a Konfigurációkezelőt, és frissítse az alábbi kulcsok értékeit:

Kulcs Érték

TestApp:Gépház:Message Adatok Azure-alkalmazás konfigurációból – Frissítve
Várjon néhány percet az esemény feldolgozásának engedélyezéséhez. Ekkor megjelenik a frissített konfiguráció.

Kulcs	Érték
TestApp:Gépház:Message	Adatok Azure-alkalmazás konfigurációból – Frissítve

Az erőforrások eltávolítása

Ha nem szeretné folytatni a cikkben létrehozott erőforrások használatát, törölje az itt létrehozott erőforráscsoportot a díjak elkerülése érdekében.

Fontos

Az erőforráscsoport törlése nem vonható vissza. Az erőforráscsoport és a benne lévő összes erőforrás véglegesen törlődik. Győződjön meg arról, hogy nem véletlenül törli a rossz erőforráscsoportot vagy erőforrásokat. Ha a cikk erőforrásait olyan erőforráscsoporton belül hozta létre, amely más megtartani kívánt erőforrásokat tartalmaz, törölje az egyes erőforrásokat a megfelelő panelről az erőforráscsoport törlése helyett.

Jelentkezzen be az Azure Portalra, és válassza ki az Erőforráscsoportokat.
A Szűrés név szerint mezőbe írja be az erőforráscsoport nevét.
Az eredménylistában válassza ki az erőforráscsoport nevét az áttekintés megtekintéséhez.
Válassza az Erőforráscsoport törlése elemet.
A rendszer az erőforráscsoport törlésének megerősítését kéri. Adja meg a megerősítéshez az erőforráscsoport nevét, és válassza a Törlés lehetőséget.

Néhány pillanat múlva az erőforráscsoport és annak összes erőforrása törlődik.

Következő lépések

Ebben az oktatóanyagban engedélyezte a .NET-alkalmazást, hogy dinamikusan frissítse a konfigurációs beállításokat az Alkalmazáskonfigurációból. Ha szeretné megtudni, hogyan használhat azure-beli felügyelt identitást az alkalmazáskonfigurációhoz való hozzáférés gördülékenyebbé tételéhez, folytassa a következő oktatóanyagban.

Felügyelt identitás integrációja

Megosztás a következőn keresztül: