Bezpečné ukládání tajných kódů aplikací ve vývoji v ASP.NET CoreSafe storage of app secrets in development in ASP.NET Core

Od Rick Anderson, Daniel Skořepaa Scott AddieBy Rick Anderson, Daniel Roth, and Scott Addie

Zobrazení nebo stažení ukázkového kódu (stažení)View or download sample code (how to download)

Tento dokument vysvětluje techniky pro ukládání a načítání citlivých dat během vývoje aplikace ASP.NET Core.This document explains techniques for storing and retrieving sensitive data during the development of an ASP.NET Core app. Nikdy neukládejte hesla nebo další citlivá data ve zdrojovém kódu.Never store passwords or other sensitive data in source code. Provozní tajemství by se neměla používat pro vývoj nebo testování.Production secrets shouldn't be used for development or test. Pomocí poskytovatele konfigurace Azure Key Vaultmůžete ukládat a chránit tajné kódy Azure test a produkčního prostředí.You can store and protect Azure test and production secrets with the Azure Key Vault configuration provider.

Proměnné prostředíEnvironment variables

Proměnné prostředí se používají k tomu, aby nedocházelo k ukládání tajných klíčů k aplikacím v kódu nebo v místních konfiguračních souborech.Environment variables are used to avoid storage of app secrets in code or in local configuration files. Proměnné prostředí přepíšou konfigurační hodnoty pro všechny dříve zadané zdroje konfigurace.Environment variables override configuration values for all previously specified configuration sources.

Nakonfigurujte čtení hodnot proměnných prostředí voláním AddEnvironmentVariables Startup v konstruktoru: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();
}

Vezměte v úvahu ASP.NET Core webovou aplikaci, ve které je povolené zabezpečení individuálních uživatelských účtů .Consider an ASP.NET Core web app in which Individual User Accounts security is enabled. Výchozí připojovací řetězec databáze je obsažen v souboru appSettings. JSON projektu s klíčem DefaultConnection.A default database connection string is included in the project's appsettings.json file with the key DefaultConnection. Výchozí připojovací řetězec je pro LocalDB, který běží v uživatelském režimu a nevyžaduje heslo.The default connection string is for LocalDB, which runs in user mode and doesn't require a password. Během nasazování DefaultConnection aplikace se hodnota klíče dá přepsat hodnotou proměnné prostředí.During app deployment, the DefaultConnection key value can be overridden with an environment variable's value. Proměnná prostředí může ukládat úplný připojovací řetězec s citlivými přihlašovacími údaji.The environment variable may store the complete connection string with sensitive credentials.

Varování

Proměnné prostředí se většinou ukládají v prostém, nešifrovaném textu.Environment variables are generally stored in plain, unencrypted text. Pokud dojde k ohrožení bezpečnosti počítače nebo procesu, jsou proměnné prostředí dostupné nedůvěryhodnými stranami.If the machine or process is compromised, environment variables can be accessed by untrusted parties. Další opatření, která zabraňují odhalení tajných kódů uživateli, mohou být povinná.Additional measures to prevent disclosure of user secrets may be required.

Když pracujete s hierarchickými klíči v proměnných prostředí, oddělovač dvojtečky (:) nemusí fungovat na všech platformách (například bash).When working with hierarchical keys in environment variables, a colon separator (:) may not work on all platforms (for example, Bash). Dvojité podtržítko (__) je podporováno všemi platformami a je automaticky nahrazeno dvojtečkou.A double underscore (__) is supported by all platforms and is automatically replaced by a colon.

Správce tajných klíčůSecret Manager

Nástroj Správce tajných klíčů ukládá citlivé údaje během vývoje ASP.NET Core projektu.The Secret Manager tool stores sensitive data during the development of an ASP.NET Core project. V tomto kontextu je část citlivých dat tajný klíč aplikace.In this context, a piece of sensitive data is an app secret. Tajné klíče aplikace se ukládají v odděleném umístění ze stromu projektu.App secrets are stored in a separate location from the project tree. Tajné klíče aplikace jsou přidruženy k určitému projektu nebo sdíleny napříč několika projekty.The app secrets are associated with a specific project or shared across several projects. Tajné kódy aplikace nejsou zaregistrovány do správy zdrojového kódu.The app secrets aren't checked into source control.

Varování

Nástroj Správce tajných klíčů nešifruje uložené tajné klíče a neměl by být považován za důvěryhodné úložiště.The Secret Manager tool doesn't encrypt the stored secrets and shouldn't be treated as a trusted store. Pouze pro účely vývoje.It's for development purposes only. Klíče a hodnoty jsou uložené v konfiguračním souboru JSON v adresáři profilu uživatele.The keys and values are stored in a JSON configuration file in the user profile directory.

Jak funguje nástroj Správce tajných klíčůHow the Secret Manager tool works

Nástroj Správce tajných klíčů vyříznout podrobnosti implementace, například WHERE a způsob uložení hodnot.The Secret Manager tool abstracts away the implementation details, such as where and how the values are stored. Tento nástroj můžete použít bez znalosti těchto podrobností implementace.You can use the tool without knowing these implementation details. Hodnoty jsou uložené v konfiguračním souboru JSON ve složce profilu uživatele chráněné systémem v místním počítači:The values are stored in a JSON configuration file in a system-protected user profile folder on the local machine:

Cesta k systému souborů:File system path:

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

V předchozích cestách souborů nahraďte <user_secrets_id> UserSecretsId hodnotou zadanou v souboru . csproj .In the preceding file paths, replace <user_secrets_id> with the UserSecretsId value specified in the .csproj file.

Nepište kód, který závisí na umístění nebo formátu dat uložených pomocí nástroje Správce tajných klíčů.Don't write code that depends on the location or format of data saved with the Secret Manager tool. Tyto podrobnosti implementace se můžou změnit.These implementation details may change. Například tajné hodnoty nejsou šifrovány, ale mohou být v budoucnu.For example, the secret values aren't encrypted, but could be in the future.

Instalace nástroje Správce tajných klíčůInstall the Secret Manager tool

Nástroj Správce tajných klíčů je součástí .NET Core CLI v .NET Core SDK 2.1.300 nebo novějším.The Secret Manager tool is bundled with the .NET Core CLI in .NET Core SDK 2.1.300 or later. Pro .NET Core SDK verze před 2.1.300 je instalace nástroje nutná.For .NET Core SDK versions before 2.1.300, tool installation is necessary.

Tip

Pokud dotnet --version chcete zobrazit nainstalované číslo verze .NET Core SDK, spusťte z příkazového prostředí.Run dotnet --version from a command shell to see the installed .NET Core SDK version number.

Zobrazí se upozornění, pokud .NET Core SDK používá nástroj: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).

Do projektu ASP.NET Core nainstalujte balíček NuGet Microsoft. Extensions. SecretManager. Tools .Install the Microsoft.Extensions.SecretManager.Tools NuGet package in your ASP.NET Core project. Příklad: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>

Spuštěním následujícího příkazu v příkazovém prostředí Ověřte instalaci nástroje:Execute the following command in a command shell to validate the tool installation:

dotnet user-secrets -h

Nástroj Správce tajných klíčů zobrazuje ukázkové použití, možnosti a nápovědu k příkazům: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.

Poznámka

Musíte být ve stejném adresáři jako soubor . csproj ke spuštění nástrojů definovaných v DotNetCliToolReference prvcích souboru . csproj .You must be in the same directory as the .csproj file to run tools defined in the .csproj file's DotNetCliToolReference elements.

Povolit tajné úložištěEnable secret storage

Nástroj Správce tajných klíčů pracuje na nastavení konfigurace specifické pro projekt uložené v profilu uživatele.The Secret Manager tool operates on project-specific configuration settings stored in your user profile.

Nástroj Správce tajných klíčů obsahuje init příkaz v .NET Core SDK 3.0.100 nebo novějším.The Secret Manager tool includes an init command in .NET Core SDK 3.0.100 or later. Chcete-li použít tajné klíče uživatele, spusťte následující příkaz v adresáři projektu:To use user secrets, run the following command in the project directory:

dotnet user-secrets init

Předchozí příkaz přidá UserSecretsId prvek PropertyGroup v rámci souboru . csproj .The preceding command adds a UserSecretsId element within a PropertyGroup of the .csproj file. Ve výchozím nastavení je vnitřní text pro UserSecretsId identifikátor GUID.By default, the inner text of UserSecretsId is a GUID. Vnitřní text je libovolný, ale je pro projekt jedinečný.The inner text is arbitrary, but is unique to the project.

Pro použití uživatelských tajných klíčů definujte UserSecretsId prvek PropertyGroup v rámci souboru . csproj .To use user secrets, define a UserSecretsId element within a PropertyGroup of the .csproj file. Vnitřní text UserSecretsId je libovolný, ale je pro projekt jedinečný.The inner text of UserSecretsId is arbitrary, but is unique to the project. Vývojáři obvykle generují identifikátor GUID pro 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>

Tip

V aplikaci Visual Studio klikněte pravým tlačítkem myši na projekt v Průzkumník řešení a v místní nabídce vyberte možnost spravovat tajné klíče uživatele .In Visual Studio, right-click the project in Solution Explorer, and select Manage User Secrets from the context menu. Tento gesto přidá UserSecretsId prvek, který je vyplněn identifikátorem GUID, do souboru . csproj .This gesture adds a UserSecretsId element, populated with a GUID, to the .csproj file.

Nastavení tajného klíčeSet a secret

Definujte tajný klíč aplikace skládající se z klíče a jeho hodnoty.Define an app secret consisting of a key and its value. Tajný kód je přidružený k UserSecretsId hodnotě projektu.The secret is associated with the project's UserSecretsId value. Například spusťte následující příkaz z adresáře, ve kterém existuje soubor . csproj :For example, run the following command from the directory in which the .csproj file exists:

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

V předchozím příkladu dvojtečka označuje Movies literál objektu ServiceApiKey s vlastností.In the preceding example, the colon denotes that Movies is an object literal with a ServiceApiKey property.

Nástroj Správce tajných klíčů je možné použít i v jiných adresářích.The Secret Manager tool can be used from other directories too. Pomocí možnosti zadejte cestu k systému souborů, na které existuje soubor . csproj. --projectUse the --project option to supply the file system path at which the .csproj file exists. Příklad:For example:

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

Sloučení struktury JSON v aplikaci Visual StudioJSON structure flattening in Visual Studio

Gesto Spravovat uživatelské tajemství v aplikaci Visual Studio otevře v textovém editoru soubor tajných kódů. JSON .Visual Studio's Manage User Secrets gesture opens a secrets.json file in the text editor. Nahraďte obsah tajných klíčů. JSON páry klíč-hodnota, které se mají uložit.Replace the contents of secrets.json with the key-value pairs to be stored. Příklad:For example:

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

Struktura JSON je po úpravách prostřednictvím dotnet user-secrets remove nebo dotnet user-secrets set. shrnuta.The JSON structure is flattened after modifications via dotnet user-secrets remove or dotnet user-secrets set. Například spuštění dotnet user-secrets remove "Movies:ConnectionString" sbalí Movies literál objektu.For example, running dotnet user-secrets remove "Movies:ConnectionString" collapses the Movies object literal. Změněný soubor se podobá následujícímu:The modified file resembles the following:

{
  "Movies:ServiceApiKey": "12345"
}

Nastavení více tajných klíčůSet multiple secrets

Dávku tajných kódů lze nastavit pomocí set příkazuového řádku JSON pro příkaz.A batch of secrets can be set by piping JSON to the set command. V následujícím příkladu je obsah souboru input. JSON v kanálu do set příkazu.In the following example, the input.json file's contents are piped to the set command.

Otevřete příkazové prostředí a spusťte následující příkaz:Open a command shell, and execute the following command:

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

Přístup ke tajnému kóduAccess a secret

Rozhraní API pro konfiguraci ASP.NET Core poskytuje přístup ke tajným tajným klíčům správce.The ASP.NET Core Configuration API provides access to Secret Manager secrets.

Pokud je projekt cílen .NET Framework, nainstalujte balíček NuGet Microsoft. Extensions. Configuration. UserSecrets .If your project targets .NET Framework, install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

V ASP.NET Core 2,0 nebo novějším je zdroj konfigurace tajných kódů uživatelských tajných kódů automaticky přidán do režimu vývoje CreateDefaultBuilder , pokud projekt volá inicializaci nové instance hostitele s předem konfigurovanými výchozími hodnotami.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. CreateDefaultBuildervolá AddUserSecrets se, EnvironmentName když Developmentje:CreateDefaultBuilder calls AddUserSecrets when the EnvironmentName is Development:

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>();

Pokud CreateDefaultBuilder není volána, přidejte zdroj konfigurace tajných klíčů uživatele explicitně voláním AddUserSecrets v Startup konstruktoru.When CreateDefaultBuilder isn't called, add the user secrets configuration source explicitly by calling AddUserSecrets in the Startup constructor. Volejte AddUserSecrets pouze v případě, že aplikace běží ve vývojovém prostředí, jak je znázorněno v následujícím příkladu: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();
}

Nainstalujte balíček NuGet Microsoft. Extensions. Configuration. UserSecrets .Install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

Přidejte zdroj konfigurace uživatelských tajných klíčů s voláním AddUserSecrets do Startup v konstruktoru: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();
}

Uživatelské tajné kódy lze načíst prostřednictvím Configuration rozhraní 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}");
        });
    }
}

Mapování tajných kódů na POCOMap secrets to a POCO

Mapování celého literálu objektu na POCO (jednoduchá třída .NET s vlastnostmi) je užitečná pro agregaci souvisejících vlastností.Mapping an entire object literal to a POCO (a simple .NET class with properties) is useful for aggregating related properties.

Aplikace se předpokládá secrets.json soubor obsahuje následující dvě tajných kódů: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"
  }
}

K namapování předchozích tajných kódů na POCO použijte Configuration funkci vazby grafu objektů rozhraní API.To map the preceding secrets to a POCO, use the Configuration API's object graph binding feature. Následující kód se váže k vlastnímu MovieSettings POCO a přistupuje ServiceApiKey k hodnotě vlastnosti: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;

Tajné kódy Movies:ServiceApiKeyajsou mapovány na příslušné vlastnosti v MovieSettings: Movies:ConnectionStringThe 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; }
}

Výměna řetězců s tajnými kódyString replacement with secrets

Ukládání hesel v prostém textu je nezabezpečené.Storing passwords in plain text is insecure. Připojovací řetězec databáze uložený v souboru appSettings. JSON může například zahrnovat heslo pro zadaného uživatele: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"
  }
}

Bezpečnější je ukládání hesla jako tajného klíče.A more secure approach is to store the password as a secret. Příklad:For example:

dotnet user-secrets set "DbPassword" "pass123"

Odeberte dvojici klíč-hodnota z připojovacího řetězce v souboru appSettings. JSON. PasswordRemove the Password key-value pair from the connection string in appsettings.json. Příklad:For example:

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

Hodnota tajného klíče může být nastavena na SqlConnectionStringBuilder Password vlastnost objektu pro dokončení připojovacího řetězce: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}");
        });
    }
}

Výpis tajných kódůList the secrets

Aplikace se předpokládá secrets.json soubor obsahuje následující dvě tajných kódů: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"
  }
}

Z adresáře, ve kterém existuje soubor . csproj , spusťte následující příkaz:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets list

Zobrazí se následující výstup:The following output appears:

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

V předchozím příkladu dvojtečka v názvech klíčů označuje hierarchii objektů v rámci tajných kódů. JSON.In the preceding example, a colon in the key names denotes the object hierarchy within secrets.json.

Odebrání jednoho tajného klíčeRemove a single secret

Aplikace se předpokládá secrets.json soubor obsahuje následující dvě tajných kódů: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"
  }
}

Z adresáře, ve kterém existuje soubor . csproj , spusťte následující příkaz:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets remove "Movies:ConnectionString"

Soubor tajných kódů. JSON aplikace byl změněn tak, aby odstranil dvojici klíč-hodnota přidruženou MoviesConnectionString ke klíči:The app's secrets.json file was modified to remove the key-value pair associated with the MoviesConnectionString key:

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

Při dotnet user-secrets list spuštění se zobrazí následující zpráva:Running dotnet user-secrets list displays the following message:

Movies:ServiceApiKey = 12345

Odebrat všechna tajná klíčováRemove all secrets

Aplikace se předpokládá secrets.json soubor obsahuje následující dvě tajných kódů: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"
  }
}

Z adresáře, ve kterém existuje soubor . csproj , spusťte následující příkaz:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets clear

Všechny tajné klíče uživatele pro aplikaci byly odstraněny ze souboru tajných kódů. JSON :All user secrets for the app have been deleted from the secrets.json file:

{}

Při dotnet user-secrets list spuštění se zobrazí následující zpráva:Running dotnet user-secrets list displays the following message:

No secrets configured for this application.

Další zdrojeAdditional resources