Tutoriel : Utiliser la configuration dynamique dans une application Azure Functions

Article
06/01/2023

Le fournisseur de configuration .NET App Configuration prend en charge la mise en cache et l’actualisation de la configuration pilotée dynamiquement par l’activité des applications. Ce tutoriel montre comment vous pouvez implémenter des mises à jour de la configuration dynamique dans votre code. Il s’appuie sur l’application Azure Functions mentionnée dans les guides de démarrage rapide. Avant de continuer, terminez d’abord Créer une application Azure Functions avec Azure App Configuration.

Dans ce tutoriel, vous allez apprendre à :

Configurer votre application Azure Functions pour mettre à jour sa configuration en réponse aux changements survenant dans un magasin App Configuration.
Injecter la configuration la plus récente dans vos appels Azure Functions.

Prérequis

Abonnement Azure : créez-en un gratuitement
Visual Studio avec la charge de travail de développement Azure
Outils Azure Functions, s’il n’est pas déjà installé avec Visual Studio.
Terminez le guide de démarrage rapide Créer une application Azure Functions avec Azure App Configuration

Recharger des données à partir d’Azure App Configuration

Azure Functions prendre en charge l’exécution in-process ou isolated-process. La principale différence dans l’utilisation d’App Configuration entre les deux modes est la façon dont la configuration est actualisée. En mode in-process, vous devez effectuer un appel dans chaque fonction pour actualiser la configuration. En mode isolated-process, il existe une prise en charge de l’intergiciel (middleware). Le middleware App Configuration, Microsoft.Azure.AppConfiguration.Functions.Workerpermet à l’appel d’actualiser automatiquement la configuration avant l’exécution de chaque fonction.

Mettez à jour le code qui se connecte à App Configuration et ajoutez les conditions d’actualisation des données.
- In-process
- Processus isolé
Ouvrez Startup.cs et mettez à jour la méthode ConfigureAppConfiguration.
```
public override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
{
    builder.ConfigurationBuilder.AddAzureAppConfiguration(options =>
    {
        options.Connect(Environment.GetEnvironmentVariable("ConnectionString"))
                // Load all keys that start with `TestApp:` and have no label
                .Select("TestApp:*")
                // Configure to reload configuration if the registered sentinel key is modified
                .ConfigureRefresh(refreshOptions =>
                    refreshOptions.Register("TestApp:Settings:Sentinel", refreshAll: true));
    });
}
```
Ouvrez Program.cs et mettez à jour la méthode Main.
```
public static void Main()
{
    var host = new HostBuilder()
        .ConfigureAppConfiguration(builder =>
        {
            builder.AddAzureAppConfiguration(options =>
            {
                options.Connect(Environment.GetEnvironmentVariable("ConnectionString"))
                        // Load all keys that start with `TestApp:` and have no label
                        .Select("TestApp:*")
                        // Configure to reload configuration if the registered sentinel key is modified
                        .ConfigureRefresh(refreshOptions =>
                            refreshOptions.Register("TestApp:Settings:Sentinel", refreshAll: true));
            });
        })
        .ConfigureFunctionsWorkerDefaults()
        .Build();

    host.Run();
}
```
La méthode ConfigureRefresh inscrit un paramètre pour lequel une recherche de modifications doit être effectuée dès qu’une actualisation est déclenchée dans l’application. Le paramètre refreshAll indique au fournisseur App Configuration de recharger la configuration entière chaque fois qu’une modification est détectée dans le paramètre inscrit.

Tous les paramètres inscrits pour l’actualisation ont un délai d’expiration du cache de 30 secondes par défaut avant une nouvelle tentative d’actualisation. Vous pouvez changer ce délai en appelant la méthode AzureAppConfigurationRefreshOptions.SetCacheExpiration.
Conseil

Quand vous modifiez plusieurs paires clé-valeur dans App Configuration, vous ne souhaitez généralement pas que votre application recharge la configuration tant que toutes les modifications n’ont pas été appliquées. Vous pouvez inscrire une clé Sentinel et la mettre à jour uniquement quand tous les autres changements de configuration ont été effectués. Cela permet de garantir la cohérence de la configuration dans votre application.

Vous pouvez également effectuer les opérations suivantes pour réduire le risque d’incohérences :
- Concevoir votre application pour qu’elle soit tolérante aux incohérences de configuration temporaires
- Préchauffer votre application avant de la mettre en ligne (services de demandes)
- Conserver la configuration par défaut dans votre application et l’utiliser en cas d’échec de la validation de la configuration
- Choisir une stratégie de mise à jour de configuration qui réduit l’impact sur votre application, par exemple, un moment à trafic faible.

In-process
Processus isolé

Mettez à jour la méthode Configure pour rendre les services Azure App Configuration disponibles via l’injection de dépendances.
```
public override void Configure(IFunctionsHostBuilder builder)
{
    builder.Services.AddAzureAppConfiguration();
}
```

Ouvrez Function1.cs et ajoutez les espaces de noms suivants.

using System.Linq;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;

Mettez à jour le constructeur pour obtenir l’instance de IConfigurationRefresherProvider via l’injection de dépendances, à partir de laquelle vous pouvez obtenir l’instance de IConfigurationRefresher.

private readonly IConfiguration _configuration;
private readonly IConfigurationRefresher _configurationRefresher;

public Function1(IConfiguration configuration, IConfigurationRefresherProvider refresherProvider)
{
    _configuration = configuration;
    _configurationRefresher = refresherProvider.Refreshers.First();
}

Mettez à jour la méthode Run et indiquez d’actualiser la configuration à l’aide de la méthode TryRefreshAsync au début de l’appel Functions. Aucune opération n’est effectuée si la fenêtre de délai d’expiration du cache n’est pas atteinte. Supprimez l’opérateur await si vous préférez que la configuration soit actualisée sans bloquer l’appel Functions en cours. Dans ce cas, les appels Functions ultérieurs obtiendront une valeur mise à jour.

public async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    await _configurationRefresher.TryRefreshAsync(); 

    string keyName = "TestApp:Settings:Message";
    string message = _configuration[keyName];

    return message != null
        ? (ActionResult)new OkObjectResult(message)
        : new BadRequestObjectResult($"Please create a key-value with the key '{keyName}' in App Configuration.");
}

Ajoutez un appel ConfigureServices au HostBuilder pour rendre les services Azure App Configuration disponibles via l’injection de dépendances. Mettez ensuite à jour l’intergiciel ConfigureFunctionsWorkerDefaults App Configuration pour l’actualisation des données de configuration.

public static void Main()
{
    var host = new HostBuilder()
        .ConfigureAppConfiguration(builder =>
        {
            // Omitted the code added in the previous step.
            // ... ...
        })
        .ConfigureServices(services =>
        {
            // Make Azure App Configuration services available through dependency injection.
            services.AddAzureAppConfiguration();
        })
        .ConfigureFunctionsWorkerDefaults(app =>
        {
            // Use Azure App Configuration middleware for data refresh.
            app.UseAzureAppConfiguration();
        })
        .Build();

    host.Run();
}

Tester la fonction en local

Définissez une variable d’environnement nommée ConnectionString et affectez-lui la valeur de la clé d’accès à votre magasin de configuration d’application. Si vous utilisez l’invite de commandes Windows, exécutez la commande suivante et redémarrez l’invite pour que la modification soit prise en compte :
```
setx ConnectionString "connection-string-of-your-app-configuration-store"
```
Si vous utilisez Windows PowerShell, exécutez la commande suivante :
```
$Env:ConnectionString = "connection-string-of-your-app-configuration-store"
```
Si vous utilisez macOS ou Linux, exécutez la commande suivante :
```
export ConnectionString='connection-string-of-your-app-configuration-store'
```
Pour tester votre fonction, appuyez sur F5. Si vous y êtes invité, acceptez la requête dans Visual Studio pour télécharger et installer Azure Functions Core (CLI) Tools. Vous devrez peut-être aussi activer une exception de pare-feu afin de permettre aux outils de prendre en charge les requêtes HTTP.
Copiez l’URL de votre fonction à partir de la sortie runtime Azure Functions.
Collez l’URL de la demande HTTP dans la barre d’adresses de votre navigateur. La capture d’écran suivante du navigateur montre la réponse retournée par la fonction, suite à la requête GET locale.
Connectez-vous au portail Azure. Sélectionnez Toutes les ressources, puis sélectionnez le magasin App Configuration que vous avez créé dans le guide de démarrage rapide.
Sélectionnez Explorateur de configuration, puis mettez à jour la valeur de la clé suivante :

Clé Valeur

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

Créez ensuite la clé Sentinel ou modifiez sa valeur si elle existe déjà, par exemple

Clé Valeur

TestApp:Settings:Sentinel v1
Actualisez le navigateur à plusieurs reprises. Lorsque le paramètre mis en cache expire au bout de 30 secondes, la page affiche la réponse de l’appel Functions avec la valeur mise à jour.

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

Clé	Valeur
TestApp:Settings:Sentinel	v1

Remarque

L’exemple de code utilisé dans ce tutoriel peut être téléchargé à partir du dépôt GitHub App Configuration.

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 Azure Functions d’actualiser dynamiquement les paramètres de configuration à partir d’App Configuration. Pour savoir comment utiliser une identité managée Azure afin de simplifier l’accès à App Configuration, passez au tutoriel suivant.

Accès App Configuration à l’aide d’une identité managée

Partager via