Zelfstudie: Dynamische configuratie gebruiken met pushvernieuwing in een .NET Core-app

De App Configuration .NET Core-clientbibliotheek ondersteunt het bijwerken van de configuratie op aanvraag zonder dat een toepassing opnieuw wordt gestart. Een toepassing kan worden geconfigureerd voor het detecteren van wijzigingen in App Configuration met behulp van een of beide van de volgende twee benaderingen.

1. Poll-model: dit is het standaardgedrag dat polling gebruikt om wijzigingen in de configuratie te detecteren. Zodra de waarde van een instelling in de cache is verlopen, wordt bij de volgende aanroep naar of een aanvraag naar de server gestuurd om te controleren of de configuratie is gewijzigd en wordt indien nodig de bijgewerkte configuratie TryRefreshAsync RefreshAsync opgevraagd.

2. Pushmodel: hierbij wordt gebruikgemaakt App Configuration gebeurtenissen om wijzigingen in de configuratie te detecteren. Zodra App Configuration is ingesteld voor het verzenden van belangrijke waardewijzigingsgebeurtenissen naar Azure Event Grid, kan de toepassing deze gebeurtenissen gebruiken om het totale aantal aanvragen te optimaliseren dat nodig is om de configuratie bijgewerkt te houden. Toepassingen kunnen ervoor kiezen om zich rechtstreeks vanuit Event Grid op deze gebeurtenissen te abonneren, of via een van de ondersteunde gebeurtenis-handlers, zoals een webhook, een Azure-functie of een Service Bus onderwerp.

Toepassingen kunnen ervoor kiezen om zich rechtstreeks vanuit het Event Grid of via een web hook te abonneren op deze gebeurtenissen, of door gebeurtenissen door testuren naar Azure Service Bus. De Azure Service Bus SDK biedt een API voor het registreren van een berichten-handler die dit proces vereenvoudigt voor toepassingen die geen HTTP-eindpunt hebben of het gebeurtenisraster niet continu willen controleren op wijzigingen.

Deze zelfstudie laat zien hoe u dynamische configuratie-updates in uw code kunt implementeren met behulp van pushvernieuwing. Dit is gebaseerd op de app die is geïntroduceerd in de quickstarts. Volg eerst Een .NET Core-app maken met App Configuration voordat u verder gaat.

U kunt elke code-editor gebruiken om de stappen in deze zelfstudie uit te voeren. Visual Studio Code is een uitstekende optie die beschikbaar is op de Windows-, macOS- en Linux-platforms.

In deze zelfstudie leert u het volgende:

Vereisten

Als u deze zelfstudie wilt uitvoeren, installeert u de .NET Core SDK.

Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.

Azure-Service Bus en -abonnement instellen

In deze zelfstudie wordt de Service Bus-integratie voor Event Grid gebruikt om de detectie van configuratiewijzigingen te vereenvoudigen voor toepassingen die geen poll-App Configuration continu op wijzigingen willen. De Azure Service Bus SDK biedt een API voor het registreren van een berichten-handler die kan worden gebruikt om de configuratie bij te werken wanneer wijzigingen worden gedetecteerd in App Configuration. Volg de stappen in de snelstart: Gebruik de Azure Portal om een Service Bus-onderwerp en -abonnement te maken om een Service Bus-naamruimte, -onderwerp en -abonnement te maken.

Zodra de resources zijn gemaakt, voegt u de volgende omgevingsvariabelen toe. Deze worden gebruikt om een gebeurtenis-handler te registreren voor configuratiewijzigingen in de toepassingscode.

Gebeurtenisabonnement instellen

1. Open de App Configuration resource in het Azure Portal klik vervolgens + Event Subscription op in het Events deelvenster.

   

2. Voer een naam in voor Event Subscription de en de System Topic .

   

3. Selecteer de Endpoint Type als , selecteer het Service Bus en klik vervolgens op Service Bus Topic Confirm Selection .

   

4. Klik op Create om het gebeurtenisabonnement te maken.

5. Klik in Event Subscriptions het deelvenster om te controleren of het abonnement is Events gemaakt.

   

Gebeurtenis-handler registreren om gegevens opnieuw te laden App Configuration

Open Program.cs en werk het bestand bij met de volgende code.

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

De methode SetDirty wordt gebruikt om de waarde in de cache in te stellen voor sleutelwaarden die zijn geregistreerd voor vernieuwen als vervuild. Dit zorgt ervoor dat de waarden in de cache bij de volgende aanroep naar of opnieuw worden gevalideerd met App Configuration en indien RefreshAsync TryRefreshAsync nodig worden bijgewerkt.

Er wordt een willekeurige vertraging toegevoegd voordat de waarde in de cache wordt gemarkeerd als vervuild om mogelijke beperking te verminderen in het geval meerdere exemplaren tegelijkertijd worden vernieuwd. De maximale standaardvertraging voordat de waarde in de cache als vervuild wordt gemarkeerd, is 30 seconden, maar kan worden overschrijven door een optionele parameter door te geven TimeSpan aan de SetDirty methode .

De app lokaal compileren en uitvoeren

1. Stel een omgevingsvariabele in met de naam AppConfigurationConnectionString en stel deze in op de toegangssleutel voor App Configuration store. Als u de Windows-opdrachtprompt gebruikt, voert u de volgende opdracht uit en start u de opdrachtprompt opnieuw om de wijziging door te voeren:

    setx AppConfigurationConnectionString "connection-string-of-your-app-configuration-store"
   

   Als u Windows PowerShell gebruikt, voert u de volgende opdracht uit:

    $Env:AppConfigurationConnectionString = "connection-string-of-your-app-configuration-store"
   

   Als u macOS of Linux gebruikt, voert u de volgende opdracht uit:

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

2. Voer de volgende opdracht uit om de console-app te bouwen:

    dotnet build
   

3. Nadat het bouwen is voltooid, voert u de volgende opdracht uit om de app lokaal uit te voeren:

    dotnet run
   

   

4. Meld u aan bij de Azure-portal. Selecteer Alle resources en selecteer de instantie van het App Configuration-archief dat u in de quickstart hebt gemaakt.

5. Selecteer Configuratieverkenner en werk de waarde van de volgende sleutels bij:

   Sleutel	Waarde
   TestApp:Settings:Message	Gegevens van Azure App Configuration - bijgewerkt

6. Wacht 30 seconden totdat de gebeurtenis is verwerkt en de configuratie kan worden bijgewerkt.

   

Resources opschonen

Als u niet door wilt gaan met de resources die in dit artikel zijn gemaakt, verwijdert u de resourcegroep die u hier hebt gemaakt om kosten te voorkomen.

1. Meld u aan bij de Azure-portal en selecteer Resourcegroepen.
2. Voer de naam van de resourcegroep in het vak Filteren op naam in.
3. Selecteer in de resultatenlijst de resourcegroepnaam om een overzicht te bekijken.
4. Selecteer Resourcegroep verwijderen.
5. U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Voer de naam van de resourcegroep in ter bevestiging en selecteer Verwijderen.

Na enkele ogenblikken worden de resourcegroep en alle bijbehorende resources verwijderd.

Volgende stappen

In deze zelfstudie hebt u uw .NET Core-app ingeschakeld voor het dynamisch vernieuwen van configuratie-instellingen vanuit App Configuration. Als u wilt weten hoe u een door Azure beheerde identiteit kunt gebruiken om de toegang tot App Configuration te stroomlijnen, gaat u verder met de volgende zelfstudie.