---
sidebar_position: 13
title: Configuration
---

La configuration dans ASP.NET Core est effectuée à l’aide d’un ou de plusieurs fournisseurs de configuration. 
Les fournisseurs de configuration lisent les données de configuration des paires clé-valeur à l’aide d’une variété de sources de configuration :

* Paramètres des fichiers, tels que `appsettings.json`
* Variables d'environnement
* Azure Key Vault
* Azure App Configuration
* Arguments de ligne de commande
* Fournisseurs personnalisés, installés ou créés
* Fichiers de répertoire
* Objets .NET en mémoire

:::caution

Les fichiers de configuration et de paramètres dans une application Blazor Webassembly sont visibles par les utilisateurs. Ne stockez pas de secrets d’application, d’informations d’identification ou d’autres données sensibles dans la configuration ou les fichiers d’une application Webassembly.

:::

## Configuration par défaut

Les applications web ASP.NET Core créées avec dotnet new ou Visual Studio générer le code suivant :

```csharp
public static async Task Main(string[] args)
{
// highlight-next-line
	var builder = WebApplication.CreateBuilder(args);
	
	...
```

`CreateBuilder` fournit la configuration par défaut de l’application dans l’ordre suivant :

* `ChainedConfigurationProvider` : ajoute un `IConfiguration` existant en tant que source. Dans le cas de configuration par défaut, ajoute la configuration d'hôte et la définit en tant que première source de la configuration de l'application.
* `appsettings.json` utilisant le provider par défaut JSON.
* appsettings.`Environment`.json tilisant le provider par défaut JSON. Par exemple, appsettings.**Production**.json et appsettings.**Development**.json.
* Secrets d’application lorsque l’application s’exécute dans l' environnement `Development`.
* Variables d’environnement à l’aide du fournisseur de configuration des variables d’environnement.
* Arguments de ligne de commande à l’aide du fournisseur de configuration de ligne de commande.

Les fournisseurs de configuration ajoutés ultérieurement remplacent les paramètres de clé précédents. 
Par exemple, si `MyKey` est défini à la fois dans `appsettings.json` et dans l’environnement, la valeur d’environnement est utilisée. 
À l’aide des fournisseurs de configuration par défaut, le fournisseur de configuration de ligne de commande remplace tous les autres fournisseurs.


## appsettings.json

Prenons le `appsettings.json` fichier suivant :

```json title="appsettings.json"
{
  "Position": {
    "Title": "Editor",
    "Name": "Joe Smith"
  },
  "MyKey":  "My appsettings.json Value",
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}
```

Le code suivant affiche plusieurs des paramètres de configuration précédents :

```html title="Config.razor"
@page "/config"
<h3>Config</h3>

<div>
    <div>MyKey: @Configuration["MyKey"]</div>
    <div>Position:Title: @Configuration["Position:Title"]</div>
    <div>Position:Name: @Configuration["Position:Name"]</div>
    <div>Logging:LogLevel:Default: @Configuration["Logging:LogLevel:Default"]</div>
</div>
```

```csharp title="Config.razor.cs"
using Microsoft.Extensions.Configuration;

public partial class Config
{
	[Inject] 
	public IConfiguration Configuration { get; set; }
}
```

La configuration par défaut `JsonConfigurationProvider` charge dans l’ordre suivant :

* appsettings.json
* appsettings.`Environment`.json : par exemple, appsettings.**Production**.json et appsettings.**Development**.json. La version de l’environnement du fichier est chargée à partir de `IHostingEnvironment.EnvironmentName`.

Les valeurs de appsettings.`Environment`.json remplacent les clés dans appsettings.json. Par exemple, par défaut :

* En développement, le fichier appsettings.**Development**.json remplace les valeurs trouvées dans appsettings.json.
* En production, le fichier appsettings.**Production**.json remplace les valeurs trouvées dans appsettings.json. Par exemple, lors du déploiement de l’application sur Azure.

Si une valeur de configuration doit être garantie, utiliser `GetValue`. L’exemple précédent lit uniquement des chaînes et ne prend pas en charge de valeur par défaut.

À l’aide de la configuration par défaut de appsettings.json et de appsettings.`Environment`.json. les fichiers sont activés avec `reloadOnChange: true`. 
Les modifications apportées aux fichiers appsettings.json et appsettings.`Environment`.json après le démarrage de l’application est lu par le fournisseur de configuration JSON.

## Lier des données de configuration hiérarchiques à l’aide du modèle options

La méthode recommandée pour lire les valeurs de configuration associées utilise le modèle d’options. Par exemple, pour lire les valeurs de configuration suivantes :

```json title="appsettings.json"
"Position": {
	"Title": "Editor",
    "Name": "Joe Smith"
}
```

Créez la classe suivante `PositionOptions` :

```csharp title="PositionOptions.cs"
public class PositionOptions
{
    public const string Position = "Position";

    public string Title { get; set; }
    public string Name { get; set; }
}
```

Une classe d’options :

* Doit être non abstract avec un constructeur sans paramètre public.
* Toutes les propriétés publiques en lecture/écriture du type sont liées.
* Les champs ne sont pas liés. Dans le code précédent, `Position` n’est pas lié. La propriété `Position` est utilisée afin que la chaîne "Position" ne doive pas être codée en dur dans l’application lors de la liaison de la classe à un fournisseur de configuration.

Le code suivant :

* Appelle `ConfigurationBinder.Bind` pour lier la classe `PositionOptions` à la section `Position`.
* Affiche les données de configuration `Position`.


```html title="Config.razor"
@page "/config"
<h3>Config</h3>

@if (positionOptions != null)
{
    <div>
        <div>Title: @positionOptions.Title</div>
        <div>Name: @positionOptions.Name</div>
    </div>
}
```

```csharp title="Config.razor.cs"
public partial class Config
{
	[Inject] 
	public IConfiguration Configuration { get; set; }

	private PositionOptions positionOptions;

	protected override void OnInitialized()
	{
		base.OnInitialized();
		
		positionOptions = new PositionOptions();
		Configuration.GetSection(PositionOptions.Position).Bind(positionOptions);
	}
}
```

Dans le code précédent, par défaut, les modifications apportées au fichier de configuration JSON après le démarrage de l’application sont lues.

`ConfigurationBinder.Get<T>` lie et retourne le type spécifié. `ConfigurationBinder.Get<T>` peut être plus pratique que l’utilisation de `ConfigurationBinder.Bind`. 
Le code suivant montre comment utiliser `ConfigurationBinder.Get<T>` avec la classe `PositionOptions` :

```csharp title="Config.razor.cs"
public partial class Config
{
	[Inject] 
	public IConfiguration Configuration { get; set; }

	private PositionOptions positionOptions;

	protected override void OnInitialized()
	{
		base.OnInitialized();
		
		positionOptions = Configuration.GetSection(PositionOptions.Position).Get<PositionOptions>();
	}
}
```

Une autre approche de l’utilisation du modèle options consiste à lier la section et à l’ajouter au conteneur du service d’injection de dépendances. 
Dans le code suivant, `PositionOptions` est ajouté au conteneur de services avec `Configure` et lié à la configuration :

```csharp title="Program.cs"
...

builder.Services.Configure<PositionOptions>(option =>
{
	var positionOptions = builder.Configuration.GetSection(PositionOptions.Position).Get<PositionOptions>();

	option.Name = positionOptions.Name;
	option.Title = positionOptions.Title;
});

...
```

À l’aide du code précédent, le code suivant lit les options de position :

```csharp title="Config.razor.cs"
public partial class Config
{
	[Inject] 
	public IConfiguration Configuration { get; set; }

	[Inject] 
	public IOptions<PositionOptions> OptionsPositionOptions { get; set; }

	private PositionOptions positionOptions;
	
	protected override void OnInitialized()
	{
		base.OnInitialized();

		positionOptions = OptionsPositionOptions.Value;
	}
}
```

## Sécurité et secrets de l’utilisateur

Instructions relatives aux données de configuration :

* Ne stockez jamais des mots de passe ou d’autres données sensibles dans le code du fournisseur de configuration ou dans les fichiers de configuration en texte clair. L’outil Gestionnaire de secret peut être utilisé pour stocker les secrets en développement.
* N’utilisez aucun secret de production dans les environnements de développement ou de test.
* Spécifiez les secrets en dehors du projet afin qu’ils ne puissent pas être validés par inadvertance dans un référentiel de code source.
Par défaut, la source de configuration des secrets de l’utilisateur est inscrite après les sources de configuration JSON. 
Par conséquent, les clés de secrets d’utilisateur sont prioritaires sur les clés dans appsettings.json et appsettings.`Environment`.json.

## Variables d'environnement

À l’aide de la configuration par défaut, le `EnvironmentVariablesConfigurationProvider` charge la configuration à partir des paires clé-valeur de variable d’environnement après la lecture du ficher `appsettings.json`, appsettings.`Environment`.json et les secrets de l’utilisateur. 
Par conséquent, les valeurs de clés lues à partir de l’environnement remplacent les valeurs lues à partir de `appsettings.json` appsettings.`Environment`.json et les secrets de l’utilisateur.

Le séparateur `:` ne fonctionne pas avec les clés hiérarchiques de variable d’environnement sur toutes les plateformes. `__`, le double trait de soulignement, est :

* Pris en charge par toutes les plateformes. Par exemple, le séparateur `:` n’est pas pris en charge par `Bash`, mais `__` l'est.
* Automatiquement remplacé par un `:`

Les commandes `set` suivantes :

* Définissez les clés d’environnement et les valeurs de l' exemple précédent sur Windows.
* Testez les paramètres lors de l’utilisation. La dotnet run commande doit être exécutée dans le répertoire du projet.

```shell
set MyKey="My key from Environment"
set Position__Title=Environment_Editor
set Position__Name=Environment_Rick
dotnet run
```

Paramètres d’environnement précédents :

* Sont uniquement définies dans les processus lancés à partir de la fenêtre de commande dans laquelle ils ont été définis.
* Ne seront pas lues par les navigateurs lancés avec Visual Studio.

Les commandes `setx` suivantes peuvent être utilisées pour définir les clés et les valeurs d’environnement sur Windows. 
Contrairement à `set`, les paramètres `setx` sont conservés. `/M` définit la variable dans l’environnement système. 
Si le commutateur `/M` n’est pas utilisé, une variable d’environnement utilisateur est définie.

```shell
setx MyKey "My key from setx Environment" /M
setx Position__Title Environment_Editor /M
setx Position__Name Environment_Rick /M
```

Pour vérifier que les commandes précédentes remplacent `appsettings.json` et appsettings.`Environment`.json:

* avec Visual Studio : quittez et redémarrez Visual Studio.
* Avec l’interface CLI : démarrez une nouvelle fenêtre de commande et entrez `dotnet run`.

Un des grand intéret des variables d'environnement et l'utilisation de celle-ci avec Docker.
