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

Par Rick Anderson, Daniel Roth, et 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 explique les techniques permettant de stocker et de récupérer des données sensibles pendant le développement d’une application ASP.NET Core.This document explains techniques for storing and retrieving sensitive data during the development of an ASP.NET Core app. 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. Aucun secret de production ne doit pas être utilisé pour le développement ou de test.Production secrets shouldn't be used for development or test. Vous pouvez stocker et protéger les secrets de test et de production Azure avec le fournisseur de configuration Azure Key Vault.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 permettent d’éviter le stockage de 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.

Configurer la lecture des valeurs de variable d’environnement en appelant AddEnvironmentVariables dans le Startup constructeur :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();
}

Imaginez une application web ASP.NET Core dans laquelle la sécurité 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. Durant le déploiement de l’application, la valeur de la clé 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 les 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 au format texte brut non chiffré.Environment variables are generally stored in plain, unencrypted text. Si l’ordinateur ou le processus est compromis, des tiers non approuvés peuvent y accéder.If the machine or process is compromised, environment variables can be accessed by untrusted parties. Il peut donc être nécessaire de prendre des mesures supplémentaires pour empêcher la divulgation des secrets utilisateur.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 des 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. Secrets d’application sont stockés dans un emplacement distinct à partir de l’arborescence du projet.App secrets are stored in a separate location from the project tree. Les secrets d’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 d’application ne sont pas activé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és par le 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 du système de fichiers :File system path:

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

Dans l’exemple précédent, les chemins des fichiers, remplacez <user_secrets_id> avec la UserSecretsId valeur spécifiée dans le .csproj fichier.In the preceding file paths, replace <user_secrets_id> with the UserSecretsId value specified in the .csproj file.

Ne pas écrire du code qui dépend de l’emplacement ou le 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 peut être à l’avenir.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 Secret Manager est fourni avec l’interface CLI .NET Core dans le 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 du SDK .NET Core avant 2.1.300, l’installation de l’outil est nécessaire.For .NET Core SDK versions before 2.1.300, tool installation is necessary.

Conseil

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

Un avertissement s’affiche si le SDK .NET Core utilisée inclut 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).

Installer le Microsoft.Extensions.SecretManager.Tools package NuGet dans votre projet ASP.NET Core.Install the Microsoft.Extensions.SecretManager.Tools NuGet package in your ASP.NET Core project. 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 invite de commandes 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 Secret Manager affiche des exemples d’utilisation, options et l’aide de la commande :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 .csproj fichier pour exécuter les outils définis dans le .csproj du fichier DotNetCliToolReference éléments.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 Secret Manager opère 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 Secret Manager inclut un init commande dans le 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 les secrets de l’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 UserSecretsId élément au sein d’un PropertyGroup de la .csproj fichier.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 au projet.The inner text is arbitrary, but is unique to the project.

Pour utiliser les secrets des utilisateurs, définir un UserSecretsId élément au sein d’un PropertyGroup de la .csproj fichier.To use user secrets, define a UserSecretsId element within a PropertyGroup of the .csproj file. Le texte interne de UserSecretsId est arbitraire, mais est unique au 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 sur le projet dans l’Explorateur de solutions, puis sélectionnez gérer les Secrets 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 mouvement ajoute un UserSecretsId élément, rempli avec un GUID, à la .csproj fichier.This gesture adds a UserSecretsId element, populated with a GUID, to the .csproj file.

Définir une clé secrèteSet a secret

Définir une clé secrète d’application composée d’une clé et sa valeur.Define an app secret consisting of a key and its value. Le secret est associé avec le projet UserSecretsId valeur.The secret is associated with the project's UserSecretsId value. Par exemple, exécutez la commande suivante à partir du répertoire dans lequel le .csproj fichier existe :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 objet littéral avec un ServiceApiKey propriété.In the preceding example, the colon denotes that Movies is an object literal with a ServiceApiKey property.

L’outil Secret Manager peut être utilisé à partir d’autres répertoires.The Secret Manager tool can be used from other directories too. Utilisez le --project option pour fournir le chemin d’accès de système de fichier à partir duquel le .csproj fichier existe.Use the --project option to supply the file system path at which the .csproj file exists. Exemple :For example:

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

Structure JSON mise à plat dans Visual StudioJSON structure flattening in Visual Studio

De Visual Studio gérer les Secrets utilisateur mouvements ouvre un secrets.json fichier 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 avec les paires clé-valeur à stocker.Replace the contents of secrets.json with the key-value pairs to be stored. 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 les modifications opérées par le biais de 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, en cours d’exécution dotnet user-secrets remove "Movies:ConnectionString" réduit le Movies littéral d’objet.For example, running dotnet user-secrets remove "Movies:ConnectionString" collapses the Movies object literal. Le fichier modifié ressemble à ceci :The modified file resembles the following:

{
  "Movies:ServiceApiKey": "12345"
}

Définir plusieurs clés secrètesSet multiple secrets

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

Ouvrez une invite de commandes et 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

Le API de Configuration ASP.NET Core fournit l’accès aux clés secrètes Secret Manager.The ASP.NET Core Configuration API provides access to Secret Manager secrets.

Si votre projet cible .NET Framework, installez le Microsoft.Extensions.Configuration.UserSecrets package NuGet.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 de secrets 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 les valeurs par défaut préconfigurés.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 appels 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>();

Lorsque CreateDefaultBuilder n’est pas appelée, ajouter la source de configuration de secrets utilisateur explicitement en appelant AddUserSecrets dans le Startup constructeur.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();
}

Installer le Microsoft.Extensions.Configuration.UserSecrets package NuGet.Install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

Ajouter la source de configuration de secrets utilisateur avec un appel à AddUserSecrets dans le Startup constructeur :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();
}

Secrets de l’utilisateur peuvent être récupérées via la Configuration API :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)
    {
        var result = string.IsNullOrEmpty(_moviesApiKey) ? "Null" : "Not Null";
        app.Run(async (context) =>
        {
            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)
    {
        var result = string.IsNullOrEmpty(_moviesApiKey) ? "Null" : "Not Null";
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync($"Secret is {result}");
        });
    }
}

Mapper des secrets à un objet POCOMap secrets to a POCO

Mappage d’un littéral d’objet entier à un objet POCO (une classe .NET simple avec des propriétés) est utile pour l’agrégation des propriétés connexes.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édentes à un objet POCO, utilisez le Configuration API de liaison du graphique d’objet fonctionnalité.To map the preceding secrets to a POCO, use the Configuration API's object graph binding feature. Le code suivant lie un personnalisé MovieSettings POCO et accède à la ServiceApiKey valeur de propriété :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;

Le Movies:ConnectionString et Movies:ServiceApiKey secrets sont mappées 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 avec des secretsString replacement with secrets

Stocker les 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ées 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. Exemple :For example:

dotnet user-secrets set "DbPassword" "pass123"

Supprimer le Password paire clé-valeur à partir de la chaîne de connexion dans appsettings.json.Remove the Password key-value pair from the connection string in appsettings.json. Exemple :For example:

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

Valeur du secret peut être définie sur une SqlConnectionStringBuilder l’objet Password propriété 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 clés secrètesList 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 le .csproj fichier existe :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 les noms de clé désigne la hiérarchie d’objets au sein de secrets.json.In the preceding example, a colon in the key names denotes the object hierarchy within secrets.json.

Supprimer un secret uniqueRemove 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 le .csproj fichier existe :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets remove "Movies:ConnectionString"

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

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

En cours d’exécution 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 le .csproj fichier existe :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets clear

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

{}

En cours d’exécution 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