Schnellstart: Azure Key Vault-Schlüsselclientbibliothek für .NET

Artikel
04/09/2024

Hier finden Sie Informationen zu den ersten Schritten mit der Azure Key Vault-Schlüsselclientbibliothek für .NET. Azure Key Vault ist ein Clouddienst, der als sicherer Speicher für kryptografische Schlüssel fungiert. Dadurch können kryptografische Schlüssel, Kennwörter, Zertifikate und andere Geheimnisse sicher gespeichert werden. Azure Key Vault-Instanzen können über das Azure-Portal erstellt und verwaltet werden. In dieser Schnellstartanleitung erfahren Sie, wie Sie mithilfe der .NET-Schlüsselclientbibliothek Schlüssel in einem Azure-Schlüsseltresor erstellen, daraus abrufen und löschen.

Ressourcen der Key Vault-Schlüsselclientbibliothek:

API-Referenzdokumentation | Quellcode der Bibliothek | Paket (NuGet)

Weitere Informationen zu Key Vault und Schlüsseln finden Sie unter folgenden Links:

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto
.NET 6 SDK oder höher
Azure-Befehlszeilenschnittstelle
Eine Key Vault-Instanz. Diese kann über das Azure-Portal, die Azure CLI oder mithilfe von Azure PowerShell erstellt werden.

In dieser Schnellstartanleitung werden dotnet und die Azure CLI verwendet.

Einrichten

In dieser Schnellstartanleitung wird die Azure Identity-Bibliothek mit der Azure CLI verwendet, um den Benutzer bei Azure-Diensten zu authentifizieren. Entwickler können auch Visual Studio oder Visual Studio Code verwenden, um ihre Aufrufe zu authentifizieren. Weitere Informationen finden Sie unter Authentifizieren des Clients mit der Azure Identity-Clientbibliothek.

Führen Sie den Befehl login aus.
```
az login
```
Die CLI öffnet Ihren Standardbrowser, sofern sie dazu in der Lage ist, und lädt eine Azure-Anmeldeseite.

Öffnen Sie andernfalls die Browserseite https://aka.ms/devicelogin, und geben Sie den in Ihrem Terminal angezeigten Autorisierungscode ein.
Melden Sie sich im Browser mit Ihren Anmeldeinformationen an.

Gewähren des Zugriffs auf Ihren Schlüsseltresor

Azure-Befehlszeilenschnittstelle
Azure PowerShell

Um Ihrem Schlüsseltresor über die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) Berechtigungen für Ihre Anwendung zu gewähren, weisen Sie mithilfe des Azure CLI-Befehls az role assignment create eine Rolle zu.

az role assignment create --role "Key Vault Secrets User" --assignee "<app-id>" --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>/providers/Microsoft.KeyVault/vaults/<your-unique-keyvault-name>"

Um Ihrem Schlüsseltresor über die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) Berechtigungen für Ihre Anwendung zu gewähren, weisen Sie mithilfe des Azure PowerShell-Cmdlets New-AzRoleAssignment eine Rolle zu.

New-AzRoleAssignment -ObjectId "<app-id>" -RoleDefinitionName "Key Vault Secrets User" -Scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>/providers/Microsoft.KeyVault/vaults/<your-unique-keyvault-name>"

Ersetzen Sie <app-id>, <subscription-id>, <resource-group-name> und <your-unique-keyvault-name> durch Ihre tatsächlichen Werte. <app-id> ist die Anwendungs-ID (Client-ID) Ihrer registrierten Anwendung in Azure AD.

Erstellen einer neuen .NET-Konsolen-App

Führen Sie in einer Befehlsshell den folgenden Befehl aus, um ein Projekt namens key-vault-console-app zu erstellen:
```
dotnet new console --name key-vault-console-app
```
Wechseln Sie zum neu erstellten Verzeichnis key-vault-console-app, und führen Sie den folgenden Befehl aus, um das Projekt zu erstellen:
```
dotnet build
```
Die Buildausgabe sollte keine Warnungen oder Fehler enthalten.
```
Build succeeded.
 0 Warning(s)
 0 Error(s)
```

Installieren der Pakete

Installieren Sie über die Befehlsshell die Azure Key Vault-Schlüsselclientbibliothek für .NET:

dotnet add package Azure.Security.KeyVault.Keys

Für diese Schnellstartanleitung müssen Sie auch die Azure Identity-Clientbibliothek installieren:

dotnet add package Azure.Identity

Festlegen von Umgebungsvariablen

Diese Anwendung verwendet den Namen des Schlüsseltresors als Umgebungsvariable namens KEY_VAULT_NAME.

Windows

set KEY_VAULT_NAME=<your-key-vault-name>

Windows PowerShell

$Env:KEY_VAULT_NAME="<your-key-vault-name>"

macOS oder Linux

export KEY_VAULT_NAME=<your-key-vault-name>

Objektmodell

Mit der Azure Key Vault-Schlüsselclientbibliothek für .NET können Sie Schlüssel verwalten. Im Abschnitt Codebeispiele wird gezeigt, wie ein Client erstellt und ein Schlüssel festgelegt, abgerufen und gelöscht wird.

Codebeispiele

Hinzufügen von Anweisungen

Fügen Sie am Anfang von Program.cs die folgenden Anweisungen hinzu:

using System;
using Azure.Identity;
using Azure.Security.KeyVault.Keys;

Authentifizieren und Erstellen eines Clients

Anwendungsanforderungen an die meisten Azure-Dienste müssen autorisiert werden. Die Verwendung der von der Azure Identity-Clientbibliothek bereitgestellten Klasse DefaultAzureCredential ist der empfohlene Ansatz zum Implementieren von kennwortlosen Verbindungen mit Azure-Diensten in Ihrem Code. DefaultAzureCredential unterstützt mehrere Authentifizierungsmethoden und bestimmt, welche Methode zur Laufzeit verwendet werden soll. Bei diesem Ansatz kann Ihre App unterschiedliche Authentifizierungsmethoden in verschiedenen Umgebungen (lokal gegenüber Produktion) verwenden, ohne umgebungsspezifischen Code zu implementieren.

In dieser Schnellstartanleitung authentifiziert sich DefaultAzureCredential mit den Anmeldeinformationen des lokalen Entwicklungsbenutzers, der bei der Azure CLI angemeldet ist, beim Schlüsseltresor. Wenn die Anwendung in Azure bereitgestellt wird, kann derselbe DefaultAzureCredential-Code automatisch eine verwaltete Identität ermitteln und verwenden, die App Service, einem virtuellen Computer oder anderen Diensten zugewiesen ist. Weitere Informationen finden Sie in der Übersicht zu verwalteten Identitäten.

In diesem Beispiel wird der Name Ihres Schlüsseltresors in den Schlüsseltresor-URI mit dem Format https://<your-key-vault-name>.vault.azure.net erweitert. Weitere Informationen zur Authentifizierung beim Schlüsseltresor finden Sie im Entwicklerhandbuch.

var keyVaultName = Environment.GetEnvironmentVariable("KEY_VAULT_NAME");
var kvUri = $"https://{keyVaultName}.vault.azure.net";

var client = new KeyClient(new Uri(kvUri), new DefaultAzureCredential());

Speichern eines Schlüssels

Verwenden Sie hierfür die CreateKeyAsync-Methode. Die Parameter der Methode akzeptieren einen Schlüsselnamen und den Schlüsseltyp.

var key = await client.CreateKeyAsync("myKey", KeyType.Rsa);

Hinweis

Ist der Schlüsselname vorhanden, wird über diesen Code eine neue Version dieses Schlüssels erstellt.

Abrufen eines Schlüssels

Nun können Sie den zuvor erstellten Schlüssel mithilfe der CreateKeyAsync-Methode abrufen.

var key = await client.GetKeyAsync("myKey");

Löschen eines Schlüssels

Abschließend löschen Sie den Schlüssel mit der Methode StartDeleteKeyAsync aus Ihrem Schlüsseltresor und bereinigen ihn mit der Methode PurgeDeletedKeyAsync.

var operation = await client.StartDeleteKeyAsync("myKey");

// You only need to wait for completion if you want to purge or recover the key.
await operation.WaitForCompletionAsync();

var key = operation.Value;
await client.PurgeDeletedKeyAsync("myKey");

Beispielcode

Führen Sie die folgenden Schritte aus, um die .NET-Konsolen-App so zu ändern, dass Sie mit dem Schlüsseltresor interagiert:

Ersetzen Sie den Code in Program.cs durch den folgenden Code:

using System;
using System.Threading.Tasks;
using Azure.Identity;
using Azure.Security.KeyVault.Keys;

namespace key_vault_console_app
{
    class Program
    {
        static async Task Main(string[] args)
        {
            const string keyName = "myKey";
            var keyVaultName = Environment.GetEnvironmentVariable("KEY_VAULT_NAME");
            var kvUri = $"https://{keyVaultName}.vault.azure.net";

            var client = new KeyClient(new Uri(kvUri), new DefaultAzureCredential());

            Console.Write($"Creating a key in {keyVaultName} called '{keyName}' ...");
            var createdKey = await client.CreateKeyAsync(keyName, KeyType.Rsa);
            Console.WriteLine("done.");

            Console.WriteLine($"Retrieving your key from {keyVaultName}.");
            var key = await client.GetKeyAsync(keyName);
            Console.WriteLine($"Your key version is '{key.Value.Properties.Version}'.");

            Console.Write($"Deleting your key from {keyVaultName} ...");
            var deleteOperation = await client.StartDeleteKeyAsync(keyName);
            // You only need to wait for completion if you want to purge or recover the key.
            await deleteOperation.WaitForCompletionAsync();
            Console.WriteLine("done.");

            Console.Write($"Purging your key from {keyVaultName} ...");
            await client.PurgeDeletedKeyAsync(keyName);
            Console.WriteLine(" done.");
        }
    }
}

Testen und Überprüfen

Ausführen des folgenden Befehls zum Erstellen des Projekts
```
dotnet build
```
Führen Sie die App mit dem folgenden Befehl aus.
```
dotnet run
```

Geben Sie bei entsprechender Aufforderung einen Geheimniswert ein, z. B. „mySecretPassword“.

Eine Variation der folgenden Ausgabe wird angezeigt:

Creating a key in mykeyvault called 'myKey' ... done.
Retrieving your key from mykeyvault.
Your key version is '8532359bced24e4bb2525f2d2050738a'.
Deleting your key from jl-kv ... done
Purging your key from <your-unique-keyvault-name> ... done.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie einen Schlüsseltresor erstellt, einen Schlüssel gespeichert und diesen Schlüssel abgerufen.

Weitere Informationen zu Key Vault und zur Integration in Ihre Apps finden Sie in den folgenden Artikeln: