Stockage sécurisé des secrets d’application en développement dans ASP.NET CoreSafe storage of app secrets in development in ASP.NET Core

Par Rick Anderson, Daniel Rothet Scott AddieBy Rick Anderson, Daniel Roth, and Scott Addie

Affichez ou téléchargez l’exemple de code (procédure de téléchargement)View or download sample code (how to download)

Ce document décrit les techniques de stockage et de récupération des données sensibles lors du développement d’une application ASP.NET Core sur un ordinateur de développement.This document explains techniques for storing and retrieving sensitive data during development of an ASP.NET Core app on a development machine. Ne stockez jamais de mots de passe ou d’autres données sensibles dans le code source.Never store passwords or other sensitive data in source code. Les secrets de production ne doivent pas être utilisés à des fins de développement ou de test.Production secrets shouldn't be used for development or test. Les secrets ne doivent pas être déployés avec l’application.Secrets shouldn't be deployed with the app. Au lieu de cela, les secrets doivent être mis à disposition dans l’environnement de production par un moyen contrôlé, comme les variables d’environnement, les Azure Key Vault, etc. Vous pouvez stocker et protéger les secrets de test et de production Azure à l’aide du fournisseur de configuration Azure Key Vault.Instead, secrets should be made available in the production environment through a controlled means like environment variables, Azure Key Vault, etc. You can store and protect Azure test and production secrets with the Azure Key Vault configuration provider.

Variables d'environnementEnvironment variables

Les variables d’environnement sont utilisées pour éviter le stockage des secrets d’application dans le code ou dans des fichiers de configuration locaux.Environment variables are used to avoid storage of app secrets in code or in local configuration files. Les variables d’environnement remplacent les valeurs de configuration pour toutes les sources de configuration spécifiées précédemment.Environment variables override configuration values for all previously specified configuration sources.

Configurez la lecture des valeurs de variable d’environnement en appelant AddEnvironmentVariables dans le constructeur Startup :Configure the reading of environment variable values by calling AddEnvironmentVariables in the Startup constructor:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", 
                     optional: false, 
                     reloadOnChange: true)
        .AddEnvironmentVariables();

    if (env.IsDevelopment())
    {
        builder.AddUserSecrets<Startup>();
    }

    Configuration = builder.Build();
}

Prenons l’exemple d’une application Web ASP.NET Core dans laquelle la sécurité des comptes d’utilisateur individuels est activée.Consider an ASP.NET Core web app in which Individual User Accounts security is enabled. Une chaîne de connexion de base de données par défaut est incluse dans le fichier appSettings. JSON du projet avec la clé DefaultConnection.A default database connection string is included in the project's appsettings.json file with the key DefaultConnection. La chaîne de connexion par défaut est pour la base de données locale, qui s’exécute en mode utilisateur et ne nécessite pas de mot de passe.The default connection string is for LocalDB, which runs in user mode and doesn't require a password. Pendant le déploiement de l’application, la valeur de clé de DefaultConnection peut être remplacée par la valeur d’une variable d’environnement.During app deployment, the DefaultConnection key value can be overridden with an environment variable's value. La variable d’environnement peut stocker la chaîne de connexion complète avec des informations d’identification sensibles.The environment variable may store the complete connection string with sensitive credentials.

Avertissement

Les variables d’environnement sont généralement stockées en texte brut et non chiffré.Environment variables are generally stored in plain, unencrypted text. Si l’ordinateur ou le processus est compromis, les variables d’environnement sont accessibles aux parties non fiables.If the machine or process is compromised, environment variables can be accessed by untrusted parties. Des mesures supplémentaires pour empêcher la divulgation de secrets d’utilisateur peuvent être nécessaires.Additional measures to prevent disclosure of user secrets may be required.

Quand vous utilisez des clés hiérarchiques dans des variables d’environnement, le séparateur deux-points (:) risque de ne pas fonctionner sur toutes les plateformes (par exemple, Bash).When working with hierarchical keys in environment variables, a colon separator (:) may not work on all platforms (for example, Bash). Un trait de soulignement double (__) est pris en charge par toutes les plateformes et automatiquement remplacé par un signe deux-points.A double underscore (__) is supported by all platforms and is automatically replaced by a colon.

L'outil Secret Manager (Gestionnaire de secrets)Secret Manager

L’outil secret Manager stocke les données sensibles pendant le développement d’un projet ASP.NET Core.The Secret Manager tool stores sensitive data during the development of an ASP.NET Core project. Dans ce contexte, un élément de données sensibles est un secret d’application.In this context, a piece of sensitive data is an app secret. Les secrets de l’application sont stockés dans un emplacement distinct de l’arborescence du projet.App secrets are stored in a separate location from the project tree. Les secrets de l’application sont associés à un projet spécifique ou partagés entre plusieurs projets.The app secrets are associated with a specific project or shared across several projects. Les secrets de l’application ne sont pas archivés dans le contrôle de code source.The app secrets aren't checked into source control.

Avertissement

L'outil Secret Manager ne chiffre pas les clés secrètes stockées et donc ne doit pas être traité comme un magasin approuvé.The Secret Manager tool doesn't encrypt the stored secrets and shouldn't be treated as a trusted store. Il est utile uniquement à des fins de développement.It's for development purposes only. Les clés et valeurs sont stockées dans un fichier de configuration JSON dans le répertoire de profil utilisateur.The keys and values are stored in a JSON configuration file in the user profile directory.

Fonctionnement de l’outil Secret ManagerHow the Secret Manager tool works

L’outil Secret Manager élimine les détails d’implémentation, tels qu’où et comment les valeurs sont stockées.The Secret Manager tool abstracts away the implementation details, such as where and how the values are stored. Vous pouvez utiliser l’outil sans connaître ces détails d’implémentation.You can use the tool without knowing these implementation details. Les valeurs sont stockées dans un fichier de configuration JSON dans un dossier de profil utilisateur protégé du système sur l’ordinateur local :The values are stored in a JSON configuration file in a system-protected user profile folder on the local machine:

Chemin d’accès au système de fichiers :File system path:

%APPDATA%\Microsoft\UserSecrets\<user_secrets_id>\secrets.json

Dans les chemins d’accès de fichier précédents, remplacez <user_secrets_id> par la valeur UserSecretsId spécifiée dans le fichier . csproj .In the preceding file paths, replace <user_secrets_id> with the UserSecretsId value specified in the .csproj file.

N’écrivez pas de code dépendant de l’emplacement ou du format des données enregistrées avec l’outil secret Manager.Don't write code that depends on the location or format of data saved with the Secret Manager tool. Ces détails d’implémentation peuvent changer.These implementation details may change. Par exemple, les valeurs secrètes ne sont pas chiffrées, mais peuvent être dans le futur.For example, the secret values aren't encrypted, but could be in the future.

Installer l’outil secret ManagerInstall the Secret Manager tool

L’outil Gestionnaire de secret est fourni avec le CLI .NET Core dans kit SDK .NET Core 2.1.300 ou version ultérieure.The Secret Manager tool is bundled with the .NET Core CLI in .NET Core SDK 2.1.300 or later. Pour les versions kit SDK .NET Core antérieures à 2.1.300, l’installation des outils est nécessaire.For .NET Core SDK versions before 2.1.300, tool installation is necessary.

Conseil

Exécutez dotnet --version à partir d’une interface de commande pour voir le numéro de version du kit SDK .NET Core installé.Run dotnet --version from a command shell to see the installed .NET Core SDK version number.

Un avertissement s’affiche si le kit SDK .NET Core utilisé comprend l’outil :A warning is displayed if the .NET Core SDK being used includes the tool:

The tool 'Microsoft.Extensions.SecretManager.Tools' is now included in the .NET Core SDK. Information on resolving this warning is available at (https://aka.ms/dotnetclitools-in-box).

Installez le package NuGet Microsoft. extensions. SecretManager. Tools dans votre projet ASP.net core.Install the Microsoft.Extensions.SecretManager.Tools NuGet package in your ASP.NET Core project. Par exemple :For example:

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>netcoreapp1.1</TargetFramework>
    <UserSecretsId>1242d6d6-9df3-4031-b031-d9b27d13c25a</UserSecretsId>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore" 
                      Version="1.1.6" />
    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" 
                      Version="1.1.2" />
    <PackageReference Include="System.Data.SqlClient" 
                      Version="4.5.0" />
  </ItemGroup>
  <ItemGroup>
    <DotNetCliToolReference Include="Microsoft.Extensions.SecretManager.Tools" 
                            Version="1.0.1" />
  </ItemGroup>
</Project>

Exécutez la commande suivante dans une interface de commande pour valider l’installation de l’outil :Execute the following command in a command shell to validate the tool installation:

dotnet user-secrets -h

L’outil Gestionnaire de secret affiche des exemples d’utilisation, d’options et d’aide sur les commandes :The Secret Manager tool displays sample usage, options, and command help:

Usage: dotnet user-secrets [options] [command]

Options:
  -?|-h|--help                        Show help information
  --version                           Show version information
  -v|--verbose                        Show verbose output
  -p|--project <PROJECT>              Path to project. Defaults to searching the current directory.
  -c|--configuration <CONFIGURATION>  The project configuration to use. Defaults to 'Debug'.
  --id                                The user secret ID to use.

Commands:
  clear   Deletes all the application secrets
  list    Lists all the application secrets
  remove  Removes the specified user secret
  set     Sets the user secret to the specified value

Use "dotnet user-secrets [command] --help" for more information about a command.

Notes

Vous devez être dans le même répertoire que le fichier . csproj pour exécuter les outils définis dans les éléments DotNetCliToolReference du fichier . csproj .You must be in the same directory as the .csproj file to run tools defined in the .csproj file's DotNetCliToolReference elements.

Activer le stockage secretEnable secret storage

L’outil Gestionnaire de secret fonctionne sur les paramètres de configuration spécifiques au projet stockés dans votre profil utilisateur.The Secret Manager tool operates on project-specific configuration settings stored in your user profile.

L’outil Gestionnaire de secret comprend une commande init dans kit SDK .NET Core 3.0.100 ou version ultérieure.The Secret Manager tool includes an init command in .NET Core SDK 3.0.100 or later. Pour utiliser des secrets d’utilisateur, exécutez la commande suivante dans le répertoire du projet :To use user secrets, run the following command in the project directory:

dotnet user-secrets init

La commande précédente ajoute un élément UserSecretsId dans une PropertyGroup du fichier . csproj .The preceding command adds a UserSecretsId element within a PropertyGroup of the .csproj file. Par défaut, le texte interne de UserSecretsId est un GUID.By default, the inner text of UserSecretsId is a GUID. Le texte interne est arbitraire, mais il est unique pour le projet.The inner text is arbitrary, but is unique to the project.

Pour utiliser des secrets d’utilisateur, définissez un élément UserSecretsId dans un PropertyGroup du fichier . csproj .To use user secrets, define a UserSecretsId element within a PropertyGroup of the .csproj file. Le texte interne de UserSecretsId est arbitraire, mais il est unique pour le projet.The inner text of UserSecretsId is arbitrary, but is unique to the project. Les développeurs génèrent généralement un GUID pour le UserSecretsId.Developers typically generate a GUID for the UserSecretsId.

<PropertyGroup>
  <TargetFramework>netcoreapp2.1</TargetFramework>
  <UserSecretsId>79a3edd0-2092-40a2-a04d-dcb46d5ca9ed</UserSecretsId>
</PropertyGroup>
<PropertyGroup>
  <TargetFramework>netcoreapp1.1</TargetFramework>
  <UserSecretsId>1242d6d6-9df3-4031-b031-d9b27d13c25a</UserSecretsId>
</PropertyGroup>

Conseil

Dans Visual Studio, cliquez avec le bouton droit sur le projet dans Explorateur de solutions, puis sélectionnez gérer les secrets d’utilisateur dans le menu contextuel.In Visual Studio, right-click the project in Solution Explorer, and select Manage User Secrets from the context menu. Ce geste ajoute un élément UserSecretsId, rempli avec un GUID, au fichier . csproj .This gesture adds a UserSecretsId element, populated with a GUID, to the .csproj file.

Définir une clé secrèteSet a secret

Définissez un secret d’application comprenant une clé et sa valeur.Define an app secret consisting of a key and its value. Le secret est associé à la valeur de UserSecretsId du projet.The secret is associated with the project's UserSecretsId value. Par exemple, exécutez la commande suivante à partir du répertoire dans lequel se trouve le fichier . csproj :For example, run the following command from the directory in which the .csproj file exists:

dotnet user-secrets set "Movies:ServiceApiKey" "12345"

Dans l’exemple précédent, le signe deux-points indique que Movies est un littéral d’objet avec une propriété ServiceApiKey.In the preceding example, the colon denotes that Movies is an object literal with a ServiceApiKey property.

L’outil Gestionnaire de secret peut également être utilisé à partir d’autres annuaires.The Secret Manager tool can be used from other directories too. Utilisez l’option --project pour fournir le chemin d’accès au système de fichiers où se trouve le fichier . csproj .Use the --project option to supply the file system path at which the .csproj file exists. Par exemple :For example:

dotnet user-secrets set "Movies:ServiceApiKey" "12345" --project "C:\apps\WebApp1\src\WebApp1"

Aplatissement de la structure JSON dans Visual StudioJSON structure flattening in Visual Studio

Le geste gérer les secrets de l’utilisateur de Visual Studio ouvre un fichier secrets. JSON dans l’éditeur de texte.Visual Studio's Manage User Secrets gesture opens a secrets.json file in the text editor. Remplacez le contenu de secrets. JSON par les paires clé-valeur à stocker.Replace the contents of secrets.json with the key-value pairs to be stored. Par exemple :For example:

{
  "Movies": {
    "ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;Trusted_Connection=True;MultipleActiveResultSets=true",
    "ServiceApiKey": "12345"
  }
}

La structure JSON est aplatie après des modifications via dotnet user-secrets remove ou dotnet user-secrets set.The JSON structure is flattened after modifications via dotnet user-secrets remove or dotnet user-secrets set. Par exemple, l’exécution de dotnet user-secrets remove "Movies:ConnectionString" réduit le littéral d’objet Movies.For example, running dotnet user-secrets remove "Movies:ConnectionString" collapses the Movies object literal. Le fichier modifié ressemble à ce qui suit :The modified file resembles the following:

{
  "Movies:ServiceApiKey": "12345"
}

Définir plusieurs secretsSet multiple secrets

Un lot de secrets peut être défini par la canalisation JSON à la commande set.A batch of secrets can be set by piping JSON to the set command. Dans l’exemple suivant, le contenu du fichier Input. JSON est dirigé vers la commande set.In the following example, the input.json file's contents are piped to the set command.

Ouvrez une interface de commande, puis exécutez la commande suivante :Open a command shell, and execute the following command:

type .\input.json | dotnet user-secrets set

Accéder à une clé secrèteAccess a secret

L' API de Configuration ASP.net Core permet d’accéder aux secrets du gestionnaire de secret.The ASP.NET Core Configuration API provides access to Secret Manager secrets.

Si votre projet cible .NET Framework, installez le package NuGet Microsoft. extensions. Configuration. UserSecrets .If your project targets .NET Framework, install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

Dans ASP.NET Core 2,0 ou version ultérieure, la source de configuration des secrets de l’utilisateur est automatiquement ajoutée en mode de développement lorsque le projet appelle CreateDefaultBuilder pour initialiser une nouvelle instance de l’hôte avec des valeurs par défaut préconfigurées.In ASP.NET Core 2.0 or later, the user secrets configuration source is automatically added in development mode when the project calls CreateDefaultBuilder to initialize a new instance of the host with preconfigured defaults. CreateDefaultBuilder appelle AddUserSecrets lorsque le EnvironmentName est Development:CreateDefaultBuilder calls AddUserSecrets when the EnvironmentName is Development:

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>();
public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Quand CreateDefaultBuilder n’est pas appelé, ajoutez explicitement la source de configuration des secrets de l’utilisateur en appelant AddUserSecrets dans le constructeur Startup.When CreateDefaultBuilder isn't called, add the user secrets configuration source explicitly by calling AddUserSecrets in the Startup constructor. Appelez AddUserSecrets uniquement lorsque l’application s’exécute dans l’environnement de développement, comme illustré dans l’exemple suivant :Call AddUserSecrets only when the app runs in the Development environment, as shown in the following example:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", 
                     optional: false, 
                     reloadOnChange: true)
        .AddEnvironmentVariables();

    if (env.IsDevelopment())
    {
        builder.AddUserSecrets<Startup>();
    }

    Configuration = builder.Build();
}
public Startup(IWebHostEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", 
                     optional: false, 
                     reloadOnChange: true)
        .AddEnvironmentVariables();

    if (env.IsDevelopment())
    {
        builder.AddUserSecrets<Startup>();
    }

    Configuration = builder.Build();
}

Installez le package NuGet Microsoft. extensions. Configuration. UserSecrets .Install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

Ajoutez la source de configuration des secrets de l’utilisateur à l’aide d’un appel à AddUserSecrets dans le constructeur Startup :Add the user secrets configuration source with a call to AddUserSecrets in the Startup constructor:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", 
                     optional: false, 
                     reloadOnChange: true)
        .AddEnvironmentVariables();

    if (env.IsDevelopment())
    {
        builder.AddUserSecrets<Startup>();
    }

    Configuration = builder.Build();
}

Les secrets de l’utilisateur peuvent être récupérés via l’API Configuration :User secrets can be retrieved via the Configuration API:

public class Startup
{
    private string _moviesApiKey = null;

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        _moviesApiKey = Configuration["Movies:ServiceApiKey"];
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Run(async (context) =>
        {
            var result = string.IsNullOrEmpty(_moviesApiKey) ? "Null" : "Not Null";
            await context.Response.WriteAsync($"Secret is {result}");
        });
    }
}
public class Startup
{
    private string _moviesApiKey = null;
    
    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", 
                         optional: false, 
                         reloadOnChange: true)
            .AddEnvironmentVariables();

        if (env.IsDevelopment())
        {
            builder.AddUserSecrets<Startup>();
        }

        Configuration = builder.Build();
    }

    public IConfigurationRoot Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        _moviesApiKey = Configuration["Movies:ServiceApiKey"];
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Run(async (context) =>
        {
            var result = string.IsNullOrEmpty(_moviesApiKey) ? "Null" : "Not Null";
            await context.Response.WriteAsync($"Secret is {result}");
        });
    }
}

Mapper les secrets à un POCOMap secrets to a POCO

Le mappage d’un littéral d’objet entier à un POCO (une classe .NET simple avec des propriétés) est utile pour l’agrégation des propriétés associées.Mapping an entire object literal to a POCO (a simple .NET class with properties) is useful for aggregating related properties.

Supposons que l’application secrets.json fichier contient les secrets de deux suivantes :Assume the app's secrets.json file contains the following two secrets:

{
  "Movies": {
    "ServiceApiKey": "12345",
    "ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Pour mapper les secrets précédents à un POCO, utilisez la fonctionnalité de liaison de graphique d’objets de l’API Configuration.To map the preceding secrets to a POCO, use the Configuration API's object graph binding feature. Le code suivant est lié à un MovieSettings POCO personnalisé et accède à la valeur de la propriété ServiceApiKey :The following code binds to a custom MovieSettings POCO and accesses the ServiceApiKey property value:

var moviesConfig = Configuration.GetSection("Movies")
                                .Get<MovieSettings>();
_moviesApiKey = moviesConfig.ServiceApiKey;
var moviesConfig = new MovieSettings();
Configuration.GetSection("Movies").Bind(moviesConfig);
_moviesApiKey = moviesConfig.ServiceApiKey;

Les secrets Movies:ConnectionString et Movies:ServiceApiKey sont mappés aux propriétés respectives dans MovieSettings:The Movies:ConnectionString and Movies:ServiceApiKey secrets are mapped to the respective properties in MovieSettings:

public class MovieSettings
{
    public string ConnectionString { get; set; }

    public string ServiceApiKey { get; set; }
}

Remplacement de chaîne par des secretsString replacement with secrets

Le stockage des mots de passe en texte brut n’est pas sécurisé.Storing passwords in plain text is insecure. Par exemple, une chaîne de connexion de base de données stockée dans appSettings. JSON peut inclure un mot de passe pour l’utilisateur spécifié :For example, a database connection string stored in appsettings.json may include a password for the specified user:

{
  "ConnectionStrings": {
    "Movies": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;User Id=johndoe;Password=pass123;MultipleActiveResultSets=true"
  }
}

Une approche plus sécurisée consiste à stocker le mot de passe en tant que secret.A more secure approach is to store the password as a secret. Par exemple :For example:

dotnet user-secrets set "DbPassword" "pass123"

Supprimez la paire clé-valeur Password de la chaîne de connexion dans appSettings. JSON.Remove the Password key-value pair from the connection string in appsettings.json. Par exemple :For example:

{
  "ConnectionStrings": {
    "Movies": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;User Id=johndoe;MultipleActiveResultSets=true"
  }
}

La valeur du secret peut être définie sur la propriété Password d’un objet SqlConnectionStringBuilder pour terminer la chaîne de connexion :The secret's value can be set on a SqlConnectionStringBuilder object's Password property to complete the connection string:

public class Startup
{
    private string _connection = null;

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        var builder = new SqlConnectionStringBuilder(
            Configuration.GetConnectionString("Movies"));
        builder.Password = Configuration["DbPassword"];
        _connection = builder.ConnectionString;
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync($"DB Connection: {_connection}");
        });
    }
}
public class Startup
{
    private string _connection = null;
    
    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json",
                         optional: false,
                         reloadOnChange: true)
            .AddEnvironmentVariables();

        if (env.IsDevelopment())
        {
            builder.AddUserSecrets<Startup>();
        }

        Configuration = builder.Build();
    }

    public IConfigurationRoot Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        var builder = new SqlConnectionStringBuilder(
            Configuration.GetConnectionString("Movies"));
        builder.Password = Configuration["DbPassword"];
        _connection = builder.ConnectionString;
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync($"DB Connection: {_connection}");
        });
    }
}

Répertorier les secretsList the secrets

Supposons que l’application secrets.json fichier contient les secrets de deux suivantes :Assume the app's secrets.json file contains the following two secrets:

{
  "Movies": {
    "ServiceApiKey": "12345",
    "ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Exécutez la commande suivante à partir du répertoire dans lequel se trouve le fichier . csproj :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets list

La sortie suivante apparaît :The following output appears:

Movies:ConnectionString = Server=(localdb)\mssqllocaldb;Database=Movie-1;Trusted_Connection=True;MultipleActiveResultSets=true
Movies:ServiceApiKey = 12345

Dans l’exemple précédent, un signe deux-points dans le nom de clé désigne la hiérarchie d’objets dans secrets. JSON.In the preceding example, a colon in the key names denotes the object hierarchy within secrets.json.

Supprimer une seule clé secrèteRemove a single secret

Supposons que l’application secrets.json fichier contient les secrets de deux suivantes :Assume the app's secrets.json file contains the following two secrets:

{
  "Movies": {
    "ServiceApiKey": "12345",
    "ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Exécutez la commande suivante à partir du répertoire dans lequel se trouve le fichier . csproj :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets remove "Movies:ConnectionString"

Le fichier secrets. JSON de l’application a été modifié pour supprimer la paire clé-valeur associée à la clé de MoviesConnectionString :The app's secrets.json file was modified to remove the key-value pair associated with the MoviesConnectionString key:

{
  "Movies": {
    "ServiceApiKey": "12345"
  }
}

L’exécution de dotnet user-secrets list affiche le message suivant :Running dotnet user-secrets list displays the following message:

Movies:ServiceApiKey = 12345

Supprimer tous les secretsRemove all secrets

Supposons que l’application secrets.json fichier contient les secrets de deux suivantes :Assume the app's secrets.json file contains the following two secrets:

{
  "Movies": {
    "ServiceApiKey": "12345",
    "ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Exécutez la commande suivante à partir du répertoire dans lequel se trouve le fichier . csproj :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets clear

Tous les secrets d’utilisateur de l’application ont été supprimés du fichier secrets. JSON :All user secrets for the app have been deleted from the secrets.json file:

{}

L’exécution de dotnet user-secrets list affiche le message suivant :Running dotnet user-secrets list displays the following message:

No secrets configured for this application.

Ressources supplémentairesAdditional resources