Archiviazione sicura dei segreti delle app in fase di sviluppo in ASP.NET CoreSafe storage of app secrets in development in ASP.NET Core

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

Visualizzare o scaricare il codice di esempio (procedura per il download)View or download sample code (how to download)

Questo documento illustra le tecniche per l'archiviazione e il recupero di dati sensibili durante lo sviluppo di un'app ASP.NET Core.This document explains techniques for storing and retrieving sensitive data during the development of an ASP.NET Core app. Non archiviare mai le password o altri dati sensibili nel codice sorgente.Never store passwords or other sensitive data in source code. I segreti di produzione non devono essere usati per lo sviluppo o il test.Production secrets shouldn't be used for development or test. È possibile memorizzare e proteggere i segreti relativi al test e alla produzione di Azure usando il provider di configurazione di Azure Key Vault.You can store and protect Azure test and production secrets with the Azure Key Vault configuration provider.

Variabili di ambienteEnvironment variables

Le variabili di ambiente vengono usate per evitare l'archiviazione di segreti dell'app nel codice o nei file di configurazione locali.Environment variables are used to avoid storage of app secrets in code or in local configuration files. Le variabili di ambiente sostituiscono i valori di configurazione per tutte le origini di configurazione precedentemente specificate.Environment variables override configuration values for all previously specified configuration sources.

Configurare la lettura dei valori delle variabili di AddEnvironmentVariables ambiente chiamando Startup nel costruttore: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();
}

Si consideri un'app Web ASP.NET Core in cui è abilitata la sicurezza dei singoli account utente .Consider an ASP.NET Core web app in which Individual User Accounts security is enabled. Una stringa di connessione al database predefinita è inclusa nel file appSettings. JSON del progetto con la DefaultConnectionchiave.A default database connection string is included in the project's appsettings.json file with the key DefaultConnection. La stringa di connessione predefinita è per il database locale, che viene eseguito in modalità utente e non richiede una password.The default connection string is for LocalDB, which runs in user mode and doesn't require a password. Durante la distribuzione dell'app DefaultConnection , il valore della chiave può essere sostituito con il valore di una variabile di ambiente.During app deployment, the DefaultConnection key value can be overridden with an environment variable's value. La variabile di ambiente può archiviare la stringa di connessione completa con credenziali riservate.The environment variable may store the complete connection string with sensitive credentials.

Avviso

Le variabili di ambiente vengono in genere archiviate in testo normale e non crittografato.Environment variables are generally stored in plain, unencrypted text. Se il computer o il processo è compromesso, le variabili di ambiente possono essere accessibili da entità non attendibili.If the machine or process is compromised, environment variables can be accessed by untrusted parties. Potrebbero essere necessarie misure aggiuntive per impedire la divulgazione di segreti utente.Additional measures to prevent disclosure of user secrets may be required.

Quando si usano chiavi gerarchiche in variabili di ambiente, il separatore due punti (:) potrebbe non funzionare in tutte le piattaforme (ad esempio in Bash).When working with hierarchical keys in environment variables, a colon separator (:) may not work on all platforms (for example, Bash). Il doppio carattere di sottolineatura (__) è supportato da tutte le piattaforme e viene sostituito automaticamente con i due punti.A double underscore (__) is supported by all platforms and is automatically replaced by a colon.

Gestione segretaSecret Manager

Lo strumento Gestione Secret archivia i dati sensibili durante lo sviluppo di un progetto ASP.NET Core.The Secret Manager tool stores sensitive data during the development of an ASP.NET Core project. In questo contesto, una parte di dati sensibili è un segreto dell'app.In this context, a piece of sensitive data is an app secret. I segreti dell'app vengono archiviati in un percorso separato dall'albero del progetto.App secrets are stored in a separate location from the project tree. I segreti dell'app sono associati a un progetto specifico o condivisi tra più progetti.The app secrets are associated with a specific project or shared across several projects. I segreti dell'app non vengono archiviati nel controllo del codice sorgente.The app secrets aren't checked into source control.

Avviso

Lo strumento Secret Manager non crittografa i segreti archiviati e non deve essere considerato come un archivio attendibile.The Secret Manager tool doesn't encrypt the stored secrets and shouldn't be treated as a trusted store. È solo a scopo di sviluppo.It's for development purposes only. Le chiavi e i valori vengono archiviati in un file di configurazione JSON nella directory del profilo utente.The keys and values are stored in a JSON configuration file in the user profile directory.

Funzionamento dello strumento di gestione dei segretiHow the Secret Manager tool works

Lo strumento di gestione dei segreti estrae i dettagli di implementazione, ad esempio dove e come vengono archiviati i valori.The Secret Manager tool abstracts away the implementation details, such as where and how the values are stored. È possibile utilizzare lo strumento senza conoscere i dettagli di implementazione.You can use the tool without knowing these implementation details. I valori vengono archiviati in un file di configurazione JSON in una cartella del profilo utente protetta dal sistema nel computer locale:The values are stored in a JSON configuration file in a system-protected user profile folder on the local machine:

Percorso del file System:File system path:

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

Nei percorsi di file precedenti sostituire <user_secrets_id> con il UserSecretsId valore specificato nel file con estensione csproj .In the preceding file paths, replace <user_secrets_id> with the UserSecretsId value specified in the .csproj file.

Non scrivere codice che dipende dalla posizione o dal formato dei dati salvati con lo strumento di gestione dei segreti.Don't write code that depends on the location or format of data saved with the Secret Manager tool. Questi dettagli di implementazione possono cambiare.These implementation details may change. Ad esempio, i valori dei segreti non sono crittografati, ma potrebbero essere futuri.For example, the secret values aren't encrypted, but could be in the future.

Installare lo strumento di gestione dei segretiInstall the Secret Manager tool

Lo strumento di gestione dei segreti è integrato con il interfaccia della riga di comando di .NET Core in .NET Core SDK 2.1.300 o versione successiva.The Secret Manager tool is bundled with the .NET Core CLI in .NET Core SDK 2.1.300 or later. Per .NET Core SDK versioni precedenti a 2.1.300, è necessaria l'installazione dello strumento.For .NET Core SDK versions before 2.1.300, tool installation is necessary.

Suggerimento

Eseguire dotnet --version da una shell dei comandi per visualizzare il numero di versione di .NET Core SDK installato.Run dotnet --version from a command shell to see the installed .NET Core SDK version number.

Se il .NET Core SDK usato include lo strumento, viene visualizzato un avviso: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).

Installare il pacchetto NuGet Microsoft. Extensions. SecretManager. Tools nel progetto ASP.NET Core.Install the Microsoft.Extensions.SecretManager.Tools NuGet package in your ASP.NET Core project. Ad esempio: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>

Eseguire il comando seguente in una shell dei comandi per convalidare l'installazione dello strumento:Execute the following command in a command shell to validate the tool installation:

dotnet user-secrets -h

Lo strumento Gestione segreta Visualizza l'utilizzo di esempio, le opzioni e la guida ai comandi: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.

Nota

È necessario trovarsi nella stessa directory del file con estensione csproj per eseguire gli strumenti definiti negli DotNetCliToolReference elementi del file con estensione csproj.You must be in the same directory as the .csproj file to run tools defined in the .csproj file's DotNetCliToolReference elements.

Abilita archiviazione segretaEnable secret storage

Lo strumento Gestione Secret funziona sulle impostazioni di configurazione specifiche del progetto archiviate nel profilo utente.The Secret Manager tool operates on project-specific configuration settings stored in your user profile.

Lo strumento di gestione dei segreti init include un comando in .NET Core SDK 3.0.100 o versione successiva.The Secret Manager tool includes an init command in .NET Core SDK 3.0.100 or later. Per usare i segreti utente, eseguire il comando seguente nella directory del progetto:To use user secrets, run the following command in the project directory:

dotnet user-secrets init

Il comando precedente aggiunge un UserSecretsId elemento all'interno PropertyGroup di un del file con estensione csproj .The preceding command adds a UserSecretsId element within a PropertyGroup of the .csproj file. Per impostazione predefinita, il testo interno UserSecretsId di è un GUID.By default, the inner text of UserSecretsId is a GUID. Il testo interno è arbitrario, ma è univoco per il progetto.The inner text is arbitrary, but is unique to the project.

Per usare i segreti utente, definire UserSecretsId un elemento in PropertyGroup un del file con estensione csproj .To use user secrets, define a UserSecretsId element within a PropertyGroup of the .csproj file. Il testo interno di UserSecretsId è arbitrario, ma è univoco per il progetto.The inner text of UserSecretsId is arbitrary, but is unique to the project. Gli sviluppatori generano in genere un UserSecretsIdGUID per il.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>

Suggerimento

In Visual Studio fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere Gestisci segreti utente dal menu di scelta rapida.In Visual Studio, right-click the project in Solution Explorer, and select Manage User Secrets from the context menu. Questo movimento aggiunge un UserSecretsId elemento, popolato con un GUID, al file con estensione csproj .This gesture adds a UserSecretsId element, populated with a GUID, to the .csproj file.

Imposta un segretoSet a secret

Definire un segreto dell'app costituito da una chiave e dal relativo valore.Define an app secret consisting of a key and its value. Il segreto è associato al UserSecretsId valore del progetto.The secret is associated with the project's UserSecretsId value. Ad esempio, eseguire il comando seguente dalla directory in cui è presente il file con estensione csproj :For example, run the following command from the directory in which the .csproj file exists:

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

Nell'esempio precedente, i due punti indicano che Movies è un valore letterale di oggetto con una ServiceApiKey proprietà.In the preceding example, the colon denotes that Movies is an object literal with a ServiceApiKey property.

Lo strumento Gestione Secret può essere usato anche da altre directory.The Secret Manager tool can be used from other directories too. Utilizzare l' --project opzione per specificare il percorso di file System in cui è presente il file con estensione csproj .Use the --project option to supply the file system path at which the .csproj file exists. Ad esempio:For example:

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

Flat Structure JSON in Visual StudioJSON structure flattening in Visual Studio

Il gesto di gestione dei segreti utente di Visual Studio apre un file Secrets. JSON nell'editor di testo.Visual Studio's Manage User Secrets gesture opens a secrets.json file in the text editor. Sostituire il contenuto di Secrets. JSON con le coppie chiave-valore da archiviare.Replace the contents of secrets.json with the key-value pairs to be stored. Ad esempio:For example:

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

La struttura JSON è bidimensionale dopo le modifiche dotnet user-secrets remove tramite dotnet user-secrets seto.The JSON structure is flattened after modifications via dotnet user-secrets remove or dotnet user-secrets set. Ad esempio, l' dotnet user-secrets remove "Movies:ConnectionString" esecuzione comprime il Movies valore letterale dell'oggetto.For example, running dotnet user-secrets remove "Movies:ConnectionString" collapses the Movies object literal. Il file modificato è simile al seguente:The modified file resembles the following:

{
  "Movies:ServiceApiKey": "12345"
}

Impostare più segretiSet multiple secrets

È possibile impostare un batch di segreti inviando tramite pipe JSON set al comando.A batch of secrets can be set by piping JSON to the set command. Nell'esempio seguente il contenuto del file input. JSON viene inviato tramite pipe al set comando.In the following example, the input.json file's contents are piped to the set command.

Aprire una shell dei comandi ed eseguire il comando seguente:Open a command shell, and execute the following command:

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

Accedere a un segretoAccess a secret

L' API di configurazione ASP.NET Core fornisce l'accesso ai segreti di gestione segreti.The ASP.NET Core Configuration API provides access to Secret Manager secrets.

Se il progetto è destinato .NET Framework, installare il pacchetto NuGet Microsoft. Extensions. Configuration. UserSecrets .If your project targets .NET Framework, install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

In ASP.NET Core 2,0 o versioni successive, l'origine configurazione dei segreti utente viene aggiunta automaticamente in modalità di sviluppo quando CreateDefaultBuilder il progetto chiama per inizializzare una nuova istanza dell'host con impostazioni predefinite preconfigurate.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. CreateDefaultBuilderchiama AddUserSecrets quandoEnvironmentName è :DevelopmentCreateDefaultBuilder calls AddUserSecrets when the EnvironmentName is Development:

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

Quando CreateDefaultBuilder non viene chiamato, aggiungere l'origine di configurazione dei segreti utente in AddUserSecrets modo esplicito chiamando nel Startup costruttore.When CreateDefaultBuilder isn't called, add the user secrets configuration source explicitly by calling AddUserSecrets in the Startup constructor. Chiamare AddUserSecrets solo quando l'app è in esecuzione nell'ambiente di sviluppo, come illustrato nell'esempio seguente: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();
}

Installare il pacchetto NuGet Microsoft. Extensions. Configuration. UserSecrets .Install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

Aggiungere l'origine di configurazione dei segreti utente con una AddUserSecrets chiamata a Startup nel costruttore: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();
}

I segreti utente possono essere recuperati Configuration tramite l'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}");
        });
    }
}

Mappare i segreti a un POCOMap secrets to a POCO

Il mapping di un intero valore letterale di oggetto a un oggetto POCO (una classe .NET semplice con proprietà) è utile per l'aggregazione di proprietà correlate.Mapping an entire object literal to a POCO (a simple .NET class with properties) is useful for aggregating related properties.

Si supponga dell'app Secrets file contiene i seguenti due segreti: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"
  }
}

Per eseguire il mapping dei segreti precedenti a un poco, Configuration usare la funzionalità di associazione dell'oggetto grafico dell'API.To map the preceding secrets to a POCO, use the Configuration API's object graph binding feature. Il codice seguente è associato a un oggetto MovieSettings poco personalizzato e accede al ServiceApiKey valore della proprietà: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;

I Movies:ConnectionString segreti Movies:ServiceApiKey e vengono mappati alle rispettive proprietà MovieSettingsin: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; }
}

Sostituzione di stringhe con segretiString replacement with secrets

L'archiviazione delle password in testo normale non è protetta.Storing passwords in plain text is insecure. Ad esempio, una stringa di connessione del database archiviata in appSettings. JSON può includere una password per l'utente specificato: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"
  }
}

Un approccio più sicuro consiste nell'archiviare la password come segreto.A more secure approach is to store the password as a secret. Ad esempio:For example:

dotnet user-secrets set "DbPassword" "pass123"

Rimuovere la Password coppia chiave-valore dalla stringa di connessione in appSettings. JSON.Remove the Password key-value pair from the connection string in appsettings.json. Ad esempio:For example:

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

Il valore del segreto può essere impostato sulla SqlConnectionStringBuilder Password proprietà di un oggetto per completare la stringa di connessione: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}");
        });
    }
}

Elenca i segretiList the secrets

Si supponga dell'app Secrets file contiene i seguenti due segreti: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"
  }
}

Eseguire il comando seguente dalla directory in cui è presente il file con estensione csproj :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets list

Viene visualizzato l'output seguente:The following output appears:

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

Nell'esempio precedente, i due punti nei nomi delle chiavi indicano la gerarchia di oggetti all'interno di Secrets. JSON.In the preceding example, a colon in the key names denotes the object hierarchy within secrets.json.

Rimuovere un singolo segretoRemove a single secret

Si supponga dell'app Secrets file contiene i seguenti due segreti: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"
  }
}

Eseguire il comando seguente dalla directory in cui è presente il file con estensione csproj :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets remove "Movies:ConnectionString"

Il file Secrets. JSON dell'app è stato modificato per rimuovere la coppia chiave-valore associata MoviesConnectionString alla chiave:The app's secrets.json file was modified to remove the key-value pair associated with the MoviesConnectionString key:

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

In dotnet user-secrets list esecuzione viene visualizzato il messaggio seguente:Running dotnet user-secrets list displays the following message:

Movies:ServiceApiKey = 12345

Rimuovi tutti i segretiRemove all secrets

Si supponga dell'app Secrets file contiene i seguenti due segreti: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"
  }
}

Eseguire il comando seguente dalla directory in cui è presente il file con estensione csproj :Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets clear

Tutti i segreti utente per l'app sono stati eliminati dal file Secrets. JSON :All user secrets for the app have been deleted from the secrets.json file:

{}

In dotnet user-secrets list esecuzione viene visualizzato il messaggio seguente:Running dotnet user-secrets list displays the following message:

No secrets configured for this application.

Risorse aggiuntiveAdditional resources