Freigeben über


Schnellstart: Azure Key Vault-Schlüsselclientbibliothek für JavaScript

Hier finden Sie Informationen zu den ersten Schritten mit der Azure Key Vault-Schlüsselclientbibliothek für JavaScript. Azure Key Vault ist ein Clouddienst, der als sicherer Speicher für kryptografische Schlüssel fungiert. Dadurch können 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 JavaScript-Schlüsselclientbibliothek Schlüssel in einem Azure-Schlüsseltresor erstellen, daraus abrufen und löschen.

Ressourcen der Key Vault-Clientbibliothek:

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

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

Voraussetzungen

In diesem Schnellstart wird davon ausgegangen, dass Sie die Azure CLI ausführen.

Anmelden bei Azure

  1. 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.

  2. Melden Sie sich im Browser mit Ihren Anmeldeinformationen an.

Erstellen einer neuen Node.js-Anwendung

Erstellen Sie eine Node.js-Anwendung, die Ihren Schlüsseltresor verwendet.

  1. Erstellen Sie in einem Terminal einen Ordner namens key-vault-node-app und wechseln Sie in diesen Ordner:

    mkdir key-vault-node-app && cd key-vault-node-app
    
  2. Initialisieren Sie das Node.js-Projekt:

    npm init -y
    

Installieren von Key Vault-Paketen

  1. Installieren Sie über das Terminal die Azure Key Vault-Geheimnisclientbibliothek, @azure/keyvault-secrets für Node.js.

    npm install @azure/keyvault-keys
    
  2. Installieren Sie das Paket für die Azure-Identitätsclientbibliothek, @azure/identity, um sich bei einem Key Vault zu authentifizieren.

    npm install @azure/identity
    

Gewähren des Zugriffs auf Ihren Schlüsseltresor

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

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

Ersetzen Sie <upn>, <subscription-id>, <resource-group-name> und <your-unique-keyvault-name> durch Ihre tatsächlichen Werte. Ihr Benutzerprinzipalname (UPN) hat in der Regel das Format einer E-Mail-Adresse (z. B. username@domain.com).

Festlegen von Umgebungsvariablen

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

set KEY_VAULT_URL=<your-key-vault-endpoint>

Authentifizieren und Erstellen eines Clients

Anwendungsanforderungen an die meisten Azure-Dienste müssen autorisiert werden. Die Verwendung der von der Azure-Identitätsclientbibliothek bereitgestellten Methode 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 Code wird der Endpunkt Ihres Schlüsseltresors verwendet, um den Schlüsseltresorclient zu erstellen. Das Endpunktformat sieht wie https://<your-key-vault-name>.vault.azure.net aus, kann sich jedoch für souveräne Clouds ändern. Weitere Informationen zur Authentifizierung beim Schlüsseltresor finden Sie im Entwicklerhandbuch.

Codebeispiel

In den folgenden Codebeispielen wird gezeigt, wie Sie einen Client erstellen und ein Geheimnis festlegen, abrufen und löschen.

Dieser Code verwendet die folgenden Key Vault-Geheimnisklassen und -methoden:

Einrichten des App-Frameworks

  • Erstellen Sie eine neue Textdatei und fügen Sie den folgenden Code in die Datei index.js ein.

    const { KeyClient } = require("@azure/keyvault-keys");
    const { DefaultAzureCredential } = require("@azure/identity");
    
    async function main() {
    
        // DefaultAzureCredential expects the following three environment variables:
        // - AZURE_TENANT_ID: The tenant ID in Azure Active Directory
        // - AZURE_CLIENT_ID: The application (client) ID registered in the AAD tenant
        // - AZURE_CLIENT_SECRET: The client secret for the registered application
        const credential = new DefaultAzureCredential();
    
        const keyVaultUrl = process.env["KEY_VAULT_URL"];
        if(!keyVaultUrl) throw new Error("KEY_VAULT_URL is empty");
    
        const client = new KeyClient(keyVaultUrl, credential);
    
        const uniqueString = Date.now();
        const keyName = `sample-key-${uniqueString}`;
        const ecKeyName = `sample-ec-key-${uniqueString}`;
        const rsaKeyName = `sample-rsa-key-${uniqueString}`;
    
        // Create key using the general method
        const result = await client.createKey(keyName, "EC");
        console.log("key: ", result);
    
        // Create key using specialized key creation methods
        const ecResult = await client.createEcKey(ecKeyName, { curve: "P-256" });
        const rsaResult = await client.createRsaKey(rsaKeyName, { keySize: 2048 });
        console.log("Elliptic curve key: ", ecResult);
        console.log("RSA Key: ", rsaResult);
    
        // Get a specific key
        const key = await client.getKey(keyName);
        console.log("key: ", key);
    
        // Or list the keys we have
        for await (const keyProperties of client.listPropertiesOfKeys()) {
        const key = await client.getKey(keyProperties.name);
        console.log("key: ", key);
        }
    
        // Update the key
        const updatedKey = await client.updateKeyProperties(keyName, result.properties.version, {
        enabled: false
        });
        console.log("updated key: ", updatedKey);
    
        // Delete the key - the key is soft-deleted but not yet purged
        const deletePoller = await client.beginDeleteKey(keyName);
        await deletePoller.pollUntilDone();
    
        const deletedKey = await client.getDeletedKey(keyName);
        console.log("deleted key: ", deletedKey);
    
        // Purge the key - the key is permanently deleted
        // This operation could take some time to complete
        console.time("purge a single key");
        await client.purgeDeletedKey(keyName);
        console.timeEnd("purge a single key");
    }
    
    main().catch((error) => {
      console.error("An error occurred:", error);
      process.exit(1);
    });
    

Ausführen der Beispielanwendung

  1. Führen Sie die App aus:

    node index.js
    
  2. Die create- und get-Methoden geben ein vollständiges JSON-Objekt für den Schlüssel zurück:

    "key":  {
      "key": {
        "kid": "https://YOUR-KEY-VAULT-ENDPOINT/keys/YOUR-KEY-NAME/YOUR-KEY-VERSION",
        "kty": "YOUR-KEY-TYPE",
        "keyOps": [ ARRAY-OF-VALID-OPERATIONS ],
        ... other properties based on key type
      },
      "id": "https://YOUR-KEY-VAULT-ENDPOINT/keys/YOUR-KEY-NAME/YOUR-KEY-VERSION",
      "name": "YOUR-KEY-NAME",
      "keyOperations": [ ARRAY-OF-VALID-OPERATIONS ],
      "keyType": "YOUR-KEY-TYPE",
      "properties": {
        "tags": undefined,
        "enabled": true,
        "notBefore": undefined,
        "expiresOn": undefined,
        "createdOn": 2021-11-29T18:29:11.000Z,
        "updatedOn": 2021-11-29T18:29:11.000Z,
        "recoverableDays": 90,
        "recoveryLevel": "Recoverable+Purgeable",
        "exportable": undefined,
        "releasePolicy": undefined,
        "vaultUrl": "https://YOUR-KEY-VAULT-ENDPOINT",
        "version": "YOUR-KEY-VERSION",
        "name": "YOUR-KEY-VAULT-NAME",
        "managed": undefined,
        "id": "https://YOUR-KEY-VAULT-ENDPOINT/keys/YOUR-KEY-NAME/YOUR-KEY-VERSION"
      }
    }
    
  • Erstellen Sie eine neue Textdatei, und fügen Sie den folgenden Code in die Datei index.js ein.

    import {
      KeyClient,
      KeyVaultKey,
      KeyProperties,
      DeletedKey,
    } from "@azure/keyvault-keys";
    import { DefaultAzureCredential } from "@azure/identity";
    import "dotenv/config";
    
    const credential = new DefaultAzureCredential();
    
    // Get Key Vault name from environment variables
    // such as `https://${keyVaultName}.vault.azure.net`
    const keyVaultUrl = process.env.KEY_VAULT_URL;
    if (!keyVaultUrl) throw new Error("KEY_VAULT_URL is empty");
    
    function printKey(keyVaultKey: KeyVaultKey): void {
      const { name, key, id, keyType, keyOperations, properties } = keyVaultKey;
      console.log("Key: ", { name, key, id, keyType });
    
      const { vaultUrl, version, enabled, expiresOn }: KeyProperties = properties;
      console.log("Key Properties: ", { vaultUrl, version, enabled, expiresOn });
    
      console.log("Key Operations: ", keyOperations.join(", "));
    }
    
    async function main(): Promise<void> {
      // Create a new KeyClient
      const client = new KeyClient(keyVaultUrl, credential);
    
      // Create unique key names
      const uniqueString = Date.now().toString();
      const keyName = `sample-key-${uniqueString}`;
      const ecKeyName = `sample-ec-key-${uniqueString}`;
      const rsaKeyName = `sample-rsa-key-${uniqueString}`;
    
      // Create a EC key
      const ecKey = await client.createKey(keyName, "EC");
      printKey(ecKey);
    
      // Elliptic curve key
      const ec256Key = await client.createEcKey(ecKeyName, {
        curve: "P-256",
      });
      printKey(ec256Key);
    
      // RSA key
      const rsa2048Key = await client.createRsaKey(rsaKeyName, {
        keySize: 2048,
      });
      printKey(rsa2048Key);
    
      // Get a key
      const key = await client.getKey(keyName);
      printKey(key);
    
      // Get properties of all keys
      for await (const keyProperties of client.listPropertiesOfKeys()) {
        const iteratedKey = await client.getKey(keyProperties.name);
        printKey(iteratedKey);
      }
    
      // Update key properties - disable key
      const updatedKey = await client.updateKeyProperties(
        keyName,
        ecKey.properties.version,
        {
          enabled: false,
        }
      );
      printKey(updatedKey);
    
      // Delete key (without immediate purge)
      const deletePoller = await client.beginDeleteKey(keyName);
      await deletePoller.pollUntilDone();
    
      // Get a deleted key
      const deletedKey = await client.getDeletedKey(keyName);
      console.log("deleted key: ", deletedKey.name);
    
      // Purge a deleted key
      console.time("purge a single key");
      await client.purgeDeletedKey(keyName);
      console.timeEnd("purge a single key");
    }
    
    main().catch((error) => {
      console.error("An error occurred:", error);
      process.exit(1);
    });
    

Ausführen der Beispielanwendung

  1. Erstellen Sie die TypeScript-App:

    tsc
    
  2. Führen Sie die App aus:

    node index.js
    
  3. Die create- und get-Methoden geben ein vollständiges JSON-Objekt für den Schlüssel zurück:

    "key":  {
      "key": {
        "kid": "https://YOUR-KEY-VAULT-ENDPOINT/keys/YOUR-KEY-NAME/YOUR-KEY-VERSION",
        "kty": "YOUR-KEY-TYPE",
        "keyOps": [ ARRAY-OF-VALID-OPERATIONS ],
        ... other properties based on key type
      },
      "id": "https://YOUR-KEY-VAULT-ENDPOINT/keys/YOUR-KEY-NAME/YOUR-KEY-VERSION",
      "name": "YOUR-KEY-NAME",
      "keyOperations": [ ARRAY-OF-VALID-OPERATIONS ],
      "keyType": "YOUR-KEY-TYPE",
      "properties": {
        "tags": undefined,
        "enabled": true,
        "notBefore": undefined,
        "expiresOn": undefined,
        "createdOn": 2021-11-29T18:29:11.000Z,
        "updatedOn": 2021-11-29T18:29:11.000Z,
        "recoverableDays": 90,
        "recoveryLevel": "Recoverable+Purgeable",
        "exportable": undefined,
        "releasePolicy": undefined,
        "vaultUrl": "https://YOUR-KEY-VAULT-ENDPOINT",
        "version": "YOUR-KEY-VERSION",
        "name": "YOUR-KEY-VAULT-NAME",
        "managed": undefined,
        "id": "https://YOUR-KEY-VAULT-ENDPOINT/keys/YOUR-KEY-NAME/YOUR-KEY-VERSION"
      }
    }
    

Integration mit App-Konfiguration

Das Azure SDK bietet eine Hilfsmethode, parseKeyVaultKeyIdentifier, um die angegebene Key Vault-Schlüssel-ID zu analysieren. Dies ist erforderlich, wenn Sie App-Konfigurationsreferenzen auf Key Vault verwenden. App-Konfiguration speichert die Key Vault Schlüssel-ID. Sie benötigen die Methode parseKeyVaultKeyIdentifier, um diese ID zu analysieren und den Schlüsselnamen abzurufen. Sobald Sie den Schlüsselnamen haben, können Sie den aktuellen Schlüsselwert mit Code aus dieser Schnellstartanleitung erhalten.

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 Anwendungen finden Sie in den folgenden Artikeln.