Esercitazione: Usare la configurazione dinamica usando l'aggiornamento push in un'app .NET

Articolo
04/04/2024

La libreria client .NET Configurazione app supporta l'aggiornamento della configurazione su richiesta senza causare il riavvio di un'applicazione. Un'applicazione può essere configurata per rilevare le modifiche in Configurazione app usando uno o entrambi i due approcci seguenti.

Modello di polling: comportamento predefinito che usa il polling per rilevare le modifiche nella configurazione. Una volta scaduto il valore memorizzato nella cache di un'impostazione, la chiamata successiva a TryRefreshAsync o RefreshAsync invia una richiesta al server per verificare se la configurazione è stata modificata ed esegue il pull della configurazione aggiornata, se necessario.
Modello push: usa Configurazione app eventi per rilevare le modifiche nella configurazione. Dopo aver configurato Configurazione app per inviare gli eventi di modifica del valore della chiave a Griglia di eventi di Azure, l'applicazione può usare questi eventi per ottimizzare il numero totale di richieste necessarie per mantenere aggiornata la configurazione. Le applicazioni possono scegliere di eseguire la sottoscrizione direttamente da Griglia di eventi o tramite uno dei gestori eventi supportati, ad esempio un webhook, una funzione di Azure o un argomento di bus di servizio.

Questa esercitazione illustra come implementare gli aggiornamenti della configurazione dinamica nel codice usando l'aggiornamento push. Si basa sull'app introdotta nell'esercitazione. Prima di continuare, completare Esercitazione: Usare la configurazione dinamica in un'app .NET.

Per completare i passaggi riportati in questa esercitazione, è possibile usare qualsiasi editor di codice. Visual Studio Code è un'ottima opzione ed è disponibile per le piattaforme Windows, macOS e Linux.

In questa esercitazione apprenderai a:

Configurare una sottoscrizione per inviare eventi di modifica della configurazione da Configurazione app a un argomento di bus di servizio
Configurare l'app .NET per aggiornarne la configurazione in risposta alle modifiche in Configurazione app.
Utilizzare la configurazione più recente nell'applicazione.

Prerequisiti

Esercitazione: Usare la configurazione dinamica in un'app .NET
Pacchetto Microsoft.Extensions.Configuration.AzureAppConfiguration NuGet versione 5.0.0 o successiva

Configurare bus di servizio di Azure argomento e sottoscrizione

Questa esercitazione usa l'integrazione bus di servizio per Griglia di eventi per semplificare il rilevamento delle modifiche di configurazione per le applicazioni che non vogliono eseguire il polling di Configurazione app per le modifiche in modo continuo. L'SDK di bus di servizio di Azure fornisce un'API per registrare un gestore di messaggi che può essere usato per aggiornare la configurazione quando vengono rilevate modifiche in Configurazione app. Seguire la procedura descritta in Avvio rapido: Usare il portale di Azure per creare un argomento e una sottoscrizione bus di servizio per creare uno spazio dei nomi, un argomento e una sottoscrizione del bus di servizio.

Dopo aver creato le risorse, aggiungere le variabili di ambiente seguenti. Questi verranno usati per registrare un gestore eventi per le modifiche di configurazione nel codice dell'applicazione.

Chiave	valore
ServiceBusConnectionString	stringa di Connessione ion per lo spazio dei nomi del bus di servizio
ServiceBusTopic	Nome dell'argomento bus di servizio
ServiceBusSubscription	Nome della sottoscrizione del bus di servizio

Configurare la sottoscrizione di eventi

Aprire la risorsa Configurazione app nel portale di Azure, quindi fare clic sul + Event SubscriptionEvents riquadro.
Immettere un nome per Event Subscription e System Topic.
Selezionare come Endpoint TypeService Bus Topic, scegliere l'argomento bus di servizio, quindi fare clic su Confirm Selection.
Fare clic su Create per creare la sottoscrizione di eventi.
Fare clic sul Event SubscriptionsEvents riquadro per verificare che la sottoscrizione sia stata creata correttamente.

Nota

Quando si sottoscrive le modifiche alla configurazione, è possibile usare uno o più filtri per ridurre il numero di eventi inviati all'applicazione. Questi filtri possono essere configurati come filtri di sottoscrizione di Griglia di eventi o bus di servizio filtri di sottoscrizione. Ad esempio, un filtro di sottoscrizione può essere usato per sottoscrivere solo gli eventi per le modifiche in una chiave che inizia con una stringa specifica.

Registrare il gestore eventi per ricaricare i dati da Configurazione app

Aprire Program.cs e aggiornare il file con il codice seguente.

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")
                            .SetCacheExpiration(TimeSpan.FromDays(1))  // 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);
            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;
                };
        }
    }
}

Il ProcessPushNotification metodo reimposta la scadenza della cache su un breve ritardo casuale. In questo modo, le chiamate future a RefreshAsync o TryRefreshAsync per convalidare nuovamente i valori memorizzati nella cache in Configurazione app e aggiornarli in base alle esigenze. In questo esempio si esegue la registrazione per monitorare le modifiche apportate alla chiave: TestApp:Impostazioni:Message con scadenza della cache di un giorno. Ciò significa che non verrà effettuata alcuna richiesta di Configurazione app prima del superamento di un giorno dall'ultimo controllo. ProcessPushNotification Chiamando l'applicazione, le richieste verranno inviate a Configurazione app nei prossimi secondi. L'applicazione caricherà i nuovi valori di configurazione poco dopo che le modifiche si verificano nell'archivio App Configuration senza dover eseguire costantemente il polling degli aggiornamenti. Nel caso in cui l'applicazione non verifichi la notifica delle modifiche per qualsiasi motivo, verificherà comunque la presenza di modifiche alla configurazione una volta al giorno.

Il breve ritardo casuale per la scadenza della cache è utile se sono presenti molte istanze dell'applicazione o dei microservizi che si connettono allo stesso archivio Configurazione app con il modello push. Senza questo ritardo, tutte le istanze dell'applicazione potrebbero inviare contemporaneamente richieste all'archivio Configurazione app non appena ricevono una notifica di modifica. Ciò può causare la limitazione dell'archivio da parte del servizio Configurazione app. Il ritardo di scadenza della cache è impostato su un numero casuale compreso tra 0 e un massimo di 30 secondi per impostazione predefinita, ma è possibile modificare il valore massimo tramite il parametro maxDelay facoltativo al ProcessPushNotification metodo .

Il ProcessPushNotification metodo accetta un PushNotification oggetto contenente informazioni su quale modifica in Configurazione app ha attivato la notifica push. Ciò consente di assicurarsi che tutte le modifiche di configurazione fino all'evento di attivazione vengano caricate nell'aggiornamento della configurazione seguente. Il SetDirty metodo non garantisce la modifica che attiva il caricamento della notifica push in un aggiornamento immediato della configurazione. Se si usa il SetDirty metodo per il modello push, è consigliabile usare invece il ProcessPushNotification metodo .

Compilare ed eseguire l'app in locale

Impostare una variabile di ambiente denominata AppConfiguration Connessione ionString e impostarla sulla chiave di accesso all'archivio Configurazione app.
Per compilare ed eseguire l'app in locale usando il prompt dei comandi di Windows, eseguire il comando seguente e riavviare il prompt dei comandi per consentire l'applicazione della modifica:
```
setx AppConfigurationConnectionString "connection-string-of-your-app-configuration-store"
```
Se si usa Windows PowerShell, eseguire il comando seguente:
```
$Env:AppConfigurationConnectionString = "connection-string-of-your-app-configuration-store"
```
Se si usa macOS, eseguire il comando seguente:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Se si usa Linux, eseguire il comando seguente:
```
export AppConfigurationConnectionString='connection-string-of-your-app-configuration-store'
```
Eseguire il comando seguente per compilare l'app console:
```
dotnet build
```
Al termine della compilazione, eseguire questo comando per eseguire l'app Web in locale:
```
dotnet run
```
Accedere al portale di Azure. Selezionare Tutte le risorse e quindi l'istanza di archivio di Configurazione app creata nell'argomento di avvio rapido.
Selezionare Configuration Explorer e aggiornare i valori delle chiavi seguenti:

Chiave valore

TestApp:Settings:Message Dati di Configurazione app di Azure - Aggiornati
Attendere alcuni istanti per consentire l'elaborazione dell'evento. Verrà visualizzata la configurazione aggiornata.

Chiave	valore
TestApp:Settings:Message	Dati di Configurazione app di Azure - Aggiornati

Pulire le risorse

Se non si vuole continuare a usare le risorse create in questo articolo, eliminare il gruppo di risorse creato qui per evitare addebiti.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Il gruppo di risorse e tutte le risorse in esso contenute vengono eliminati in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse o le risorse sbagliate. Se le risorse per questo articolo sono state create in un gruppo di risorse che contiene altre risorse che si vogliono mantenere, eliminare ogni risorsa singolarmente dal rispettivo riquadro anziché eliminare il gruppo di risorse.

Accedere al portale di Azure e selezionare Gruppi di risorse.
Nella casella Filtra per nome immettere il nome del gruppo di risorse.
Nell'elenco dei risultati selezionare il nome del gruppo di risorse per visualizzare una panoramica.
Selezionare Elimina gruppo di risorse.
Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Immettere il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Passaggi successivi

In questa esercitazione è stato abilitato l'app .NET per aggiornare dinamicamente le impostazioni di configurazione da Configurazione app. Per informazioni su come usare un'identità gestita di Azure per semplificare l'accesso a Configurazione app, continuare con l'esercitazione successiva.

Integrazione dell'identità gestita