Rychlý start: Klientská knihovna certifikátů služby Azure Key Vault pro JavaScript

Začínáme s klientskou knihovnou certifikátů služby Azure Key Vault pro JavaScript Azure Key Vault je cloudová služba, která poskytuje zabezpečené úložiště certifikátů. Můžete bezpečně ukládat klíče, hesla, certifikáty a další tajné klíče. Trezory klíčů Azure můžete vytvářet a spravovat přes web Azure Portal. V tomto rychlém startu se naučíte vytvářet, načítat a odstraňovat certifikáty z trezoru klíčů Azure pomocí klientské knihovny JavaScriptu.

Prostředky knihovny klienta služby Key Vault:

Referenční dokumentace k API | Zdrojový kód knihovny | Balíček (npm)

Další informace o službě Key Vault a certifikátech najdete tady:

Požadavky

Předplatné Azure – vytvořte si ho zdarma.
Aktuální Node.js LTS.
Azure CLI
Existující služba Key Vault – můžete ji vytvořit pomocí:

Předplatné Azure – vytvořte si ho zdarma.
Aktuální Node.js LTS.
TypeScript 5+
Azure CLI
Existující služba Key Vault – můžete ji vytvořit pomocí:

V tomto rychlém startu se předpokládá, že používáte Azure CLI.

Spusťte příkaz login.
```
az login
```
Pokud rozhraní příkazového řádku může otevřít výchozí prohlížeč, provede to a načte přihlašovací stránku Azure.

V opačném případě otevřete stránku https://aka.ms/devicelogin prohlížeče a zadejte autorizační kód zobrazený v terminálu.
Přihlaste se pomocí přihlašovacích údajů vašeho účtu v prohlížeči.

Vytvoření nové aplikace Node.js

Vytvořte Node.js aplikaci, která používá váš trezor klíčů.

V terminálu vytvořte složku s názvem key-vault-node-app a změňte ji do této složky:
```
mkdir key-vault-node-app && cd key-vault-node-app
```
Inicializace projektu Node.js:
```
npm init -y
```

Instalace balíčků služby Key Vault

Pomocí terminálu nainstalujte knihovnu tajných kódů služby Azure Key Vault @azure/keyvault-certificates pro Node.js.
```
npm install @azure/keyvault-certificates
```
Nainstalujte klientskou knihovnu Azure Identity, @azure/identity, pro ověření ve službě Key Vault.
```
npm install @azure/identity
```

Udělení přístupu k trezoru klíčů

Pokud chcete získat oprávnění k trezoru klíčů prostřednictvím řízení přístupu na základě role (RBAC), přiřaďte roli k hlavnímu názvu uživatele (UPN) pomocí příkazu Azure CLI az role assignment create.

az role assignment create --role "Key Vault Certificates Officer" --assignee "<upn>" --scope "/subscriptions/<subscription-id>/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/<vault-name>"

Nahraďte hodnoty <upn>, <subscription-id> a <vault-name> skutečnými hodnotami. Pokud jste použili jiný název skupiny prostředků, nahraďte také myResourceGroup. Hlavní název uživatele (UPN) bude obvykle v formátu e-mailové adresy (např. username@domain.com).

Nastavení proměnných prostředí

Tato aplikace používá koncový bod trezoru klíčů jako proměnnou prostředí s názvem KEY_VAULT_URL.

set KEY_VAULT_URL=<key-vault-endpoint>

Windows PowerShell

$Env:KEY_VAULT_URL="<key-vault-endpoint>"

export KEY_VAULT_URL=<key-vault-endpoint>

Ověření a vytvoření klienta

Žádosti o aplikace na většinu služeb Azure musí být autorizované. Použití metody DefaultAzureCredential poskytované klientskou knihovnou azure Identity je doporučeným přístupem k implementaci připojení bez hesel ke službám Azure ve vašem kódu. DefaultAzureCredential podporuje více metod ověřování a určuje, která metoda se má použít za běhu. Tento přístup umožňuje vaší aplikaci používat různé metody ověřování v různých prostředích (místní a produkční) bez implementace kódu specifického pro prostředí.

V tomto rychlém startu se DefaultAzureCredential autentizuje vůči Key Vault pomocí přihlašovacích údajů místního vývojového uživatele přihlášeného v Azure CLI. Když je aplikace nasazená do Azure, může stejný DefaultAzureCredential kód automaticky zjišťovat a používat spravovanou identitu přiřazenou ke službě App Service, virtuálnímu počítači nebo jiným službám. Další informace najdete v tématu Přehled spravované identity.

V tomto kódu se koncový bod vašeho trezoru klíčů používá k vytvoření klienta trezoru klíčů. Formát koncového bodu vypadá jako https://<vault-name>.vault.azure.net, ale může se změnit u suverénních cloudů. Další informace o ověřování v trezoru klíčů najdete v příručce pro vývojáře.

Příklad kódu

Tento kód používá následující třídy a metody certifikátů služby Key Vault:

Nastavení architektury aplikace

Vytvořte nový textový soubor a vložte do index.js souboru následující kód.

Poznámka:

Tento rychlý start vytvoří certifikát podepsaný svým držitelem pro demonstrační účely. V případě produkčních úloh integrujte Key Vault s důvěryhodnou certifikační autoritou. Viz Bezpečte si certifikáty Azure Key Vault.

const { CertificateClient, DefaultCertificatePolicy } = require("@azure/keyvault-certificates");
const { DefaultAzureCredential } = require("@azure/identity");

async function main() {
  // DefaultAzureCredential automatically uses managed identity in Azure environments.
  // For local development, it uses credentials from Azure CLI, Azure PowerShell, or environment variables.
  // See: https://learn.microsoft.com/javascript/api/@azure/identity/defaultazurecredential
  const credential = new DefaultAzureCredential();

  const keyVaultUrl = process.env["KEY_VAULT_URL"];
  if(!keyVaultUrl) throw new Error("KEY_VAULT_URL is empty");

  const client = new CertificateClient(keyVaultUrl, credential);

  const uniqueString = new Date().getTime();
  const certificateName = `cert${uniqueString}`;

  // Creating a self-signed certificate
  const createPoller = await client.beginCreateCertificate(
    certificateName,
    DefaultCertificatePolicy
  );

  const pendingCertificate = createPoller.getResult();
  console.log("Certificate: ", pendingCertificate);

  // To read a certificate with their policy:
  let certificateWithPolicy = await client.getCertificate(certificateName);
  // Note: It will always read the latest version of the certificate.

  console.log("Certificate with policy:", certificateWithPolicy);

  // To read a certificate from a specific version:
  const certificateFromVersion = await client.getCertificateVersion(
    certificateName,
    certificateWithPolicy.properties.version
  );
  // Note: It will not retrieve the certificate's policy.
  console.log("Certificate from a specific version:", certificateFromVersion);

  const updatedCertificate = await client.updateCertificateProperties(certificateName, "", {
    tags: {
      customTag: "value"
    }
  });
  console.log("Updated certificate:", updatedCertificate);

  // Updating the certificate's policy:
  await client.updateCertificatePolicy(certificateName, {
    issuerName: "Self",
    subject: "cn=MyOtherCert"
  });
  certificateWithPolicy = await client.getCertificate(certificateName);
  console.log("updatedCertificate certificate's policy:", certificateWithPolicy.policy);

  // delete certificate
  const deletePoller = await client.beginDeleteCertificate(certificateName);
  const deletedCertificate = await deletePoller.pollUntilDone();
  console.log("Recovery Id: ", deletedCertificate.recoveryId);
  console.log("Deleted Date: ", deletedCertificate.deletedOn);
  console.log("Scheduled Purge Date: ", deletedCertificate.scheduledPurgeDate);
}

main().catch((error) => {
  console.error("An error occurred:", error);
  process.exit(1);
});

Spuštění ukázkové aplikace

Spuštění aplikace:
```
node index.js
```

Metody vytvoření a získání vrátí úplný objekt JSON pro certifikát:

{
  "keyId": undefined,
  "secretId": undefined,
  "name": "<certificate-name>",
    "reuseKey": false,
    "keyCurveName": undefined,
    "exportable": true,
    "issuerName": 'Self',
    "certificateType": undefined,
    "certificateTransparency": undefined
  },
  "properties": {
    "createdOn": 2021-11-29T20:17:45.000Z,
    "updatedOn": 2021-11-29T20:17:45.000Z,
    "expiresOn": 2022-11-29T20:17:45.000Z,
    "id": "https://<key-vault-name>.vault.azure.net/certificates/<certificate-name>/<certificate-version>",
    "enabled": false,
    "notBefore": 2021-11-29T20:07:45.000Z,
    "recoveryLevel": "Recoverable+Purgeable",
    "name": "<certificate-name>",
    "vaultUrl": "https://<key-vault-name>.vault.azure.net",
    "version": "<certificate-version>",
    "tags": undefined,
    "x509Thumbprint": undefined,
    "recoverableDays": 90
  }
}

Vytvořte nový textový soubor a vložte do index.ts souboru následující kód.

import {
  CertificateClient,
  DefaultCertificatePolicy,
  KeyVaultCertificate,
  DeletedCertificate,
  CertificatePolicy,
  KeyVaultCertificateWithPolicy,
} from "@azure/keyvault-certificates";
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 printCertificate(
  certificate: KeyVaultCertificate | KeyVaultCertificateWithPolicy
): void {
  console.log("-- printCertificate ---------------------------");

  // if policy is defined, it's a KeyVaultCertificateWithPolicy
  if ((certificate as KeyVaultCertificateWithPolicy).policy) {
    const { name, properties, policy } =
      certificate as KeyVaultCertificateWithPolicy;
    const { createdOn, updatedOn, expiresOn, vaultUrl, version, tags } =
      properties;
    console.log("Certificate: ", {
      name,
      createdOn,
      updatedOn,
      expiresOn,
      vaultUrl,
      version,
    });
    console.log("Certificate Policy: ", policy);
    printObjectProperties(tags);
    return;
  } else {
    const { name, properties } = certificate;
    const { createdOn, updatedOn, expiresOn, vaultUrl, version, tags } =
      properties;
    console.log("Certificate: ", {
      name,
      createdOn,
      updatedOn,
      expiresOn,
      vaultUrl,
      version,
    });
    printObjectProperties(tags);
  }
}
// Object properties are tags and CertificatePolicy
function printObjectProperties(obj: Record<string, any>): void {
  if (!obj) return;

  console.log("-- printObjectProperties ---------------------------");

  Object.entries(obj).forEach(([key, value]) => {
    if (key === "lifetimeActions") {
      console.log(`${key}: ${JSON.stringify(value)}`);
    } else {
      console.log(`${key}: ${value}`);
    }
  });
}
function printDeletedCertificate(deletedCertificate: DeletedCertificate): void {
  const { recoveryId, deletedOn, scheduledPurgeDate } = deletedCertificate;
  console.log("Deleted Certificate: ", {
    recoveryId,
    deletedOn,
    scheduledPurgeDate,
  });
}
async function main(): Promise<void> {
  // Create a new CertificateClient
  const client = new CertificateClient(keyVaultUrl, credential);

  // Create a unique certificate name
  const uniqueString = new Date().getTime().toString();
  const certificateName = `cert${uniqueString}`;

  // Creating a self-signed certificate
  const createPoller = await client.beginCreateCertificate(
    certificateName,
    DefaultCertificatePolicy
  );

  // Get the created certificate
  const pendingCertificate = await createPoller.getResult();
  printCertificate(pendingCertificate);

  // Get certificate by name
  let certificateWithPolicy = await client.getCertificate(certificateName);
  printCertificate(pendingCertificate);

  // Get certificate by version
  const certificateFromVersion = await client.getCertificateVersion(
    certificateName,
    certificateWithPolicy.properties.version!
  );
  printCertificate(certificateFromVersion);

  // Update properties of the certificate
  const updatedCertificate = await client.updateCertificateProperties(
    certificateName,
    certificateWithPolicy.properties.version!,
    {
      tags: {
        customTag: "my value",
      },
    }
  );
  printCertificate(updatedCertificate);

  // Updating the certificate's policy
  const certificatePolicy = await client.updateCertificatePolicy(
    certificateName,
    {
      issuerName: "Self",
      subject: "cn=MyOtherCert",
    }
  );
  printObjectProperties(certificatePolicy);

  // Get certificate again to see the updated policy
  certificateWithPolicy = await client.getCertificate(certificateName);
  printCertificate(certificateWithPolicy);

  // Delete certificate
  const deletePoller = await client.beginDeleteCertificate(certificateName);
  const deletedCertificate = await deletePoller.pollUntilDone();
  printDeletedCertificate(deletedCertificate);
}

main().catch((error) => {
  console.error("An error occurred:", error);
  process.exit(1);
});

Spuštění ukázkové aplikace

Sestavení aplikace TypeScript:
```
tsc
```
Spuštění aplikace:
```
node index.js
```

Metody vytvoření a získání vrátí úplný objekt JSON pro certifikát:

{
  "keyId": undefined,
  "secretId": undefined,
  "name": "<certificate-name>",
    "reuseKey": false,
    "keyCurveName": undefined,
    "exportable": true,
    "issuerName": 'Self',
    "certificateType": undefined,
    "certificateTransparency": undefined
  },
  "properties": {
    "createdOn": 2021-11-29T20:17:45.000Z,
    "updatedOn": 2021-11-29T20:17:45.000Z,
    "expiresOn": 2022-11-29T20:17:45.000Z,
    "id": "https://<key-vault-name>.vault.azure.net/certificates/<certificate-name>/<certificate-version>",
    "enabled": false,
    "notBefore": 2021-11-29T20:07:45.000Z,
    "recoveryLevel": "Recoverable+Purgeable",
    "name": "<certificate-name>",
    "vaultUrl": "https://<key-vault-name>.vault.azure.net",
    "version": "<certificate-version>",
    "tags": undefined,
    "x509Thumbprint": undefined,
    "recoverableDays": 90
  }
}

Integrace se službou App Configuration

Sada Azure SDK poskytuje pomocnou metodu parseKeyVaultCertificateIdentifier, která parsuje dané ID certifikátu služby Key Vault, což je nezbytné v případě, že použijete odkazy služby App Configuration na Key Vault. Konfigurace aplikace ukládá ID certifikátu služby Key Vault. K analýze ID potřebujete metodu parseKeyVaultCertificateIdentifier , abyste získali název certifikátu. Jakmile budete mít název certifikátu, můžete aktuální certifikát získat pomocí kódu z tohoto rychlého startu.

Další kroky

V tomto rychlém startu jste vytvořili úložiště klíčů, uložili certifikát a získali jej zpět. Další informace o službě Key Vault a její integraci s vašimi aplikacemi najdete v těchto článcích.

Přehled služby Azure Key Vault
Prohlédněte si přehled certifikátů
Nahlédněte do tutoriálu o používaní služby Access Key Vault v aplikaci App Service
Kurz pro přístup ke službě Key Vault z virtuálního počítače
Prohlédni si průvodce vývojářem ve službě Azure Key Vault.
Přehled zabezpečení služby Key Vault
Kontrola osvědčených postupů zabezpečení specifických pro certifikáty

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-05-14

Rychlý start: Klientská knihovna certifikátů služby Azure Key Vault pro JavaScript

Požadavky

Přihlášení k Azure

Vytvoření nové aplikace Node.js

Instalace balíčků služby Key Vault

Udělení přístupu k trezoru klíčů

Nastavení proměnných prostředí

Ověření a vytvoření klienta

Příklad kódu

Nastavení architektury aplikace

Spuštění ukázkové aplikace

Spuštění ukázkové aplikace

Integrace se službou App Configuration

Další kroky

Váš názor

Další materiály