Tutoriel : Utiliser la configuration dynamique avec l’actualisation en mode push dans une application .NET

Article
02/20/2024

La bibliothèque de client .NET App Configuration prend en charge la mise à jour de la configuration à la demande, sans entraîner le redémarrage de l’application. Une application peut être configurée pour détecter les changements dans App Configuration à l’aide de l’une ou des deux approches suivantes.

Modèle par interrogation (polling) : il s’agit du comportement par défaut qui utilise l’interrogation pour détecter des changements de configuration. Quand la valeur mise en cache d’un paramètre expire, l’appel suivant à TryRefreshAsync ou à RefreshAsync envoie une demande au serveur pour vérifier si la configuration a changé et tire (pull) la configuration mise à jour si nécessaire.
Modèle d’envoi (push) : utilise les événements App Configuration pour détecter des changements de configuration. Une fois App Configuration configuré pour envoyer les événements de changement de paire clé-valeur à Azure Event Grid, l’application peut utiliser ces événements pour optimiser le nombre total de demandes nécessaires pour tenir la configuration à jour. Les applications peuvent s’abonner à ces événements directement à partir d’Event Grid ou par le biais de l’un des gestionnaires d’événements pris en charge (comme un webhook, une fonction Azure ou une rubrique Service Bus).

Ce tutoriel vous montre comment implémenter des mises à jour de la configuration dynamique dans votre code à l’aide de l’actualisation en mode push. Il s’appuie sur l’application présentée dans le tutoriel. Avant de continuer, terminez le tutoriel : Utiliser la configuration dynamique dans une application .NET.

Vous pouvez utiliser l’éditeur de code de votre choix pour exécuter les étapes de ce tutoriel. Visual Studio Code est une excellente option qui est disponible sur les plateformes Windows, macOS et Linux.

Dans ce tutoriel, vous allez apprendre à :

Configurer un abonnement pour envoyer des événements de changement de configuration d’App Configuration à une rubrique Service Bus
Configurer votre application .NET pour mettre à jour sa configuration en réponse aux changements dans App Configuration.
Utiliser la configuration la plus récente dans votre application.

Prérequis

Tutoriel : Utiliser la configuration dynamique dans une application .NET
Package NuGet Microsoft.Extensions.Configuration.AzureAppConfiguration version 5.0.0 ou ultérieure

Configurer une rubrique et un abonnement Azure Service Bus

Ce tutoriel utilise l’intégration à Service Bus pour Event Grid afin de simplifier la détection des changements de configuration pour les applications qui ne souhaitent pas interroger constamment App Configuration sur les changements. Le SDK Azure Service Bus fournit une API d’inscription de gestionnaire de messages qui peut être utilisée pour mettre à jour la configuration quand des changements sont détectés dans App Configuration. Suivez les étapes dans Démarrage rapide : Utiliser le portail Azure pour créer une rubrique et un abonnement Service Bus pour créer un espace de noms, une rubrique et un abonnement Service Bus.

Une fois les ressources créées, ajoutez les variables d’environnement suivantes. Celles-ci permettent d’inscrire un gestionnaire d’événements utilisé pour les changements de configuration dans le code de l’application.

Clé	Valeur
ServiceBusConnectionString	Chaîne de connexion pour l’espace de noms Service Bus
ServiceBusTopic	Nom de la rubrique Service Bus
ServiceBusSubscription	Nom de l’abonnement Service Bus

Configurer l’abonnement aux événements

Ouvrez la ressource App Configuration dans le portail Azure, puis cliquez sur + Event Subscription dans le volet Events.
Entrez un nom pour Event Subscription et System Topic.
Sélectionnez Service Bus Topic comme Endpoint Type, choisissez la rubrique Service Bus, puis cliquez sur Confirm Selection.
Cliquez sur Create pour créer l’abonnement aux événements.
Cliquez sur Event Subscriptions dans le volet Events pour confirmer que l’abonnement a bien été créé.

Notes

Quand vous vous abonnez à des changements de configuration, vous pouvez utiliser un ou plusieurs filtres pour réduire le nombre d’événements envoyés à votre application. Vous pouvez les configurer comme filtres d’abonnement Event Grid ou comme filtres d’abonnement Service Bus. Par exemple, vous pouvez utiliser un filtre d’abonnement pour vous abonner uniquement aux événements liés à des changements dans une clé qui commence par une chaîne spécifique.

Inscrire un gestionnaire d’événements pour recharger des données à partir d’App Configuration

Ouvrez Program.cs et mettez à jour le fichier avec le code suivant.

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

La méthode ProcessPushNotification réinitialise l’expiration du cache à un délai aléatoire bref. Cela provoque des appels ultérieurs à RefreshAsync ou TryRefreshAsync pour revalider les valeurs mises en cache par rapport à la configuration de l’application et les mettre à jour si nécessaire. Dans cet exemple, vous vous inscrivez pour surveiller les modifications apportées à la clé : TestApp:Settings:Message dont l’expiration du cache est d’une journée. Cela signifie qu’aucune demande n’est adressée à App Configuration avant qu’une journée soit passée depuis la dernière vérification. En appelant ProcessPushNotification, votre application envoie les demandes à App Configuration dans les quelques secondes qui suivent. Votre application chargera les nouvelles valeurs de configuration peu après que des modifications ont eu lieu dans le magasin App Configuration sans qu’il soit nécessaire d’interroger constamment les mises à jour. Si votre application n’affiche pas la notification de modification pour une raison quelconque, elle recherchera toujours les modifications de configuration une fois par jour.

Le délai aléatoire bref pour l’expiration du cache est utile si vous avez de nombreuses instances de votre application ou des microservices qui se connectent au même magasin App Configuration avec le modèle d’envoi (push). Sans ce délai, toutes les instances de votre application peuvent envoyer des demandes à votre magasin App Configuration simultanément, dès qu’elles reçoivent une notification de modification. Cela peut entraîner la limitation de votre magasin par le service App Configuration. Le délai d’expiration du cache est défini sur un nombre aléatoire compris entre 0 et 30 secondes par défaut, mais vous pouvez modifier la valeur maximale via le paramètre facultatif maxDelay de la méthode ProcessPushNotification.

La méthode ProcessPushNotification prend un objet PushNotification contenant des informations sur le changement dans App Configuration qui a déclenché la notification Push. Cela permet de garantir que toutes les modifications de configuration apportées à l’événement de déclenchement sont chargées dans l’actualisation de configuration suivante. La méthode SetDirty ne garantit pas le changement qui déclenche le chargement de la notification Push dans une actualisation de configuration immédiate. Si vous utilisez la méthode SetDirty pour le modèle push, nous vous recommandons d’utiliser la méthode ProcessPushNotification à la place.

Générer et exécuter l’application localement

Définissez une variable d’environnement nommée AppConfigurationConnectionString et affectez-lui la valeur de la clé d’accès à votre magasin App Configuration.
Pour créer et exécuter l’application localement via l’invite de commandes Windows, exécutez la commande suivante et redémarrez l’invite de commandes pour que la modification soit prise en compte :
```
setx AppConfigurationConnectionString "<connection-string-of-your-app-configuration-store>"
```
Si vous utilisez Windows PowerShell, exécutez la commande suivante :
```
$Env:AppConfigurationConnectionString = "<connection-string-of-your-app-configuration-store>"
```
Si vous utilisez macOS, exécutez la commande suivante :
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Si vous utilisez Linux, exécutez la commande suivante :
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Exécutez la commande suivante pour générer l’application console :
```
dotnet build
```
La génération terminée correctement, lancez la commande suivante pour exécuter l’application localement :
```
dotnet run
```
Connectez-vous au portail Azure. Sélectionnez Toutes les ressources, puis sélectionnez l’instance du magasin App Configuration que vous avez créée dans le guide de démarrage rapide.
Sélectionnez Explorateur de configuration, puis mettez à jour les valeurs des clés suivantes :

Clé Valeur

TestApp:Settings:Message Données issues d’Azure App Configuration - Mise à jour
Attendez quelques instants pour permettre à l’événement d’être traité. Vous verrez la configuration mise à jour.

Clé	Valeur
TestApp:Settings:Message	Données issues d’Azure App Configuration - Mise à jour

Nettoyer les ressources

Si vous ne souhaitez plus utiliser les ressources créées dans cet article, supprimez le groupe de ressources que vous avez créé ici afin d’éviter des frais.

Important

La suppression d’un groupe de ressources est irréversible. Le groupe de ressources et toutes les ressources qu’il contient sont supprimés définitivement. Veillez à ne pas supprimer accidentellement les mauvaises ressources ou le mauvais groupe de ressources. Si vous avez créé les ressources pour cet article dans un groupe de ressources contenant d’autres ressources que vous souhaitez conserver, supprimez chaque ressource individuellement à partir de son volet, au lieu de supprimer l’intégralité du groupe de ressources.

Connectez-vous au portail Azure, puis sélectionnez Groupes de ressources.
Dans la zone Filtrer par nom, entrez le nom de votre groupe de ressources.
Dans la liste de résultats, sélectionnez le nom du groupe de ressources pour afficher une vue d’ensemble.
Sélectionnez Supprimer le groupe de ressources.
Vous êtes invité à confirmer la suppression du groupe de ressources. Entrez le nom de votre groupe de ressources à confirmer, puis sélectionnez Supprimer.

Après quelques instants, le groupe de ressources et toutes ses ressources sont supprimés.

Étapes suivantes

Dans ce tutoriel, vous avez permis à votre application .NET d’actualiser dynamiquement les paramètres de configuration depuis App Configuration. Pour savoir comment utiliser une identité managée Azure afin de simplifier l’accès à App Configuration, passez au tutoriel suivant.

Intégration des identités managées

Partager via