Accéder aux paramètres de l'application dans Azure Functions

Tim Corey

23m 53s

Dans le paysage actuel du cloud, qui évolue rapidement, il est essentiel de gérer les paramètres des applications de manière sûre et flexible, en particulier pour les développeurs qui utilisent Azure Functions. Qu'il s'agisse de déployer une application fonctionnelle via le portail Azure, de gérer les paramètres de configuration à l'aide d'Azure Functions Core Tools ou de câbler des secrets via Key Vault, il est essentiel de structurer la configuration de votre application dès le départ.

Dans une session pratique intitulée "Accessing AppSettings in Console Apps Including Secrets.json", Tim Corey présente les meilleures pratiques en utilisant l'écosystème .NET. Bien que l'accent soit mis sur les applications console, ses concepts s'appliquent directement au développement et à la gestion des paramètres d'application de fonction dans les applications Azure Functions, notamment lorsqu'il s'agit de travailler localement, de configurer un fichier projet ou de déployer sur App Service.

Dans cet article, nous allons décomposer le tout en utilisant la structure de Tim et appliquer ses leçons au développement moderne d'Azure Functions.

Pourquoi les paramètres d'application sont importants pour Azure Functions

Tim commence par souligner l'importance des paramètres d'application pour la création d'applications autres que les applications .NET les plus basiques. La nécessité d'accéder aux paramètres des applications dans les environnements Azure Function est encore plus prononcée, étant donné que le runtime Azure Functions s'attend à ce que les valeurs de configuration soient récupérées à partir de magasins gérés tels que les variables d'environnement, local.settings.json basé sur JSON, ou Azure App Configuration.

Tim explique à 0:17 : "L'une des fonctions les plus courantes que les développeurs souhaitent obtenir est l'accès à un fichier de configuration.

Qu'il s'agisse d'une clé API, d'une chaîne de connexion ou d'un indicateur de fonctionnalité, la flexibilité et la sécurité de la configuration sont primordiales, en particulier lors du déploiement sur des plates-formes en nuage comme Microsoft Azure.

Créer les fondations avec Visual Studio

À 1:24, Tim met en place un projet de console à l'aide de Visual Studio, qu'il nomme SettingsDemoApp. Alors que les développeurs Azure initialiseraient normalement un projet Functions à l'aide des Azure Functions Core Tools, la méthode d'échafaudage et d'organisation du code utilisée par Tim se traduit de manière transparente. La configuration du fichier de projet et la structure du code sont des bases essentielles, que vous soyez dans un environnement de console ou que vous construisiez une application Azure Functions isolée avec le modèle de travailleur isolé.

Installer les paquets NuGet requis

À partir de 2:33, Tim explique comment installer quatre packages NuGet essentiels :

• Microsoft.Extensions.Configuration

• Microsoft.Extensions.Configuration.Json

• Microsoft.Extensions.Configuration.Binder

• Microsoft.Extensions.Configuration.UserSecrets

Cela reflète le système de configuration d'applications utilisé par Azure Functions, qui s'appuie sur les mêmes paquets en coulisses. Tim met l'accent sur la valeur de la modularité :

En effet, .NET Core évite les charges utiles inutiles en permettant aux développeurs d'opter pour NuGet.

Pour une application fonctionnelle typique, ces packages sont soit pré-référencés, soit facilement ajoutés pour prendre en charge une logique personnalisée pour les paramètres de configuration, l'injection de dépendances ou des cas d'utilisation avancés tels que la prise en charge de Key Vault et Azure App Configuration.

Ajouter et configurer un fichier de paramètres JSON

À 6:12, Tim crée un nouveau fichier nommé appsettings.json, imitant la structure que vous verriez dans local.settings.json pour le développement d'Azure Functions. Il l'alimente avec des paires clé-valeur telles que :

{
  "User" : {
    "Prénom "Tim",
    "Nom de famille" : "Corey"
  },
  "StarterCountValue" : 5
}

{
  "User" : {
    "Prénom "Tim",
    "Nom de famille" : "Corey"
  },
  "StarterCountValue" : 5
}

Dans les fonctions locales, les développeurs utilisent local.settings.json dans un format presque identique pour lire des valeurs dans leur logique d'application via une IConfiguration injectée. Tim met également l'accent sur une étape clé : le réglage de la fonction Copy to Output Directory (Copier dans le répertoire de sortie) du fichier sur "Copy if newer" (Copier si plus récent), ce qui est essentiel pour garantir la disponibilité de votre configuration au moment de l'exécution.

Construire manuellement le pipeline de configuration

Tim procède à l'écriture du code qui met en place un pipeline de configuration manuellement à l'aide de :

var constructeur = nouveau ConstructeurDeConfiguration()
    .SetBasePath(Directory.GetCurrentDirectory())
    addJsonFile("appsettings.json", optional : true, reloadOnChange : true) ;

var constructeur = nouveau ConstructeurDeConfiguration()
    .SetBasePath(Directory.GetCurrentDirectory())
    addJsonFile("appsettings.json", optional : true, reloadOnChange : true) ;

Bien que le runtime Azure Functions gère ce pipeline automatiquement, la décomposition de Tim clarifie la façon dont les projets de fonctions tirent des valeurs de différentes sources. Son utilisation de .AddJsonFile() reflète la manière dont les développeurs configurent local.settings.json dans leur application Azure, avec reloadOnChange introduisant le concept de paramètres de configuration rafraîchis dynamiquement pendant le développement.

Lire les valeurs avec la sécurité des types

Tim explique comment lire les paramètres en utilisant la méthode GetValue() à 11:00 :

int count = config.GetValue<int>("StarterCountValue") ;

int count = config.GetValue<int>("StarterCountValue") ;

Et pour les paramètres imbriqués, il utilise :

string firstName = config.GetValue<string>("User:FirstName") ;

string firstName = config.GetValue<string>("User:FirstName") ;

Lorsque vous travaillez avec Azure Functions, les mêmes schémas syntaxiques s'appliquent. L'utilisation par Tim de clés délimitées par deux points ("User:FirstName") a une correspondance directe dans les variables d'environnement utilisant la syntaxe du double trait de soulignement (__) :

Utilisateur__Prénom=Tim

Utilisateur__Prénom=Tim

Ceci est particulièrement utile lors du déploiement sur Azure App Service ou de la configuration via le portail Azure, où vous pouvez modifier les paramètres au moment de l'exécution en utilisant les paramètres de l'application ou les modifications basées sur l'environnement.

Gérer les secrets en toute sécurité avec UserSecrets

À 15:00, Tim présente le modèle secrets.json via User Secrets, utilisé pour stocker des données sensibles telles que les clés API ou les chaînes de connexion sans les exposer dans le contrôle de la source. Il montre comment attacher un magasin User Secrets à votre projet à l'aide de cette ligne :

builder.AddUserSecrets<Program>() ;

builder.AddUserSecrets<Program>() ;

Il insiste sur l'importance de l'ordre : les Secrets d'utilisateur ont la priorité sur les sources de configuration antérieures, ce qui renforce le principe du "dernier qui gagne". Bien qu'Azure Functions n'utilise pas directement secrets.json, dans un environnement de production en nuage, vous utiliserez Azure Key Vault, éventuellement avec une authentification d'identité gérée, pour obtenir les mêmes dérogations sécurisées.

Tim fait remarquer que les secrets dans le développement local sont un substitut pour tout système sécurisé que vous utilisez dans la production :

"Ce secrets.json est un substitut du système sécurisé que vous utilisez pour stocker vos valeurs réelles, qu'il s'agisse de Key Vault ou de paramètres d'environnement."

Exécuter et valider les configurations

Après avoir configuré les fichiers appsettings.json et secrets.json, Tim exécute l'exemple et vérifie que les secrets remplacent les valeurs de base. Cela reflète directement la façon dont Azure Functions gère les dérogations provenant de plusieurs sources : local.settings.json, Azure App Configuration, les variables d'environnement ou Key Vault.

Qu'il s'agisse d'utiliser Azure Functions Core Tools via la ligne de commande ou de déployer via Visual Studio, l'ordre de chargement et la superposition de la configuration de l'application se déroulent exactement comme le décrit Tim.

Bonnes pratiques pour la gestion de la configuration

Tim conclut en recommandant de conserver les valeurs de configuration qui ne changent pas souvent - comme les indicateurs de fonctionnalité, les paramètres de fréquence ou les configurations CORS - dans votre fichier JSON, et de placer les données sensibles comme les chaînes de connexion et les secrets dans un magasin sécurisé.

Elle doit s'aligner sur les meilleures pratiques modernes pour Azure Functions où :

• Les développeurs utilisent local.settings.json pour des fonctions locales

• Les équipes utilisent le portail Azure pour la configuration des applications

• Les secrets vont à Key Vault

• Les valeurs de la boutique Azure App Configuration permettent de séparer les paramètres du code

Ces sources s'intègrent au moteur d'exécution à l'aide de l'injection de dépendances, sans toucher aux binaires de l'application.

Conclusion

Bien que la vidéo de Tim porte sur les applications de console, chaque technique qu'il enseigne s'étend de manière transparente aux applications Azure Functions, de la création de fichiers de configuration à la lecture de clés, en passant par l'utilisation de l'identité gérée et le chargement de la configuration via l'injection de dépendances. Qu'il s'agisse de déployer avec Visual Studio, de gérer votre compte azure ou de trouver des exemples de code complets, ses idées s'appliquent directement aux pratiques réelles du cloud.