Sichere Speicherung von app-Geheimnissen bei der Entwicklung in ASP.NET CoreSafe storage of app secrets in development in ASP.NET Core

Durch Rick Anderson, Daniel Roth, und Scott AddieBy Rick Anderson, Daniel Roth, and Scott Addie

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)View or download sample code (how to download)

Dieses Dokument erläutert die Verfahren zum Speichern und Abrufen von sensiblen Daten während der Entwicklung von ASP.NET Core-Apps.This document explains techniques for storing and retrieving sensitive data during the development of an ASP.NET Core app. Speichern Sie niemals Kennwörter oder andere sensiblen Daten im Quellcode.Never store passwords or other sensitive data in source code. Produktionsgeheimnisse sollten nicht verwendet werden zu Entwicklungs- oder Testzwecken.Production secrets shouldn't be used for development or test. Sie können Azure-Test- und -Produktionsgeheimnisse mit dem Konfigurationsanbieter Azure Key Vault speichern und schützen.You can store and protect Azure test and production secrets with the Azure Key Vault configuration provider.

UmgebungsvariablenEnvironment variables

Umgebungsvariablen werden zum Speichern von app-Geheimnisse in Code oder in lokalen Konfigurationsdateien zu vermeiden.Environment variables are used to avoid storage of app secrets in code or in local configuration files. Umgebungsvariablen Überschreiben von Konfigurationswerten für alle zuvor angegebenen Konfigurationsquellen.Environment variables override configuration values for all previously specified configuration sources.

Konfigurieren Sie das Lesen der Werte von Umgebungsvariablen, durch den Aufruf AddEnvironmentVariables in die Startup Konstruktor: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();
}

Erwägen Sie eine ASP.NET Core-Web-app in der einzelne Benutzerkonten Sicherheit ist aktiviert.Consider an ASP.NET Core web app in which Individual User Accounts security is enabled. Ist eine standardmäßige Datenbank-Verbindungszeichenfolge des Projekts enthalten "appSettings.JSON" Datei mit dem Schlüssel DefaultConnection.A default database connection string is included in the project's appsettings.json file with the key DefaultConnection. Die Standardverbindungszeichenfolge ist für LocalDB, im Benutzermodus ausgeführt wird und ein Kennwort erfordert.The default connection string is for LocalDB, which runs in user mode and doesn't require a password. Während der Bereitstellung von Apps die DefaultConnection Schlüssel-Wert kann überschrieben werden, mit dem Wert für eine Umgebungsvariable.During app deployment, the DefaultConnection key value can be overridden with an environment variable's value. Die Umgebungsvariable kann die vollständige Verbindungszeichenfolge mit vertraulichen Anmeldeinformationen zu speichern.The environment variable may store the complete connection string with sensitive credentials.

Warnung

Umgebungsvariablen werden in der Regel in einfachen, unverschlüsselten Text gespeichert.Environment variables are generally stored in plain, unencrypted text. Wenn der Computer oder Prozess gefährdet ist, können die Umgebungsvariablen von nicht vertrauenswürdigen Parteien zugegriffen werden.If the machine or process is compromised, environment variables can be accessed by untrusted parties. Zusätzliche Maßnahmen zum Verhindern der Offenlegung von geheimen Benutzerschlüssel können erforderlich sein.Additional measures to prevent disclosure of user secrets may be required.

Beim Verwenden hierarchischer Schlüssel in Umgebungsvariablen funktioniert ein Doppelpunkt (:) als Trennzeichen ggf. nicht auf allen Plattformen (z. B. Bash).When working with hierarchical keys in environment variables, a colon separator (:) may not work on all platforms (for example, Bash). Ein doppelter Unterstrich (__) wird auf allen Plattformen unterstützt und automatisch durch einen Doppelpunkt ersetzt.A double underscore (__) is supported by all platforms and is automatically replaced by a colon.

Geheimnis-ManagerSecret Manager

Secret Manager-Tool werden sensible Daten gespeichert, während der Entwicklung von einem ASP.NET Core-Projekt.The Secret Manager tool stores sensitive data during the development of an ASP.NET Core project. In diesem Kontext ist ein Stück von sensiblen Daten ein app-Geheimnis an.In this context, a piece of sensitive data is an app secret. App-Geheimnisse werden in einem gesonderten Speicherort aus der Projektstruktur gespeichert.App secrets are stored in a separate location from the project tree. Die app-Geheimnisse sind einem bestimmten Projekt zugeordnet oder für mehrere Projekte freigegeben.The app secrets are associated with a specific project or shared across several projects. Die app-Geheimnisse sind nicht in quellcodeverwaltung eingecheckt.The app secrets aren't checked into source control.

Warnung

Secret Manager-Tool nicht zum Verschlüsseln der vertraulichen Daten und sollte nicht als vertrauenswürdiger Speicher behandelt werden.The Secret Manager tool doesn't encrypt the stored secrets and shouldn't be treated as a trusted store. Es ist nur zu Entwicklungszwecken.It's for development purposes only. Die Schlüssel und Werte werden in einer JSON-Konfigurationsdatei im Benutzerprofilverzeichnis gespeichert.The keys and values are stored in a JSON configuration file in the user profile directory.

Wie funktioniert das Secret Manager-toolHow the Secret Manager tool works

Secret Manager-Tool abstrahiert die Implementierungsdetails wie, wo und wie die Werte gespeichert werden.The Secret Manager tool abstracts away the implementation details, such as where and how the values are stored. Sie können das Tool verwenden, ohne zu wissen, diese Implementierungsdetails.You can use the tool without knowing these implementation details. Die Werte werden in einer JSON-Konfigurationsdatei in eine System-geschützten Benutzerprofilordner auf dem lokalen Computer gespeichert:The values are stored in a JSON configuration file in a system-protected user profile folder on the local machine:

System-Dateipfad:File system path:

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

Klicken Sie in der vorherigen Dateipfade, ersetzen Sie <user_secrets_id> mit der UserSecretsId Wert in der csproj Datei.In the preceding file paths, replace <user_secrets_id> with the UserSecretsId value specified in the .csproj file.

Schreiben Sie Code, von denen abhängig von der Speicherort oder das Format der Daten gespeichert werden, mit dem Geheimnis-Manager-Tool nicht.Don't write code that depends on the location or format of data saved with the Secret Manager tool. Details dieser Implementierung können sich ändern.These implementation details may change. Z. B. die geheimen Werte werden nicht verschlüsselt, aber konnte nicht in der Zukunft.For example, the secret values aren't encrypted, but could be in the future.

Installieren Sie das Geheimnis-Manager-toolInstall the Secret Manager tool

Secret Manager-Tool ist im Paket mit .NET Core-CLI in .NET Core SDK 2.1.300 oder höher.The Secret Manager tool is bundled with the .NET Core CLI in .NET Core SDK 2.1.300 or later. Für .NET Core SDK-Versionen vor 2.1.300 ist ein Tool-Installationsordner erforderlich.For .NET Core SDK versions before 2.1.300, tool installation is necessary.

Tipp

Führen Sie dotnet --version über eine Befehlsshell, die Anzahl der installierten .NET Core SDK-Version finden Sie unter.Run dotnet --version from a command shell to see the installed .NET Core SDK version number.

Wenn das .NET Core SDK verwendet das Tool enthält, wird eine Warnung angezeigt: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).

Installieren Sie die Microsoft.Extensions.SecretManager.Tools NuGet-Paket in Ihre ASP.NET Core-Projekt.Install the Microsoft.Extensions.SecretManager.Tools NuGet package in your ASP.NET Core project. Zum Beispiel: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>

Führen Sie den folgenden Befehl in einer Befehlsshell zum Überprüfen der Tool-Installationsordner:Execute the following command in a command shell to validate the tool installation:

dotnet user-secrets -h

Secret Manager-Tool zeigt das Beispiel für die Verwendung, Optionen und Hilfe zu dem Befehl: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.

Hinweis

Müssen Sie sich im selben Verzeichnis wie die csproj Datei ist zum Ausführen des Tools, die definiert, der csproj Datei DotNetCliToolReference Elemente.You must be in the same directory as the .csproj file to run tools defined in the .csproj file's DotNetCliToolReference elements.

Aktivieren Sie den geheimen SpeicherEnable secret storage

Secret Manager-Tool wirkt sich auf projektspezifische Konfigurationseinstellungen, die in Ihrem Benutzerprofil gespeichert.The Secret Manager tool operates on project-specific configuration settings stored in your user profile.

Das Geheimnis-Manager-Tool bietet eine init -Befehl in .NET Core SDK 3.0.100 oder höher.The Secret Manager tool includes an init command in .NET Core SDK 3.0.100 or later. Um vertrauliche Informationen eines Benutzers zu verwenden, führen Sie den folgenden Befehl im Verzeichnis Projekts ein:To use user secrets, run the following command in the project directory:

dotnet user-secrets init

Der vorherige Befehl fügt eine UserSecretsId Element innerhalb einer PropertyGroup von der csproj Datei.The preceding command adds a UserSecretsId element within a PropertyGroup of the .csproj file. Standardmäßig wird der innere Text des UserSecretsId ist eine GUID.By default, the inner text of UserSecretsId is a GUID. Der innere Text ist beliebig, aber es ist nur für das Projekt.The inner text is arbitrary, but is unique to the project.

Um vertrauliche Informationen eines Benutzers zu verwenden, definieren eine UserSecretsId Element innerhalb einer PropertyGroup von der csproj Datei.To use user secrets, define a UserSecretsId element within a PropertyGroup of the .csproj file. Der innere Text des UserSecretsId ist beliebig, aber in dem Projekt eindeutig ist.The inner text of UserSecretsId is arbitrary, but is unique to the project. Entwickler in der Regel generiert eine GUID für die 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>

Tipp

Klicken Sie in Visual Studio mit der rechten Maustaste in des Projekts im Projektmappen-Explorer, und wählen geheime Benutzerschlüssel verwalten aus dem Kontextmenü.In Visual Studio, right-click the project in Solution Explorer, and select Manage User Secrets from the context menu. Diese stiftbewegung Fügt eine UserSecretsId Elements aufgefüllt durch eine GUID, zu der csproj Datei.This gesture adds a UserSecretsId element, populated with a GUID, to the .csproj file.

Legen Sie einen geheimen SchlüsselSet a secret

Definieren Sie ein app-Geheimnis, bestehend aus einem Schlüssel und seinen Wert an.Define an app secret consisting of a key and its value. Der geheime Schlüssel des Projekts zugeordnet ist UserSecretsId Wert.The secret is associated with the project's UserSecretsId value. Führen Sie beispielsweise den folgenden Befehl aus dem Verzeichnis, in dem die csproj Datei vorhanden ist:For example, run the following command from the directory in which the .csproj file exists:

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

Im vorherigen Beispiel ist der Doppelpunkt bedeutet, dass Movies ist ein Objekt als literal mit einem ServiceApiKey Eigenschaft.In the preceding example, the colon denotes that Movies is an object literal with a ServiceApiKey property.

Secret Manager-Tool kann auch aus anderen Verzeichnissen verwendet werden.The Secret Manager tool can be used from other directories too. Verwenden der --project Option aus, um den Dateisystempfad an dem Angeben der csproj Datei vorhanden ist.Use the --project option to supply the file system path at which the .csproj file exists. Zum Beispiel:For example:

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

JSON-Struktur, die in Visual Studio vereinfachenJSON structure flattening in Visual Studio

Visual Studio geheime Benutzerschlüssel verwalten Geste öffnet eine secrets.json Datei im Text-Editor.Visual Studio's Manage User Secrets gesture opens a secrets.json file in the text editor. Ersetzen Sie den Inhalt der secrets.json mit Schlüssel-Wert-Paare gespeichert werden.Replace the contents of secrets.json with the key-value pairs to be stored. Zum Beispiel:For example:

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

Die JSON-Struktur wird nach Änderungen über vereinfacht dotnet user-secrets remove oder dotnet user-secrets set.The JSON structure is flattened after modifications via dotnet user-secrets remove or dotnet user-secrets set. Z. B. Ausführung dotnet user-secrets remove "Movies:ConnectionString" reduziert die Movies Objektliteral.For example, running dotnet user-secrets remove "Movies:ConnectionString" collapses the Movies object literal. Die geänderte Datei ähnelt der folgenden:The modified file resembles the following:

{
  "Movies:ServiceApiKey": "12345"
}

Legen Sie mehrere geheime SchlüsselSet multiple secrets

Ein Batch von geheimen Schlüsseln kann festgelegt werden, durch das Weiterleiten von JSON-Code für die set Befehl.A batch of secrets can be set by piping JSON to the set command. Im folgenden Beispiel die "Input.JSON" Dateiinhalt sind über die Pipeline an das set Befehl.In the following example, the input.json file's contents are piped to the set command.

Öffnen Sie eine Befehlsshell, und führen Sie den folgenden Befehl:Open a command shell, and execute the following command:

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

Zugriff auf einen geheimen SchlüsselAccess a secret

Die ASP.NET Core-Konfigurations-API ermöglicht den Zugriff auf Secret Manager Geheimnisse.The ASP.NET Core Configuration API provides access to Secret Manager secrets.

Wenn das Projekt .NET Framework verwendet, installieren Sie die Microsoft.Extensions.Configuration.UserSecrets NuGet-Paket.If your project targets .NET Framework, install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

In ASP.NET Core 2.0 oder höher, die Benutzer Geheimnisse Konfigurationsquelle wird automatisch hinzugefügt im Entwicklungsmodus Wenn, das Projekt aufruft CreateDefaultBuilder eine neue Instanz des Hosts mit vorkonfigurierten Standardwerten initialisiert werden.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 Aufrufe AddUserSecrets bei der EnvironmentName ist Development:CreateDefaultBuilder calls AddUserSecrets when the EnvironmentName is Development:

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

Wenn CreateDefaultBuilder wird nicht aufgerufen wird, hinzufügen die Konfigurationsquelle für Benutzer Geheimnisse explizit durch den Aufruf AddUserSecrets in die Startup Konstruktor.When CreateDefaultBuilder isn't called, add the user secrets configuration source explicitly by calling AddUserSecrets in the Startup constructor. Rufen Sie AddUserSecrets nur wenn die app in der Entwicklungsumgebung ausgeführt wird wie im folgenden Beispiel gezeigt: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();
}

Installieren Sie die Microsoft.Extensions.Configuration.UserSecrets NuGet-Paket.Install the Microsoft.Extensions.Configuration.UserSecrets NuGet package.

Hinzufügen die Konfigurationsquelle für Benutzer geheime Schlüssel mit einem Aufruf von AddUserSecrets in die Startup Konstruktor: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();
}

Vertrauliche Informationen eines Benutzers abgerufen werden können, über die 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}");
        });
    }
}

Map-Geheimtipps für die ein POCO-ObjektMap secrets to a POCO

Zuordnen eines kompletten Objekts literal, ein POCO-Objekt (eine einfache .NET Klasse mit Eigenschaften) eignet sich für das Aggregieren von verwandten Eigenschaften.Mapping an entire object literal to a POCO (a simple .NET class with properties) is useful for aggregating related properties.

Angenommen der app secrets.json -Datei enthält die folgenden zwei Geheimnisse: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"
  }
}

Verwenden, um die vorherigen geheimen Schlüssel ein POCO-Objekt zugeordnet sind, die Configuration APIs Objekt Graph Bindung Feature.To map the preceding secrets to a POCO, use the Configuration API's object graph binding feature. Der folgende Code bindet an einen benutzerdefinierten MovieSettings POCO und greift auf die ServiceApiKey Eigenschaftswert: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;

Die Movies:ConnectionString und Movies:ServiceApiKey geheime Schlüssel werden in den entsprechenden Eigenschaften im zugeordnet 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; }
}

Zeichenfolgenersetzungen mit geheimen SchlüsselnString replacement with secrets

Speichern von Kennwörtern als nur-Text ist unsicher.Storing passwords in plain text is insecure. Z. B. eine Datenbankverbindungszeichenfolge, die in gespeicherten "appSettings.JSON" kann ein Kennwort für den angegebenen Benutzer enthalten: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"
  }
}

Ein sicherer Ansatz ist das Kennwort als Geheimnis gespeichert.A more secure approach is to store the password as a secret. Zum Beispiel:For example:

dotnet user-secrets set "DbPassword" "pass123"

Entfernen Sie die Password Schlüssel / Wert-Paar aus der Verbindungszeichenfolge in "appSettings.JSON".Remove the Password key-value pair from the connection string in appsettings.json. Zum Beispiel:For example:

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

Der geheime Schlüssel Wert kann festgelegt werden, auf eine SqlConnectionStringBuilder des Objekts Password Eigenschaft, um die Verbindungszeichenfolge abgeschlossen: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}");
        });
    }
}

Auflisten der Geheimnisse.List the secrets

Angenommen der app secrets.json -Datei enthält die folgenden zwei Geheimnisse: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"
  }
}

Führen den folgenden Befehl aus dem Verzeichnis, in dem die csproj Datei vorhanden ist:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets list

Die folgende Ausgabe wird angezeigt:The following output appears:

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

Im vorherigen Beispiel, bezeichnet ein Doppelpunkt in den Schlüsselnamen die Objekthierarchie in secrets.json.In the preceding example, a colon in the key names denotes the object hierarchy within secrets.json.

Entfernen Sie einen einzelnen geheimen SchlüsselRemove a single secret

Angenommen der app secrets.json -Datei enthält die folgenden zwei Geheimnisse: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"
  }
}

Führen den folgenden Befehl aus dem Verzeichnis, in dem die csproj Datei vorhanden ist:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets remove "Movies:ConnectionString"

Der app secrets.json Datei wurde geändert, um das zugeordnete Schlüssel-Wert-Paar Entfernen der MoviesConnectionString Schlüssel:The app's secrets.json file was modified to remove the key-value pair associated with the MoviesConnectionString key:

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

Ausführung dotnet user-secrets list wird die folgende Meldung angezeigt:Running dotnet user-secrets list displays the following message:

Movies:ServiceApiKey = 12345

Entfernen Sie alle GeheimnisseRemove all secrets

Angenommen der app secrets.json -Datei enthält die folgenden zwei Geheimnisse: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"
  }
}

Führen den folgenden Befehl aus dem Verzeichnis, in dem die csproj Datei vorhanden ist:Run the following command from the directory in which the .csproj file exists:

dotnet user-secrets clear

Alle benutzergeheimnisse für die app aus gelöscht wurden die secrets.json Datei:All user secrets for the app have been deleted from the secrets.json file:

{}

Ausführung dotnet user-secrets list wird die folgende Meldung angezeigt:Running dotnet user-secrets list displays the following message:

No secrets configured for this application.

Zusätzliche RessourcenAdditional resources