Armazenamento seguro de segredos do aplicativo em desenvolvimento no ASP.NET CoreSafe storage of app secrets in development in ASP.NET Core

Por Rick Anderson, Daniel Rothe Scott AddieBy Rick Anderson, Daniel Roth, and Scott Addie

Exibir ou baixar código de exemplo (como baixar)View or download sample code (how to download)

Este documento explica técnicas para armazenar e recuperar dados confidenciais durante o desenvolvimento de um aplicativo ASP.NET Core.This document explains techniques for storing and retrieving sensitive data during the development of an ASP.NET Core app. Nunca armazene senhas ou outros dados confidenciais no código-fonte.Never store passwords or other sensitive data in source code. Os segredos de produção não devem ser usados para desenvolvimento ou teste.Production secrets shouldn't be used for development or test. Os segredos não devem ser implantados com o aplicativo.Secrets shouldn't be deployed with the app. Em vez disso, os segredos devem ser disponibilizados no ambiente de produção por meio de um meio controlado, como variáveis de ambiente, Azure Key Vault, etc. Você pode armazenar e proteger os segredos de produção e de teste do Azure com o provedor de configuração 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.

Variáveis de ambienteEnvironment variables

As variáveis de ambiente são usadas para evitar o armazenamento de segredos do aplicativo no código ou nos arquivos de configuração locais.Environment variables are used to avoid storage of app secrets in code or in local configuration files. Variáveis de ambiente substituem valores de configuração para todas as fontes de configuração especificadas anteriormente.Environment variables override configuration values for all previously specified configuration sources.

Configure a leitura de valores de variáveis de ambiente chamando AddEnvironmentVariables no construtor de 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();
}

Considere um aplicativo Web ASP.NET Core no qual a segurança das contas de usuário individuais está habilitada.Consider an ASP.NET Core web app in which Individual User Accounts security is enabled. Uma cadeia de conexão de banco de dados padrão é incluída no arquivo appSettings. JSON do projeto com a chave DefaultConnection.A default database connection string is included in the project's appsettings.json file with the key DefaultConnection. A cadeia de conexão padrão é para o LocalDB, que é executado no modo de usuário e não requer uma senha.The default connection string is for LocalDB, which runs in user mode and doesn't require a password. Durante a implantação do aplicativo, o valor da chave de DefaultConnection pode ser substituído por um valor de variável de ambiente.During app deployment, the DefaultConnection key value can be overridden with an environment variable's value. A variável de ambiente pode armazenar a cadeia de conexão completa com credenciais confidenciais.The environment variable may store the complete connection string with sensitive credentials.

Aviso

Variáveis de ambiente geralmente são armazenadas em texto simples e não criptografado.Environment variables are generally stored in plain, unencrypted text. Se o computador ou o processo estiver comprometido, as variáveis de ambiente poderão ser acessadas por partes não confiáveis.If the machine or process is compromised, environment variables can be accessed by untrusted parties. Outras medidas para evitar a divulgação de segredos do usuário podem ser necessárias.Additional measures to prevent disclosure of user secrets may be required.

Ao trabalhar com chaves hierárquicas em variáveis ​​de ambiente, um separador de dois-pontos (:) pode não funcionar em todas as plataformas (por exemplo, Bash).When working with hierarchical keys in environment variables, a colon separator (:) may not work on all platforms (for example, Bash). Um sublinhado duplo (__) é compatível com todas as plataformas e é substituído automaticamente por dois-pontos.A double underscore (__) is supported by all platforms and is automatically replaced by a colon.

Gerenciador de segredoSecret Manager

A ferramenta Gerenciador de segredo armazena dados confidenciais durante o desenvolvimento de um projeto ASP.NET Core.The Secret Manager tool stores sensitive data during the development of an ASP.NET Core project. Nesse contexto, um elemento de dados confidenciais é um segredo do aplicativo.In this context, a piece of sensitive data is an app secret. Os segredos do aplicativo são armazenados em um local separado da árvore do projeto.App secrets are stored in a separate location from the project tree. Os segredos do aplicativo são associados a um projeto específico ou compartilhados entre vários projetos.The app secrets are associated with a specific project or shared across several projects. Os segredos do aplicativo não são verificados no controle do código-fonte.The app secrets aren't checked into source control.

Aviso

A ferramenta Gerenciador de segredo não criptografa os segredos armazenados e não deve ser tratada como um repositório confiável.The Secret Manager tool doesn't encrypt the stored secrets and shouldn't be treated as a trusted store. É apenas para fins de desenvolvimento.It's for development purposes only. As chaves e os valores são armazenados em um arquivo de configuração JSON no diretório de perfil do usuário.The keys and values are stored in a JSON configuration file in the user profile directory.

Como funciona a ferramenta Gerenciador de segredoHow the Secret Manager tool works

A ferramenta Gerenciador de segredo abstrai os detalhes da implementação, como onde e como os valores são armazenados.The Secret Manager tool abstracts away the implementation details, such as where and how the values are stored. Você pode usar a ferramenta sem conhecer esses detalhes de implementação.You can use the tool without knowing these implementation details. Os valores são armazenados em um arquivo de configuração JSON em uma pasta de perfil de usuário protegida pelo sistema no computador local:The values are stored in a JSON configuration file in a system-protected user profile folder on the local machine:

Caminho do sistema de arquivos:File system path:

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

Nos caminhos de arquivo anteriores, substitua <user_secrets_id> pelo valor de UserSecretsId especificado no arquivo . csproj .In the preceding file paths, replace <user_secrets_id> with the UserSecretsId value specified in the .csproj file.

Não escreva o código que depende do local ou do formato dos dados salvos com a ferramenta Gerenciador de segredo.Don't write code that depends on the location or format of data saved with the Secret Manager tool. Esses detalhes de implementação podem ser alterados.These implementation details may change. Por exemplo, os valores secretos não são criptografados, mas podem estar no futuro.For example, the secret values aren't encrypted, but could be in the future.

Instalar a ferramenta Gerenciador de segredoInstall the Secret Manager tool

A ferramenta Gerenciador de segredo é agrupada com o CLI do .NET Core no SDK do .NET Core 2.1.300 ou posterior.The Secret Manager tool is bundled with the .NET Core CLI in .NET Core SDK 2.1.300 or later. Para SDK do .NET Core versões anteriores ao 2.1.300, a instalação da ferramenta é necessária.For .NET Core SDK versions before 2.1.300, tool installation is necessary.

Dica

Execute dotnet --version de um shell de comando para ver o número da versão do SDK do .NET Core instalado.Run dotnet --version from a command shell to see the installed .NET Core SDK version number.

Um aviso será exibido se o SDK do .NET Core que está sendo usado incluir a ferramenta: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).

Instale o pacote NuGet Microsoft. Extensions. secretomanager. Tools em seu projeto ASP.NET Core.Install the Microsoft.Extensions.SecretManager.Tools NuGet package in your ASP.NET Core project. Por exemplo: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>

Execute o seguinte comando em um shell de comando para validar a instalação da ferramenta:Execute the following command in a command shell to validate the tool installation:

dotnet user-secrets -h

A ferramenta Gerenciador de segredo exibe o uso de exemplo, as opções e a ajuda de comando: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.

Observação

Você deve estar no mesmo diretório que o arquivo . csproj para executar ferramentas definidas nos elementos de DotNetCliToolReference do arquivo . csproj .You must be in the same directory as the .csproj file to run tools defined in the .csproj file's DotNetCliToolReference elements.

Habilitar o armazenamento secretoEnable secret storage

A ferramenta Gerenciador de segredo opera em definições de configuração específicas do projeto armazenadas no seu perfil de usuário.The Secret Manager tool operates on project-specific configuration settings stored in your user profile.

A ferramenta Gerenciador de segredo inclui um comando init no SDK do .NET Core 3.0.100 ou posterior.The Secret Manager tool includes an init command in .NET Core SDK 3.0.100 or later. Para usar os segredos do usuário, execute o seguinte comando no diretório do projeto:To use user secrets, run the following command in the project directory:

dotnet user-secrets init

O comando anterior adiciona um elemento UserSecretsId dentro de uma PropertyGroup do arquivo . csproj .The preceding command adds a UserSecretsId element within a PropertyGroup of the .csproj file. Por padrão, o texto interno de UserSecretsId é um GUID.By default, the inner text of UserSecretsId is a GUID. O texto interno é arbitrário, mas é exclusivo para o projeto.The inner text is arbitrary, but is unique to the project.

Para usar os segredos do usuário, defina um elemento UserSecretsId dentro de uma PropertyGroup do arquivo . csproj .To use user secrets, define a UserSecretsId element within a PropertyGroup of the .csproj file. O texto interno de UserSecretsId é arbitrário, mas é exclusivo para o projeto.The inner text of UserSecretsId is arbitrary, but is unique to the project. Os desenvolvedores normalmente geram um GUID para o 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>

Dica

No Visual Studio, clique com o botão direito do mouse no projeto em Gerenciador de Soluções e selecione gerenciar segredos do usuário no menu de contexto.In Visual Studio, right-click the project in Solution Explorer, and select Manage User Secrets from the context menu. Esse gesto adiciona um elemento UserSecretsId, populado com um GUID, ao arquivo . csproj .This gesture adds a UserSecretsId element, populated with a GUID, to the .csproj file.

Definir um segredoSet a secret

Defina um segredo de aplicativo que consiste em uma chave e seu valor.Define an app secret consisting of a key and its value. O segredo é associado ao valor de UserSecretsId do projeto.The secret is associated with the project's UserSecretsId value. Por exemplo, execute o seguinte comando do diretório no qual o arquivo . csproj existe:For example, run the following command from the directory in which the .csproj file exists:

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

No exemplo anterior, os dois pontos indica que Movies é um literal de objeto com uma propriedade ServiceApiKey.In the preceding example, the colon denotes that Movies is an object literal with a ServiceApiKey property.

A ferramenta Gerenciador de segredo também pode ser usada em outros diretórios.The Secret Manager tool can be used from other directories too. Use a opção --project para fornecer o caminho do sistema de arquivos no qual o arquivo . csproj existe.Use the --project option to supply the file system path at which the .csproj file exists. Por exemplo:For example:

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

Nivelamento de estrutura JSON no Visual StudioJSON structure flattening in Visual Studio

O gesto gerenciar segredos do usuário do Visual Studio abre um arquivo segredos. JSON no editor de texto.Visual Studio's Manage User Secrets gesture opens a secrets.json file in the text editor. Substitua o conteúdo de Secrets. JSON pelos pares de chave-valor a serem armazenados.Replace the contents of secrets.json with the key-value pairs to be stored. Por exemplo:For example:

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

A estrutura JSON é achatada após modificações 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. Por exemplo, executar dotnet user-secrets remove "Movies:ConnectionString" recolhe o literal do objeto Movies.For example, running dotnet user-secrets remove "Movies:ConnectionString" collapses the Movies object literal. O arquivo modificado é semelhante ao seguinte:The modified file resembles the following:

{
  "Movies:ServiceApiKey": "12345"
}

Definir vários segredosSet multiple secrets

Um lote de segredos pode ser definido por meio de tubulação JSON para o comando set.A batch of secrets can be set by piping JSON to the set command. No exemplo a seguir, o conteúdo do arquivo Input. JSON é canalizado para o comando set.In the following example, the input.json file's contents are piped to the set command.

Abra um shell de comando e execute o seguinte comando:Open a command shell, and execute the following command:

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

Acessar um segredoAccess a secret

A API de configuração do ASP.NET Core fornece acesso aos segredos do Gerenciador de segredo.The ASP.NET Core Configuration API provides access to Secret Manager secrets.

Se seu projeto tiver como destino .NET Framework, instale o pacote NuGet Microsoft. Extensions. Configuration. Usersecretos .If your project targets .NET Framework, install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

No ASP.NET Core 2,0 ou posterior, a fonte de configuração de segredos do usuário é adicionada automaticamente no modo de desenvolvimento quando o projeto chama CreateDefaultBuilder para inicializar uma nova instância do host com padrões pré-configurados.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 chama AddUserSecrets quando o EnvironmentName é 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>();
        });

Quando CreateDefaultBuilder não for chamado, adicione a fonte de configuração de segredos do usuário explicitamente chamando AddUserSecrets no Construtor Startup.When CreateDefaultBuilder isn't called, add the user secrets configuration source explicitly by calling AddUserSecrets in the Startup constructor. Chame AddUserSecrets somente quando o aplicativo for executado no ambiente de desenvolvimento, conforme mostrado no exemplo a seguir: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();
}

Instale o pacote NuGet Microsoft. Extensions. Configuration. Usersecretos .Install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

Adicione a fonte de configuração de segredos do usuário com uma chamada para AddUserSecrets no construtor de 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();
}

Os segredos do usuário podem ser recuperados por meio da 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}");
        });
    }
}

Mapear segredos para um POCOMap secrets to a POCO

O mapeamento de um literal de objeto inteiro para um POCO (uma classe .NET simples com propriedades) é útil para agregar propriedades relacionadas.Mapping an entire object literal to a POCO (a simple .NET class with properties) is useful for aggregating related properties.

Suponha que o aplicativo Secrets arquivo contém os dois segredos do seguintes: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"
  }
}

Para mapear os segredos anteriores para um POCO, use o recurso de Associação de gráfico de objetos da API do Configuration.To map the preceding secrets to a POCO, use the Configuration API's object graph binding feature. O código a seguir é associado a uma MovieSettings personalizada POCO e acessa o valor da propriedade 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;

Os segredos de Movies:ConnectionString e Movies:ServiceApiKey são mapeados para as respectivas propriedades no 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; }
}

Substituição de cadeia de caracteres com segredosString replacement with secrets

O armazenamento de senhas em texto sem formatação não é seguro.Storing passwords in plain text is insecure. Por exemplo, uma cadeia de conexão de banco de dados armazenada em appSettings. JSON pode incluir uma senha para o usuário especificado: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"
  }
}

Uma abordagem mais segura é armazenar a senha como um segredo.A more secure approach is to store the password as a secret. Por exemplo:For example:

dotnet user-secrets set "DbPassword" "pass123"

Remova o Password par chave-valor da cadeia de conexão em appSettings. JSON.Remove the Password key-value pair from the connection string in appsettings.json. Por exemplo:For example:

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

O valor do segredo pode ser definido em uma propriedade Password do objeto de SqlConnectionStringBuilder para concluir a cadeia de conexão: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}");
        });
    }
}

Listar os segredosList the secrets

Suponha que o aplicativo Secrets arquivo contém os dois segredos do seguintes: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"
  }
}

Execute o seguinte comando do diretório no qual o arquivo . csproj existe:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets list

A saída a seguir é exibida:The following output appears:

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

No exemplo anterior, dois-pontos nos nomes de chave denota a hierarquia de objeto dentro de segredos. JSON.In the preceding example, a colon in the key names denotes the object hierarchy within secrets.json.

Remover um único segredoRemove a single secret

Suponha que o aplicativo Secrets arquivo contém os dois segredos do seguintes: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"
  }
}

Execute o seguinte comando do diretório no qual o arquivo . csproj existe:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets remove "Movies:ConnectionString"

O arquivo segredos. JSON do aplicativo foi modificado para remover o par chave-valor associado à chave de MoviesConnectionString:The app's secrets.json file was modified to remove the key-value pair associated with the MoviesConnectionString key:

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

A execução de dotnet user-secrets list exibe a seguinte mensagem:Running dotnet user-secrets list displays the following message:

Movies:ServiceApiKey = 12345

Remover todos os segredosRemove all secrets

Suponha que o aplicativo Secrets arquivo contém os dois segredos do seguintes: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"
  }
}

Execute o seguinte comando do diretório no qual o arquivo . csproj existe:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets clear

Todos os segredos do usuário para o aplicativo foram excluídos do arquivo segredos. JSON :All user secrets for the app have been deleted from the secrets.json file:

{}

A execução de dotnet user-secrets list exibe a seguinte mensagem:Running dotnet user-secrets list displays the following message:

No secrets configured for this application.

Recursos adicionaisAdditional resources