Øvelse – Adgangshemmeligheder, der er gemt i Azure Key Vault

13 minutter

Du ved, hvordan aktivering af administrerede identiteter for Azure-ressourcer opretter en identitet, som din app kan bruge til godkendelse. Opret nu en app, der bruger denne identitet til at få adgang til hemmeligheder i vaulten.

Læs hemmeligheder i en ASP.NET Core-app

Azure Key Vault API er en REST API, der håndterer al administration og brug af nøgler og vaults. Hver hemmelighed i en vault har en entydig URL-adresse. Hemmelige værdier hentes med HTTP GET-anmodninger.

Den officielle Key Vault-klient til .NET Core er den SecretClient klasse i Azure.Security.KeyVault.Secrets NuGet-pakken. Du behøver dog ikke at bruge den direkte. Med ASP.NET Cores AddAzureKeyVault-metode kan du indlæse alle hemmelighederne fra en vault i konfigurations-API'en ved start. Denne teknik giver dig adgang til alle dine hemmeligheder ved hjælp af det samme IConfiguration grænseflade, du bruger til resten af konfigurationen. Apps, der bruger AddAzureKeyVault, kræver både Get og List tilladelser til vaulten.

Drikkepenge

Uanset hvilken struktur eller sprog du bruger til at bygge din app, skal du designe den til at cachelagre hemmelige værdier lokalt eller indlæse dem i hukommelsen ved start, medmindre du har en bestemt grund til ikke at gøre det. Det er unødvendigt langsomt og dyrt at læse dem direkte fra boksen, hver gang du har brug for dem.

AddAzureKeyVault kræver kun vaultnavnet som input, som du får fra din lokale appkonfiguration. Den håndterer også automatisk godkendelse af administreret identitet. Når API'en bruges i en app, der er udrullet til Azure App Service med administrerede identiteter for Azure-ressourcer aktiveret. Den registrerer tokentjenesten for administrerede identiteter og bruger den til at godkende. Den passer godt til de fleste scenarier og implementerer alle bedste fremgangsmåder. Du bruger den i denne enheds øvelse.

Læs hemmeligheder i en Node.js-app

Den officielle Key Vault-klient til Node.js apps er den SecretClient klasse i @azure/keyvault-secrets npm-pakken. Apps, der indeholder hemmelige navne i deres konfiguration eller kode, bruger generelt metoden getSecret, som indlæser en hemmelig værdi med navnet. getSecret kræver, at din apps identitet har tilladelsen Get til vaulten. Apps, der er designet til at indlæse alle hemmeligheder fra en vault, bruger også metoden listPropertiesOfSecrets, som indlæser en liste over hemmeligheder og kræver List-tilladelse.

Før din app kan oprette en SecretClient forekomst, skal den have et objekt med legitimationsoplysninger til godkendelse i vaulten. Hvis du vil godkende, skal du bruge de DefaultAzureCredential, der leveres af @azure/identity npm-pakken. DefaultAzureCredential er velegnet til de fleste scenarier, hvor programmet er beregnet til i sidste ende at køre i Azure Cloud, fordi DefaultAzureCredential kombinerer legitimationsoplysninger, der ofte bruges til godkendelse, når de installeres, med legitimationsoplysninger, der bruges til at godkende i et udviklingsmiljø. DefaultAzureCredential forsøger at godkende ved hjælp af følgende mekanismer i rækkefølge:

Miljø. DefaultAzureCredential læser de kontooplysninger, der er angivet ved hjælp af miljøvariabler, og bruger dem til at godkende.
Administreret identitet. Hvis programmet udrulles til en Azure-vært med Administreret identitet aktiveret, godkendes DefaultAzureCredential med den pågældende konto.
Visual Studio Code. Hvis udvikleren er godkendt ved hjælp af plug-in'en Visual Studio Code Azure Account, godkendes DefaultAzureCredential med den pågældende konto.
Azure CLI. Hvis udvikleren har godkendt en konto ved hjælp af kommandoen Azure CLI az login, godkendes DefaultAzureCredential med den pågældende konto.

Du kan få flere oplysninger i dokumentationen.

Drikkepenge

Håndter hemmeligheder i en app

Når en hemmelighed er indlæst i din app, er det op til din app at håndtere den sikkert. I den app, du bygger i dette modul, skriver du din hemmelige værdi ud til klientsvaret, og for at vise, at den blev indlæst korrekt, får du den vist i en webbrowser. Returnering af en hemmelig værdi til klienten er ikke noget, du normalt skal gøre! Normalt bruger du hemmeligheder til at gøre ting som at initialisere klientbiblioteker til databaser eller eksterne API'er.

Vigtig

Gennemse altid din kode omhyggeligt for at sikre, at din app aldrig skriver hemmeligheder til nogen form for output, herunder logge, lager og svar.

Øvelse

Hvis du vil indlæse hemmeligheden fra vores vault, skal du oprette en ny ASP.NET Core-web-API og bruge AddAzureKeyVault.

Opret appen

Hvis du vil oprette en ny ASP.NET Core-web-API-app og åbne den i editoren, skal du køre følgende kommandoer i Azure Cloud Shell.
```
dotnet new webapi -o KeyVaultDemoApp
cd KeyVaultDemoApp
code .
```
Når editoren er indlæst, skal du tilføje NuGet-pakken, der indeholder AddAzureKeyVault og gendanne alle appens afhængigheder. Kør følgende kommandoer i Azure Cloud Shell.
```
dotnet add package Azure.Identity
dotnet add package Azure.Extensions.AspNetCore.Configuration.Secrets
dotnet restore
```

Tilføj kode, der indlæser og bruger hemmeligheder

Hvis du vil demonstrere god brug af Key Vault, skal du ændre din app for at indlæse hemmeligheder fra vaulten ved opstart. Du tilføjer også en ny controller med et slutpunkt, der henter din SecretPassword hemmelighed fra vaulten.

Hvis du vil starte appen, skal du angive følgende kommando for at starte editoren.
```
code .
```

Åbn Program.cs, slet indholdet, og erstat dem med følgende kode.

using System;
using Azure.Identity;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;

namespace KeyVaultDemoApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                })
                .ConfigureAppConfiguration((context, config) =>
                {
                    // Build the current set of configuration to load values from
                    // JSON files and environment variables, including VaultName.
                    var builtConfig = config.Build();

                    // Use VaultName from the configuration to create the full vault URI.
                    var vaultName = builtConfig["VaultName"];
                    Uri vaultUri = new Uri($"https://{vaultName}.vault.azure.net/");

                    // Load all secrets from the vault into configuration. This will automatically
                    // authenticate to the vault using a managed identity. If a managed identity
                    // is not available, it will check if Visual Studio and/or the Azure CLI are
                    // installed locally and see if they are configured with credentials that can
                    // access the vault.
                    config.AddAzureKeyVault(vaultUri, new DefaultAzureCredential());
                });
    }
}

Vigtig

Sørg for at gemme filer, når du er færdig med at redigere dem. Du kan gemme filer enten via "..." eller acceleratornøglen (Ctrl+S- på Windows og Linux Cmd+S på macOS).

Den eneste ændring fra startkoden er tilføjelsen af ConfigureAppConfiguration. Dette element er stedet, hvor vi indlæser vaultnavnet fra konfigurationen og kalder AddAzureKeyVault med det.

For controlleren skal du oprette en ny fil i mappen Controllers med navnet SecretTestController.csog indsætte følgende kode.

Drikkepenge

Hvis du vil oprette en ny fil, skal du bruge kommandoen touch i Cloud Shell. I dette tilfælde skal du køre kommandoen touch Controllers/SecretTestController.cs. Hvis du vil finde den i øverste højre hjørne af ruden filer i editoren, skal du vælge ikonet Opdater.

using System;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;

namespace KeyVaultDemoApp.Controllers
{
    [Route("api/[controller]")]
    public class SecretTestController : ControllerBase
    {
        private readonly IConfiguration _configuration;

        public SecretTestController(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        [HttpGet]
        public IActionResult Get()
        {
            // Get the secret value from configuration. This can be done anywhere
            // we have access to IConfiguration. This does not call the Key Vault
            // API, because the secrets were loaded at startup.
            var secretName = "SecretPassword";
            var secretValue = _configuration[secretName];

            if (secretValue == null)
            {
                return StatusCode(
                    StatusCodes.Status500InternalServerError,
                    $"Error: No secret named {secretName} was found...");
            }
            else {
                return Content($"Secret value: {secretValue}" +
                    Environment.NewLine + Environment.NewLine +
                    "This is for testing only! Never output a secret " +
                    "to a response or anywhere else in a real app!");
            }
        }
    }
}

Kør kommandoen dotnet build i Azure Cloud Shell, og sørg for, at alt kompileres. Appen er klar til at køre. Nu er det tid til at få det ind i Azure!

Opret en ny web-API med Express.js, og brug pakkerne @azure/keyvault-secrets og @azure/identity til at indlæse hemmeligheden fra vores vault.

Opret appen

Kør følgende kode i Azure Cloud Shell for at initialisere en ny Node.js app, installere de nødvendige pakker og åbne en ny fil i editoren.

mkdir KeyVaultDemoApp
cd KeyVaultDemoApp
npm init -y
npm install @azure/identity @azure/keyvault-secrets express
touch app.js
code app.js

Tilføj kode, der indlæser og bruger hemmeligheder

For at demonstrere god brug af Key Vault indlæser din app hemmeligheder fra vaulten ved opstart. Hvis du vil vise, at dine hemmeligheder er indlæst, skal du oprette et slutpunkt, der viser værdien af den SecretPassword hemmelighed.

Hvis du vil konfigurere appen, skal du indsætte følgende kode i editoren. Denne kode importerer de nødvendige pakker, konfigurerer URI-konfigurationen for port og vault og opretter et nyt objekt til at indeholde hemmelige navne og værdier.
```
// Importing dependencies
const { DefaultAzureCredential } = require("@azure/identity");
const { SecretClient } = require("@azure/keyvault-secrets");
const app = require('express')();

// Initialize port
const port = process.env.PORT || 3000;

// Create Vault URI from App Settings
const vaultUri = `https://${process.env.VaultName}.vault.azure.net/`;

// Map of key vault secret names to values
let vaultSecretsMap = {};
```
Vigtig

Sørg for at gemme filer, mens du arbejder på dem, især når du er færdig. Du kan gemme filer enten via "..." eller acceleratornøglen (Ctrl+S- på Windows og Linux Cmd+S på macOS).

Derefter skal du føje koden for at godkende til vaulten og indlæse hemmelighederne. Du tilføjer denne kode som to separate funktioner. Indsæt et par tomme linjer efter den kode, du tidligere har tilføjet, og indsæt derefter følgende kode.

const getKeyVaultSecrets = async () => {
  // Create a key vault secret client
  let secretClient = new SecretClient(vaultUri, new DefaultAzureCredential());
  try {
    // Iterate through each secret in the vault
    listPropertiesOfSecrets = secretClient.listPropertiesOfSecrets();
    while (true) {
      let { done, value } = await listPropertiesOfSecrets.next();
      if (done) {
        break;
      }
      // Only load enabled secrets - getSecret will return an error for disabled secrets
      if (value.enabled) {
        const secret = await secretClient.getSecret(value.name);
        vaultSecretsMap[value.name] = secret.value;
      }
    }
  } catch(err) {
    console.log(err.message)
  }
}

Hvis du vil teste, om vores hemmelighed blev indlæst, skal du oprette Express-slutpunktet. Indsæt denne kode.

app.get('/api/SecretTest', (req, res) => {
  let secretName = 'SecretPassword';
  let response;
  if (secretName in vaultSecretsMap) {
    response = `Secret value: ${vaultSecretsMap[secretName]}\n\nThis is for testing only! Never output a secret to a response or anywhere else in a real app!`;
  } else {
    response = `Error: No secret named ${secretName} was found...`
  }
  res.type('text');
  res.send(response);
});

Kald dine funktioner for at indlæse hemmelighederne fra vores vault, og start derefter appen. Indsæt dette sidste kodestykke for at fuldføre appen.

(async () =>  {
  await getKeyVaultSecrets();
  app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
  });
})().catch(err => console.log(err));

Du er færdig med at skrive kode, så sørg for at gemme filen.

Appen er klar til at køre. Nu er det tid til at få det ind i Azure!

Øvelse – Adgangshemmeligheder, der er gemt i Azure Key Vault

Læs hemmeligheder i en ASP.NET Core-app

Læs hemmeligheder i en Node.js-app

Håndter hemmeligheder i en app

Øvelse

Opret appen

Tilføj kode, der indlæser og bruger hemmeligheder

Opret appen

Tilføj kode, der indlæser og bruger hemmeligheder

Feedback