Tutorial: Usar a configuração dinâmica usando a atualização por push em um aplicativo .NET

Artigo
03/05/2024

A biblioteca de cliente .NET de Configuração do Aplicativo oferece suporte à atualização da configuração sob demanda sem fazer com que um aplicativo seja reiniciado. Um aplicativo pode ser configurado para detetar alterações na Configuração do Aplicativo usando uma ou ambas as duas abordagens a seguir.

Modelo de sondagem: Este é o comportamento padrão que usa sondagem para detetar alterações na configuração. Quando o valor armazenado em cache de uma configuração expirar, a próxima chamada ou TryRefreshAsync RefreshAsync enviará uma solicitação ao servidor para verificar se a configuração foi alterada e extrai a configuração atualizada, se necessário.
Modelo de envio: usa eventos de Configuração do Aplicativo para detetar alterações na configuração. Depois que a Configuração do Aplicativo é configurada para enviar eventos de alteração de valor de chave para a Grade de Eventos do Azure, o aplicativo pode usar esses eventos para otimizar o número total de solicitações necessárias para manter a configuração atualizada. Os aplicativos podem optar por assiná-los diretamente da Grade de Eventos ou por meio de um dos manipuladores de eventos com suporte, como um webhook, uma função do Azure ou um tópico do Service Bus.

Este tutorial mostra como você pode implementar atualizações de configuração dinâmica em seu código usando a atualização por push. Ele se baseia no aplicativo introduzido no tutorial. Antes de continuar, conclua o Tutorial: Use a configuração dinâmica em um aplicativo .NET primeiro.

Você pode usar qualquer editor de código para executar as etapas neste tutorial. O Visual Studio Code é uma excelente opção disponível nas plataformas Windows, macOS e Linux.

Neste tutorial, irá aprender a:

Configurar uma assinatura para enviar eventos de alteração de configuração da Configuração do Aplicativo para um tópico do Service Bus
Configure seu aplicativo .NET para atualizar sua configuração em resposta a alterações na Configuração do Aplicativo.
Consuma a configuração mais recente em seu aplicativo.

Pré-requisitos

Tutorial: Usar a configuração dinâmica em um aplicativo .NET
Pacote Microsoft.Extensions.Configuration.AzureAppConfiguration NuGet versão 5.0.0 ou posterior

Configurar o tópico e a subscrição do Barramento de Serviço do Azure

Este tutorial usa a integração do Service Bus para Grade de Eventos para simplificar a deteção de alterações de configuração para aplicativos que não desejam pesquisar continuamente a Configuração do Aplicativo. O SDK do Barramento de Serviço do Azure fornece uma API para registrar um manipulador de mensagens que pode ser usado para atualizar a configuração quando alterações são detetadas na Configuração do Aplicativo. Siga as etapas no Guia de início rápido: use o portal do Azure para criar um tópico e uma assinatura do Service Bus para criar um namespace, tópico e assinatura do barramento de serviço.

Depois que os recursos forem criados, adicione as seguintes variáveis de ambiente. Eles serão usados para registrar um manipulador de eventos para alterações de configuração no código do aplicativo.

Key	valor
ServiceBusConnectionString	Cadeia de conexão para o namespace do barramento de serviço
ServiceBusTópico	Nome do tópico do Service Bus
ServiceBusSubscrição	Nome da assinatura do barramento de serviço

Configurar a subscrição de eventos

Abra o recurso Configuração do Aplicativo no portal do Azure e clique em no + Event Subscription Events painel.
Insira um nome para o Event Subscription e o System Topic.
Selecione o Endpoint Type tópico como Service Bus Topic, selecione o Service Bus e clique em Confirm Selection.
Clique para Create criar a assinatura do evento.
Clique em Events no Event Subscriptions painel para validar que a assinatura foi criada com êxito.

Nota

Ao assinar alterações de configuração, um ou mais filtros podem ser usados para reduzir o número de eventos enviados ao seu aplicativo. Eles podem ser configurados como filtros de assinatura da Grade de Eventos ou filtros de assinatura do Service Bus. Por exemplo, um filtro de assinatura pode ser usado apenas para assinar eventos para alterações em uma chave que começa com uma cadeia de caracteres específica.

Registrar manipulador de eventos para recarregar dados da Configuração do Aplicativo

Abra Program.cs e atualize o arquivo com o código a seguir.

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

O ProcessPushNotification método redefine a expiração do cache para um pequeno atraso aleatório. Isso faz com que futuras chamadas ou RefreshAsync TryRefreshAsync revalidem os valores armazenados em cache na Configuração do Aplicativo e os atualizem conforme necessário. Neste exemplo, você se registra para monitorar as alterações na chave: TestApp:Settings:Message com uma expiração de cache de um dia. Isso significa que nenhuma solicitação à Configuração do Aplicativo será feita antes de um dia ter passado desde a última verificação. Ao ligar ProcessPushNotification para o seu aplicativo enviará solicitações para a Configuração do Aplicativo nos próximos segundos. Seu aplicativo carregará os novos valores de configuração logo após as alterações ocorrerem na loja, App Configuration sem a necessidade de pesquisar constantemente por atualizações. Caso seu aplicativo perca a notificação de alteração por qualquer motivo, ele ainda verificará se há alterações de configuração uma vez por dia.

O pequeno atraso aleatório para a expiração do cache é útil se você tiver muitas instâncias do seu aplicativo ou microsserviços se conectando à mesma loja de configuração de aplicativos com o modelo push. Sem esse atraso, todas as instâncias do seu aplicativo podem enviar solicitações para sua loja de configuração de aplicativos simultaneamente assim que receberem uma notificação de alteração. Isso pode fazer com que o Serviço de Configuração de Aplicativo acelere sua loja. O atraso de expiração do cache é definido como um número aleatório entre 0 e um máximo de 30 segundos por padrão, mas você pode alterar o valor máximo através do parâmetro maxDelay opcional para o ProcessPushNotification método.

O ProcessPushNotification método recebe um PushNotification objeto que contém informações sobre qual alteração na Configuração do Aplicativo disparou a notificação por push. Isso ajuda a garantir que todas as alterações de configuração até o evento de acionamento sejam carregadas na seguinte atualização de configuração. O SetDirty método não garante a alteração que dispara a notificação por push a ser carregada em uma atualização de configuração imediata. Se você estiver usando o SetDirty método para o modelo push, recomendamos usar o ProcessPushNotification método em vez disso.

Crie e execute o aplicativo localmente

Defina uma variável de ambiente chamada AppConfigurationConnectionString e defina-a como a chave de acesso à sua loja de configuração de aplicativos.
Para criar e executar o aplicativo localmente usando o prompt de comando do Windows, execute o seguinte comando e reinicie o prompt de comando para permitir que a alteração entre em vigor:
```
setx AppConfigurationConnectionString "<connection-string-of-your-app-configuration-store>"
```
Se você usar o Windows PowerShell, execute o seguinte comando:
```
$Env:AppConfigurationConnectionString = "<connection-string-of-your-app-configuration-store>"
```
Se você usa macOS, execute o seguinte comando:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Se você usa Linux, execute o seguinte comando:
```
export AppConfigurationConnectionString='<connection-string-of-your-app-configuration-store>'
```
Execute o seguinte comando para criar o aplicativo de console:
```
dotnet build
```
Depois que a compilação for concluída com êxito, execute o seguinte comando para executar o aplicativo localmente:
```
dotnet run
```
Inicie sessão no portal do Azure. Selecione Todos os recursos e selecione a instância da App Configuration Store que você criou no início rápido.
Selecione Configuration Explorer e atualize os valores das seguintes chaves:

Key valor

TestApp:Configurações:Mensagem Dados da Configuração do Aplicativo do Azure - Atualizado
Aguarde alguns momentos para permitir que o evento seja processado. Você verá a configuração atualizada.

Key	valor
TestApp:Configurações:Mensagem	Dados da Configuração do Aplicativo do Azure - Atualizado

Clean up resources (Limpar recursos)

Se não quiser continuar a utilizar os recursos criados neste artigo, elimine o grupo de recursos que criou aqui para evitar cobranças.

Importante

A eliminação de um grupo de recursos é irreversível. O grupo de recursos e todos os recursos nele contidos são excluídos permanentemente. Certifique-se de não excluir acidentalmente o grupo de recursos ou recursos errados. Se você criou os recursos para este artigo dentro de um grupo de recursos que contém outros recursos que deseja manter, exclua cada recurso individualmente de seu respetivo painel em vez de excluir o grupo de recursos.

Entre no portal do Azure e selecione Grupos de recursos.
Na caixa Filtrar por nome, introduza o nome do seu grupo de recursos.
Na lista de resultados, selecione o nome do grupo de recursos para ver uma visão geral.
Selecione Eliminar grupo de recursos.
É-lhe pedido que confirme a eliminação do grupo de recursos. Insira o nome do grupo de recursos a ser confirmado e selecione Excluir.

Após alguns momentos, o grupo de recursos e todos os seus recursos são excluídos.

Próximos passos

Neste tutorial, você habilitou seu aplicativo .NET para atualizar dinamicamente as definições de configuração da Configuração do aplicativo. Para saber como usar uma identidade gerenciada do Azure para simplificar o acesso à Configuração do Aplicativo, continue para o próximo tutorial.

Integração de identidade gerenciada

Partilhar via