Tutorial: Uso de la configuración dinámica mediante una actualización de inserción en aplicaciones de .NET

Artículo
02/20/2024

La biblioteca cliente .NET de App Configuration permite que se actualice la configuración a petición sin provocar el reinicio de las aplicaciones. Se puede configurar una aplicación para que detecte cambios en App Configuration mediante uno de los dos métodos siguientes o ambos.

Modelo de sondeo: este es el comportamiento predeterminado, que usa el sondeo para detectar los cambios en la configuración. Una vez que el valor almacenado en caché de una configuración expira, la siguiente llamada a TryRefreshAsync o RefreshAsync envía una solicitud al servidor para comprobar si la configuración ha cambiado y extrae la configuración actualizada si es necesario.
Modo de inserción: este modo utiliza eventos de App Configuration para detectar los cambios en la configuración. Una vez que App Configuration está configurado para enviar eventos de cambio de valor de clave a Azure Event Grid, la aplicación puede usar estos eventos para optimizar el número total de solicitudes necesarias para mantener la configuración actualizada. Las aplicaciones pueden optar por suscribirse a ellos directamente desde Event Grid o bien mediante uno de los controladores de eventos admitidos, como un webhook, una función de Azure o un tema de Service Bus.

Este tutorial le muestra cómo puede implementar las actualizaciones de configuración dinámica en el código mediante una actualización de inserción. Se basa en la aplicación que se introdujo en el tutorial. Antes de continuar, finalice el tutorial Uso de la configuración dinámica en una aplicación de .NET.

Para realizar los pasos de este tutorial, puede usar cualquier editor de código. Visual Studio Code es una excelente opción que está disponible en las plataformas Windows, macOS y Linux.

En este tutorial, aprenderá a:

Configurar una suscripción para enviar eventos de cambio de configuración desde App Configuration a un tema de Service Bus
Configure la aplicación de .NET para actualizar su configuración como respuesta a los cambios que se han realizado en App Configuration.
Consuma en la aplicación la configuración más reciente.

Requisitos previos

Tutorial: Uso de la configuración dinámica en una aplicación de .NET
Paquete NuGet Microsoft.Extensions.Configuration.AzureAppConfiguration, versión 5.0.0 o posterior

Configuración de un tema y una suscripción de Azure Service Bus

En este tutorial se usa la integración de Service Bus con Event Grid para simplificar la detección de cambios de configuración para las aplicaciones que no quieren sondear los cambios en App Configuration de forma continua. El SDK de Azure Service Bus proporciona una API para registrar un controlador de mensajes que se puede usar para actualizar la configuración cuando se detectan cambios en App Configuration. Siga los pasos del Inicio rápido: Use Azure Portal para crear un tema y una suscripción de Service Bus para crear un espacio de nombres, un tema y una suscripción de Service Bus.

Una vez creados los recursos, agregue las siguientes variables de entorno. Se usarán para registrar un controlador de eventos para los cambios de configuración en el código de la aplicación.

Key	Valor
ServiceBusConnectionString	Cadena de conexión para el espacio de nombres de Service Bus
ServiceBusTopic	Nombre del tema de Service Bus
ServiceBusSubscription	Nombre de la suscripción de Service Bus

Configuración de la suscripción a eventos

Abra el recurso de App Configuration en Azure Portal y, a continuación, haga clic en + Event Subscription (+ Suscripción de eventos) en el panel Events (Eventos).
Escriba un nombre para los campos Event Subscription (Suscripción de eventos) y System Topic (Tema del sistema).
Seleccione Endpoint Type (Tipo de punto de conexión) como Service Bus Topic (Tema de Service Bus), seleccione el tema de Service Bus y, a continuación, haga clic en Confirm Selection (Confirmar selección).
Haga clic en Create (Crear) para crear la suscripción de eventos.
Haga clic en Event Subscriptions (Suscripciones de eventos) en el panel Events (Eventos) para asegurarse de que la suscripción se haya creado correctamente.

Nota

Al suscribirse a los cambios de configuración, se pueden usar uno o varios filtros para reducir el número de eventos que se envían a la aplicación. Se pueden configurar como filtros de suscripción de Event Grid o filtros de suscripción de Service Bus. Por ejemplo, un filtro de suscripción se puede utilizar para suscribirse solo a eventos de cambios en una clave que empieza por una cadena específica.

Registro del controlador de eventos para volver a cargar los datos de App Configuration

Abra Program.cs y actualice el archivo con el código siguiente.

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

El método ProcessPushNotification restablece la expiración de la caché a un breve retraso aleatorio. Esto hace que las llamadas futuras a RefreshAsync o TryRefreshAsync vuelvan a validar los valores almacenados en caché en relación con App Configuration y los actualicen según sea necesario. En este ejemplo, se registra para supervisar los cambios en la clave TestApp:Settings:Message con una expiración de caché de un día. Esto significa que no se realizará ninguna solicitud a App Configuration antes de que haya transcurrido un día desde la última comprobación. Al llamar a ProcessPushNotification, la aplicación enviará solicitudes a App Configuration en los próximos segundos. La aplicación cargará los nuevos valores de configuración poco después de que se produzcan cambios en el almacén de App Configuration sin necesidad de comprobar constantemente si hay actualizaciones. En caso de que la aplicación no atienda la notificación de cambio por cualquier motivo, seguirá buscando cambios de configuración una vez al día.

El breve retraso aleatorio para la expiración de la caché es útil si tiene muchas instancias de aplicación o microservicios que se conectan al mismo almacén de App Configuration con el modelo de inserción. Sin este retraso, todas las instancias de la aplicación podrían enviar solicitudes al almacén de App Configuration simultáneamente en cuanto recibiesen una notificación de cambio. Esto puede hacer que el servicio App Configuration limite el almacén. El retraso de expiración de la caché se establece en un número aleatorio entre 0 y un máximo de 30 segundos de manera predeterminada, pero puede cambiar el valor máximo mediante el parámetro opcional maxDelay al método ProcessPushNotification.

El método ProcessPushNotification utiliza un objeto PushNotification que contiene información sobre el cambio de App Configuration que desencadenó la notificación de inserción. Esto ayuda a garantizar que todos los cambios de configuración hasta el evento desencadenador se cargan en la siguiente actualización de configuración. El método SetDirty no garantiza que el cambio que desencadena la notificación de inserción se vaya a cargar en una actualización de configuración inmediata. Si usa el método SetDirty para el modelo de inserción, se recomienda usar el método ProcessPushNotification en su lugar.

Compilación y ejecución de la aplicación en un entorno local

Establezca una variable de entorno llamada AppConfigurationConnectionString y defínala como la clave de acceso al almacén de App Configuration.
Para compilar y ejecutar la aplicación de forma local mediante el símbolo del sistema de Windows, ejecute el siguiente comando y reinicie el símbolo del sistema para que se aplique el cambio:
```
setx AppConfigurationConnectionString "<connection-string-of-your-app-configuration-store>"
```
Si usa Windows PowerShell, ejecute el siguiente comando:
```
$Env:AppConfigurationConnectionString = "<connection-string-of-your-app-configuration-store>"
```
Si usa macOS, ejecute el siguiente comando:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Si usa Linux, ejecute el siguiente comando:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Ejecute el siguiente comando para compilar la aplicación de consola:
```
dotnet build
```
Una vez que la compilación se haya realizado correctamente, ejecute el siguiente comando para ejecutar la aplicación localmente:
```
dotnet run
```
Inicie sesión en Azure Portal. Seleccione Todos los recursos y seleccione la instancia de almacén de App Configuration que creó en el inicio rápido.
Seleccione Explorador de configuración y actualice los valores de las claves siguientes:

Clave Value

TestApp:Settings:Message Datos de Azure App Configuration, actualizados
Espere unos instantes para permitir que se procese el evento. Verá la configuración actualizada.

Clave	Value
TestApp:Settings:Message	Datos de Azure App Configuration, actualizados

Limpieza de recursos

Si no quiere seguir usando los recursos que se han creado en este artículo, elimine el grupo de recursos que creó aquí para evitar cargos.

Importante

La eliminación de un grupo de recursos es irreversible. El grupo de recursos y todos los recursos que contiene se eliminan permanentemente. Asegúrese de que no elimina por accidente el grupo de recursos o los recursos equivocados. Si creó los recursos para este artículo en un grupo de recursos que contenga los recursos que desee conservar, elimine cada recurso de forma individual desde su panel respectivo, en lugar de eliminar el grupo de recursos.

Inicie sesión en Azure Portal y después seleccione Grupos de recursos.
En el cuadro de texto Filtrar por nombre, escriba el nombre del grupo de recursos.
En la lista resultados, seleccione el nombre del grupo de recursos para ver la información general.
Seleccione Eliminar grupo de recursos.
Se le pedirá que confirme la eliminación del grupo de recursos. Escriba el nombre del grupo de recursos para confirmar y seleccione Eliminar.

Transcurridos unos instantes, el grupo de recursos y todos sus recursos se eliminan.

Pasos siguientes

En este tutorial, ha habilitado la aplicación de .NET para actualizar dinámicamente la configuración a partir de App Configuration. Para obtener información sobre cómo usar una identidad administrada de Azure para simplificar el acceso a App Configuration, vaya al siguiente tutorial.

Integración de identidades administradas

Compartir vía