Provider di configurazione di Azure Key Vault in ASP.NET Core

Questo articolo illustra come usare il provider di configurazione di Azure Key Vault per caricare i valori di configurazione delle app dai segreti di Azure Key Vault. Azure Key Vault è un servizio basato sul cloud che consente di proteggere le chiavi crittografiche e i segreti usati da app e servizi. Gli scenari comuni per l'uso di Azure Key Vault con app ASP.NET Core includono:

• Controllo dell'accesso ai dati di configurazione sensibili.
• Soddisfare i requisiti per i moduli di protezione hardware convalidati FIPS 140-2 livello 2 durante l'archiviazione dei dati di configurazione.

Pacchetti

Aggiungere riferimenti al pacchetto per i pacchetti seguenti:

• Azure.Extensions.AspNetCore.Configuration.Secrets
• AzureIdentity.

Esempio di app

L'app di esempio viene eseguita in una delle due modalità determinate dalla direttiva del #define preprocessore all'inizio di Program.cs:

• Certificate: illustra l'uso di un ID client di Azure Key Vault e di un certificato X.509 per accedere ai segreti archiviati in Azure Key Vault. Questo esempio può essere eseguito da qualsiasi posizione, indipendentemente dal fatto che sia distribuito in app Azure Servizio o qualsiasi host in grado di gestire un'app ASP.NET Core.
• Managed: illustra come usare le identità gestite per le risorse di Azure. L'app gestita autentica l'app in Azure Key Vault con identità gestite identity per le risorse di Azure senza archiviare le credenziali nel codice o nella configurazione dell'app. La Managed versione dell'esempio deve essere distribuita in Azure. Seguire le indicazioni nella sezione Usare le identità gestite per le risorse di Azure.

Per altre informazioni sulla configurazione di un'app di esempio tramite direttive del preprocessore (#define), vedere Panoramica di ASP.NET Core.

Visualizzare o scaricare il codice di esempio (procedura per il download)

Archiviazione segreta nell'ambiente di sviluppo

Impostare i segreti in locale usando Secret Manager. Quando l'app di esempio viene eseguita nel computer locale nell'ambiente di sviluppo, i segreti vengono caricati dall'archivio segreti utente locale.

Secret Manager richiede una <UserSecretsId> proprietà nel file di progetto dell'app. Impostare il valore della proprietà ({GUID}) su qualsiasi GUID univoco:

<PropertyGroup>
  <UserSecretsId>{GUID}</UserSecretsId>
</PropertyGroup>

I segreti vengono creati come coppie nome-valore. I valori gerarchici (sezioni di configurazione) usano un : (due punti) come separatore nei nomi delle chiavi di configurazione di ASP.NET core.

Secret Manager viene usato da una shell dei comandi aperta alla radice del contenuto del progetto, dove {SECRET NAME} è il nome e {SECRET VALUE} è il valore:

dotnet user-secrets set "{SECRET NAME}" "{SECRET VALUE}"

Eseguire i comandi seguenti in una shell dei comandi dalla radice del contenuto del progetto per impostare i segreti per l'app di esempio:

dotnet user-secrets set "SecretName" "secret_value_1_dev"
dotnet user-secrets set "Section:SecretName" "secret_value_2_dev"

Quando questi segreti vengono archiviati in Azure Key Vault nell'archivio segreto nell'ambiente di produzione con Azure Key Vault , il _dev suffisso viene modificato in _prod. Il suffisso fornisce un segnale visivo nell'output dell'app che indica l'origine dei valori di configurazione.

Archiviazione segreta nell'ambiente di produzione con Azure Key Vault

Completare i passaggi seguenti per creare un insieme di credenziali delle chiavi di Azure e archiviare i segreti dell'app di esempio. Per altre informazioni, vedere Avvio rapido: Impostare e recuperare un segreto da Azure Key Vault usando l'interfaccia della riga di comando di Azure.

1. Aprire Azure Cloud Shell usando uno dei metodi seguenti nella portale di Azure:

   • Selezionare Prova nell'angolo superiore destro di un blocco di codice. Usare la stringa di ricerca "Interfaccia della riga di comando di Azure" nella casella di testo.
   • Aprire Cloud Shell nel browser con il pulsante Avvia Cloud Shell .
   • Selezionare il pulsante Cloud Shell nel menu nell'angolo in alto a destra del portale di Azure.

   Per altre informazioni, vedere Interfaccia della riga di comando di Azure e Panoramica di Azure Cloud Shell.

2. Se non si è già autenticati, accedere con il az login comando .

3. Creare un gruppo di risorse con il comando seguente, dove {RESOURCE GROUP NAME} è il nome del nuovo gruppo di risorse ed {LOCATION} è l'area di Azure:

   az group create --name "{RESOURCE GROUP NAME}" --location {LOCATION}
   

4. Creare un insieme di credenziali delle chiavi nel gruppo di risorse con il comando seguente, dove {KEY VAULT NAME} è il nome del nuovo insieme di credenziali e {LOCATION} è l'area di Azure:

   az keyvault create --name {KEY VAULT NAME} --resource-group "{RESOURCE GROUP NAME}" --location {LOCATION}
   

5. Creare segreti nell'insieme di credenziali come coppie nome-valore.

   I nomi dei segreti di Azure Key Vault sono limitati a caratteri alfanumerici e trattini. I valori gerarchici (sezioni di configurazione) usano -- (due trattini) come delimitatore, perché i due punti non sono consentiti nei nomi dei segreti di Key Vault. I due punti delimitano una sezione da una sottochiave nella configurazione di ASP.NET Core. La sequenza a due trattini viene sostituita da due punti quando i segreti vengono caricati nella configurazione dell'app.

   I segreti seguenti sono destinati all'uso con l'app di esempio. I valori includono un _prod suffisso per distinguerli dai valori del _dev suffisso caricati nell'ambiente di sviluppo da Secret Manager. Sostituire {KEY VAULT NAME} con il nome dell'insieme di credenziali delle chiavi creato nel passaggio precedente:

   az keyvault secret set --vault-name {KEY VAULT NAME} --name "SecretName" --value "secret_value_1_prod"
   az keyvault secret set --vault-name {KEY VAULT NAME} --name "Section--SecretName" --value "secret_value_2_prod"
   

Usare l'ID applicazione e il certificato X.509 per le app non ospitate in Azure

Configurare Azure Key Vault e l'app per usare un ID applicazione Microsoft Entra ID e un certificato X.509 per l'autenticazione in un insieme di credenziali quando l'app è ospitata all'esterno di Azure. Per i dettagli, vedere l'articolo relativo alle informazioni su chiavi, segreti e certificati.

Nota

Anche se l'uso di un ID applicazione e di un certificato X.509 è supportato per le app ospitate in Azure, non è consigliabile. Usare invece identità gestite per le risorse di Azure quando si ospita un'app in Azure. Le identità gestite non richiedono l'archiviazione di un certificato nell'app o nell'ambiente di sviluppo.

L'app di esempio usa un ID applicazione e un certificato X.509 quando la #define direttiva del preprocessore nella parte superiore di Program.cs è impostata Certificatesu .

1. Creare un certificato di archivio PKCS#12 (pfx). Le opzioni per la creazione di certificati includono New-SelfSignedCertificate in Windows e OpenSSL.
2. Installare il certificato nell'archivio certificati personale dell'utente corrente. Contrassegnare la chiave come esportabile è facoltativa. Si noti l'identificazione personale del certificato, che verrà usata più avanti in questo processo.
3. Esportare il certificato di archivio PKCS#12 (pfx) come certificato con codifica DER (.cer).
4. Registrare l'app con Microsoft Entra ID (Registrazioni app).
5. Caricare il certificato con codifica DER (.cer) in Microsoft Entra ID:
   1. Selezionare l'app in Microsoft Entra ID.
   2. Passare a Certificati e segreti.
   3. Selezionare Carica certificato per caricare il certificato, che contiene la chiave pubblica. Un certificato .cer, pem o crt è accettabile.
6. Archiviare il nome dell'insieme di credenziali delle chiavi, l'ID applicazione e l'identificazione personale del certificato nel file dell'app appsettings.json .
7. Passare a Insiemi di credenziali delle chiavi nella portale di Azure.
8. Selezionare l'insieme di credenziali delle chiavi creato nella sezione Archiviazione privata nell'ambiente di produzione con Azure Key Vault .
9. Seleziona Criteri di accesso.
10. Seleziona Aggiungi criteri di accesso.
11. Aprire le autorizzazioni Secret e fornire all'app le autorizzazioni Get e List .
12. Selezionare Seleziona entità e selezionare l'app registrata in base al nome. Fare clic sul pulsante Seleziona.
13. Seleziona OK.
14. Seleziona Salva.
15. Distribuire l'app.

L'app Certificate di esempio ottiene i valori di configurazione da IConfigurationRoot con lo stesso nome del segreto:

• Valori non gerarchici: il valore per SecretName viene ottenuto con config["SecretName"].
• Valori gerarchici (sezioni): usare : la notazione (due punti) o il GetSection metodo . Usare uno di questi approcci per ottenere il valore di configurazione:
  • config["Section:SecretName"]
  • config.GetSection("Section")["SecretName"]

Il certificato X.509 viene gestito dal sistema operativo. L'app chiama AddAzureKeyVault con i valori forniti dal appsettings.json file:

using System.Security.Cryptography.X509Certificates;
using Azure.Identity;

var builder = WebApplication.CreateBuilder(args);

if (builder.Environment.IsProduction())
{
    using var x509Store = new X509Store(StoreLocation.CurrentUser);

    x509Store.Open(OpenFlags.ReadOnly);

    var x509Certificate = x509Store.Certificates
        .Find(
            X509FindType.FindByThumbprint,
            builder.Configuration["AzureADCertThumbprint"],
            validOnly: false)
        .OfType<X509Certificate2>()
        .Single();

    builder.Configuration.AddAzureKeyVault(
        new Uri($"https://{builder.Configuration["KeyVaultName"]}.vault.azure.net/"),
        new ClientCertificateCredential(
            builder.Configuration["AzureADDirectoryId"],
            builder.Configuration["AzureADApplicationId"],
            x509Certificate));
}

var app = builder.Build();

Valori di esempio

• Nome dell'insieme di credenziali delle chiavi: contosovault
• ID applicazione: 00001111-aaaa-2222-bbbb-3333cccc4444
• Identificazione personale del certificato: fe14593dd66b2406c5269d742d04b6e1ab03adb1

appsettings.json:

{
  "KeyVaultName": "Key Vault Name",
  "AzureADApplicationId": "Azure AD Application ID",
  "AzureADCertThumbprint": "Azure AD Certificate Thumbprint",
  "AzureADDirectoryId": "Azure AD Directory ID"
}

Quando si esegue l'app, una pagina Web mostra i valori dei segreti caricati. Nell'ambiente di sviluppo i valori dei segreti vengono caricati con il _dev suffisso . Nell'ambiente di produzione i valori vengono caricati con il _prod suffisso .

Usare identità gestite per le risorse di Azure

Un'app distribuita in Azure può sfruttare le identità gestite per le risorse di Azure. Un'istanza gestita identity consente all'app di eseguire l'autenticazione con Azure Key Vault usando l'autenticazione con l'ID Entra di Microsoft senza archiviare le credenziali nel codice o nella configurazione dell'app.

L'app di esempio usa una gestione identity assegnata dal sistema quando la #define direttiva del preprocessore all'inizio di Program.cs è impostata su Managed. Per creare un'app del servizio app Azure gestitaidentity, vedere Come usare le identità gestite per servizio app e Funzioni di Azure. Dopo aver creato l'oggetto gestitoidentity, prendere nota dell'ID oggetto dell'app visualizzato nella portale di Azure nel Identity pannello del servizio app.

Immettere il nome dell'insieme di credenziali nel file dell'app appsettings.json . L'app di esempio non richiede un ID applicazione e una password (segreto client) quando è impostata sulla Managed versione, quindi è possibile ignorare tali voci di configurazione. L'app viene distribuita in Azure e Azure autentica l'app per accedere ad Azure Key Vault solo usando il nome dell'insieme di credenziali archiviato nel appsettings.json file.

Distribuire l'app di esempio nel servizio app Azure.

Usando l'interfaccia della riga di comando di Azure e l'ID oggetto dell'app, fornire all'app list le autorizzazioni e get per accedere all'insieme di credenziali:

az keyvault set-policy --name {KEY VAULT NAME} --object-id {OBJECT ID} --secret-permissions get list

Riavviare l'app usando l'interfaccia della riga di comando di Azure, PowerShell o il portale di Azure.

L'app di esempio crea un'istanza della DefaultAzureCredential classe . Le credenziali tentano di ottenere un token di accesso dall'ambiente per le risorse di Azure:

using Azure.Identity;

var builder = WebApplication.CreateBuilder(args);

if (builder.Environment.IsProduction())
{
    builder.Configuration.AddAzureKeyVault(
        new Uri($"https://{builder.Configuration["KeyVaultName"]}.vault.azure.net/"),
        new DefaultAzureCredential());
}

Valore di esempio del nome dell'insieme di credenziali delle chiavi: contosovault

appsettings.json:

{
  "KeyVaultName": "Key Vault Name"
}

Per le app che usano un account gestito identityassegnato dall'utente, configurare l'ID client gestito identityusando uno degli approcci seguenti:

1. Impostare la variabile di ambiente AZURE_CLIENT_ID.

2. Impostare la DefaultAzureCredentialOptions.ManagedIdentityClientId proprietà quando si chiama AddAzureKeyVault:

   builder.Configuration.AddAzureKeyVault(
       new Uri($"https://{builder.Configuration["KeyVaultName"]}.vault.azure.net/"),
       new DefaultAzureCredential(new DefaultAzureCredentialOptions
       {
           ManagedIdentityClientId = builder.Configuration["AzureADManagedIdentityClientId"]
       }));
   

Quando si esegue l'app, una pagina Web mostra i valori dei segreti caricati. Nell'ambiente di sviluppo i valori dei segreti hanno il _dev suffisso perché vengono forniti da Secret Manager. Nell'ambiente di produzione i valori vengono caricati con il _prod suffisso perché vengono forniti da Azure Key Vault.

Se viene visualizzato un Access denied errore, verificare che l'app sia registrata con l'ID Microsoft Entra e che sia stato fornito l'accesso all'insieme di credenziali. Verificare di aver riavviato il servizio in Azure.

Per informazioni sull'uso del provider con un servizio gestito identity e Azure Pipelines, vedere Creare una connessione al servizio Azure Resource Manager a una macchina virtuale con un servizio identitygestito.

Opzioni di configurazione

AddAzureKeyVault può accettare un AzureKeyVaultConfigurationOptions oggetto:

// using Azure.Extensions.AspNetCore.Configuration.Secrets;

builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{builder.Configuration["KeyVaultName"]}.vault.azure.net/"),
    new DefaultAzureCredential(),
    new AzureKeyVaultConfigurationOptions
    {
        // ...
    });

L'oggetto AzureKeyVaultConfigurationOptions contiene le proprietà seguenti:

Proprietà	Descrizione
Manager	KeyVaultSecretManager istanza utilizzata per controllare il caricamento dei segreti.
ReloadInterval	TimeSpan attendere tra i tentativi di polling dell'insieme di credenziali per le modifiche. Il valore predefinito è null (la configurazione non viene ricaricata).

Usare un prefisso del nome della chiave

AddAzureKeyVault fornisce un overload che accetta un'implementazione di , che consente di controllare il modo in cui i segreti di Key Vault vengono convertiti in chiavi di KeyVaultSecretManagerconfigurazione. Ad esempio, è possibile implementare l'interfaccia per caricare i valori dei segreti in base a un valore di prefisso fornito all'avvio dell'app. Questa tecnica consente, ad esempio, di caricare segreti in base alla versione dell'app.

Avviso

Non usare prefissi nei segreti di Key Vault per:

• Inserire segreti per più app nello stesso insieme di credenziali.
• Inserire segreti ambientali (ad esempio, sviluppo e segreti di produzione ) nello stesso insieme di credenziali.

App e ambienti di sviluppo/produzione diversi devono usare insiemi di credenziali delle chiavi separati per isolare gli ambienti delle app per il massimo livello di sicurezza.

Nell'esempio seguente viene stabilito un segreto in Key Vault (e si usa Secret Manager per l'ambiente di sviluppo) per 5000-AppSecret (i periodi non sono consentiti nei nomi dei segreti di Key Vault). Questo segreto rappresenta un segreto dell'app per la versione 5.0.0.0 dell'app. Per un'altra versione dell'app, 5.1.0.0, viene aggiunto un segreto all'insieme di credenziali (e usando Secret Manager) per 5100-AppSecret. Ogni versione dell'app carica il valore del segreto con versione nella configurazione come AppSecret, rimuovendo la versione durante il caricamento del segreto.

AddAzureKeyVault viene chiamato con un'implementazione personalizzata KeyVaultSecretManager :

// using Azure.Extensions.AspNetCore.Configuration.Secrets;

builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{builder.Configuration["KeyVaultName"]}.vault.azure.net/"),
    new DefaultAzureCredential(),
    new SamplePrefixKeyVaultSecretManager("5000"));

L'implementazione reagisce ai prefissi di versione dei segreti per caricare il segreto appropriato nella configurazione:

• Load carica un segreto quando il nome inizia con il prefisso . Altri segreti non vengono caricati.
• GetKey:
  • Rimuove il prefisso dal nome del segreto.
  • Sostituisce due trattini in qualsiasi nome con , KeyDelimiterche è il delimitatore usato nella configurazione (in genere due punti). Azure Key Vault non consente i due punti nei nomi dei segreti.

public class SamplePrefixKeyVaultSecretManager : KeyVaultSecretManager
{
    private readonly string _prefix;

    public SamplePrefixKeyVaultSecretManager(string prefix)
        => _prefix = $"{prefix}-";

    public override bool Load(SecretProperties properties)
        => properties.Name.StartsWith(_prefix);

    public override string GetKey(KeyVaultSecret secret)
        => secret.Name[_prefix.Length..].Replace("--", ConfigurationPath.KeyDelimiter);
}

Il Load metodo viene chiamato da un algoritmo del provider che scorre i segreti dell'insieme di credenziali per trovare i segreti con prefisso della versione. Quando viene trovato un prefisso di versione con Load, l'algoritmo usa il GetKey metodo per restituire il nome di configurazione del nome del segreto. Rimuove il prefisso della versione dal nome del segreto. Il rest nome del segreto viene restituito per il caricamento nelle coppie nome-valore di configurazione dell'app.

Quando viene implementato questo approccio:

1. Versione dell'app specificata nel file di progetto dell'app. Nell'esempio seguente la versione dell'app è impostata su 5.0.0.0:

   <PropertyGroup>
     <Version>5.0.0.0</Version>
   </PropertyGroup>
   

2. Verificare che una <UserSecretsId> proprietà sia presente nel file di progetto dell'app, dove {GUID} è un GUID fornito dall'utente:

   <PropertyGroup>
     <UserSecretsId>{GUID}</UserSecretsId>
   </PropertyGroup>
   

   Salvare i segreti seguenti in locale con Secret Manager:

   dotnet user-secrets set "5000-AppSecret" "5.0.0.0_secret_value_dev"
   dotnet user-secrets set "5100-AppSecret" "5.1.0.0_secret_value_dev"
   

3. I segreti vengono salvati in Azure Key Vault usando i comandi dell'interfaccia della riga di comando di Azure seguenti:

   az keyvault secret set --vault-name {KEY VAULT NAME} --name "5000-AppSecret" --value "5.0.0.0_secret_value_prod"
   az keyvault secret set --vault-name {KEY VAULT NAME} --name "5100-AppSecret" --value "5.1.0.0_secret_value_prod"
   

4. Quando l'app viene eseguita, vengono caricati i segreti di Key Vault. Il segreto stringa per 5000-AppSecret viene confrontato con la versione dell'app specificata nel file di progetto dell'app (5.0.0.0).

5. La versione, 5000 con il trattino, viene rimossa dal nome della chiave. In tutta l'app, la lettura della configurazione con la chiave AppSecret carica il valore del segreto.

6. Se la versione dell'app viene modificata nel file 5.1.0.0 di progetto in e l'app viene eseguita di nuovo, il valore del segreto restituito si trova 5.1.0.0_secret_value_dev nell'ambiente di sviluppo e 5.1.0.0_secret_value_prod in Produzione.

Nota

È anche possibile fornire la propria SecretClient implementazione a AddAzureKeyVault. Un client personalizzato consente di condividere una singola istanza del client nell'app.

Associare una matrice a una classe

Il provider può leggere i valori di configurazione in una matrice per l'associazione a una matrice POCO.

Quando si legge da un'origine di configurazione che consente alle chiavi di contenere separatori di due punti (:), viene usato un segmento di chiave numerica per distinguere le chiavi che costituiscono una matrice (:0:, :1:, ... :{n}:). Per altre informazioni, vedere Configurazione: Associare una matrice a una classe.

Le chiavi di Azure Key Vault non possono usare due punti come separatore. L'approccio descritto in questo articolo usa trattini doppi (--) come separatore per i valori gerarchici (sezioni). Le chiavi di matrice vengono archiviate in Azure Key Vault con trattini doppi e segmenti di chiave numerica (--0--, --1--, ... --{n}--).

Esaminare la seguente configurazione del provider di registrazione Serilog fornita da un file JSON. Nella matrice sono definiti WriteTo due valori letterali oggetto che riflettono due sink Serilog, che descrivono le destinazioni per la registrazione dell'output:

"Serilog": {
  "WriteTo": [
    {
      "Name": "AzureTableStorage",
      "Args": {
        "storageTableName": "logs",
        "connectionString": "DefaultEnd...ountKey=Eby8...GMGw=="
      }
    },
    {
      "Name": "AzureDocumentDB",
      "Args": {
        "endpointUrl": "https://contoso.documents.azure.com:443",
        "authorizationKey": "Eby8...GMGw=="
      }
    }
  ]
}

La configurazione illustrata nel file JSON precedente viene archiviata in Azure Key Vault usando la notazione double dash (--) e i segmenti numerici:

Chiave	valore
Serilog--WriteTo--0--Name	AzureTableStorage
Serilog--WriteTo--0--Args--storageTableName	logs
Serilog--WriteTo--0--Args--connectionString	DefaultEnd...ountKey=Eby8...GMGw==
Serilog--WriteTo--1--Name	AzureDocumentDB
Serilog--WriteTo--1--Args--endpointUrl	https://contoso.documents.azure.com:443
Serilog--WriteTo--1--Args--authorizationKey	Eby8...GMGw==

Ricaricare i segreti

Per impostazione predefinita, i segreti vengono memorizzati nella cache dal provider di configurazione per la durata dell'app. I segreti che sono stati successivamente disabilitati o aggiornati nell'insieme di credenziali vengono ignorati dall'app.

Per ricaricare i segreti, chiamare IConfigurationRoot.Reload:

config.Reload();

Per ricaricare periodicamente i segreti, a un intervallo specificato, impostare la AzureKeyVaultConfigurationOptions.ReloadInterval proprietà . Per altre informazioni, vedere Opzioni di configurazione.

Segreti disabilitati e scaduti

I segreti scaduti sono inclusi per impostazione predefinita nel provider di configurazione. Per escludere i valori per questi segreti nella configurazione dell'app, aggiornare il segreto scaduto o fornire la configurazione usando un provider di configurazione personalizzato:

class SampleKeyVaultSecretManager : KeyVaultSecretManager
{
  public override bool Load(SecretProperties properties) =>
    properties.ExpiresOn.HasValue &&
    properties.ExpiresOn.Value > DateTimeOffset.Now;
}

Passare questa personalizzata KeyVaultSecretManager a AddAzureKeyVault:

// using Azure.Extensions.AspNetCore.Configuration.Secrets;

builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{builder.Configuration["KeyVaultName"]}.vault.azure.net/"),
    new DefaultAzureCredential(),
    new SampleKeyVaultSecretManager());

I segreti disabilitati non possono essere recuperati da Key Vault e non sono mai inclusi.

Risoluzione dei problemi

Quando l'app non carica la configurazione usando il provider, viene scritto un messaggio di errore nell'infrastruttura di registrazione principale ASP.NET. Le condizioni seguenti impediranno il caricamento della configurazione:

• L'app o il certificato non sono configurati correttamente in Microsoft Entra ID.
• L'insieme di credenziali non esiste in Azure Key Vault.
• L'app non è autorizzata ad accedere all'insieme di credenziali.
• I criteri di accesso non includono Get e List le autorizzazioni.
• Nell'insieme di credenziali i dati di configurazione (coppia nome-valore) sono denominati in modo non corretto, mancanti o disabilitati.
• L'app ha il nome dell'insieme di credenziali delle chiavi (KeyVaultName), l'ID applicazione Microsoft Entra ID (AzureADApplicationId) o l'identificazione personale del certificato Microsoft Entra ID (AzureADCertThumbprint) o l'ID directory dell'ID Microsoft Entra (AzureADDirectoryId).
• Quando si aggiungono i criteri di accesso di Key Vault per l'app, i criteri sono stati creati, ma il pulsante Salva non è stato selezionato nell'interfaccia utente dei criteri di accesso.

Risorse aggiuntive

• Visualizzare o scaricare il codice di esempio (procedura per il download)
• Configurazione in ASP.NET Core
• Microsoft Azure: Documentazione di Key Vault
• Come generare e trasferire chiavi protette dal modulo di protezione hardware per Azure Key Vault
• Guida introduttiva: Impostare e recuperare un segreto da Azure Key Vault usando un'app Web .NET
• Esercitazione: Come usare Azure Key Vault con la macchina virtuale Windows di Azure in .NET