Condividi tramite

KeyClient class

Pacchetto:
@azure/keyvault-keys

KeyClient fornisce metodi per gestire KeyVaultKey in Azure Key Vault. Il client supporta la creazione, il recupero, l'aggiornamento, l'eliminazione, l'eliminazione, il backup, il ripristino e l'elenco di KeyVaultKeys. Il client supporta anche l'elenco DeletedKey per un'eliminazione temporanea abilitata per Azure Key Vault.

Costruttori

KeyClient(string, TokenCredential, KeyClientOptions)

Crea un'istanza di KeyClient.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

// Build the URL to reach your key vault
const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`; // or `https://${vaultName}.managedhsm.azure.net` for managed HSM.

// Lastly, create our keys client and connect to the service
const client = new KeyClient(url, credential);

Proprietà

vaultUrl

URL di base dell'insieme di credenziali

Metodi

backupKey(string, BackupKeyOptions)

Richiede il download di un backup della chiave specificata nel client. Tutte le versioni della chiave verranno scaricate. Questa operazione richiede l'autorizzazione chiavi/backup.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const backupContents = await client.backupKey(keyName);

Esegue il backup della chiave specificata.
beginDeleteKey(string, BeginDeleteKeyOptions)

L'operazione di eliminazione si applica a qualsiasi chiave archiviata in Azure Key Vault. Le singole versioni di una chiave non possono essere eliminate, ma solo tutte le versioni di una determinata chiave contemporaneamente.

Questa funzione restituisce un poller dell'operazione a esecuzione prolungata che consente di attendere a tempo indeterminato fino a quando la chiave non viene eliminata.

Questa operazione richiede l'autorizzazione chiavi/eliminazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);
await poller.pollUntilDone();

Elimina una chiave da un insieme di credenziali delle chiavi specificato.
beginRecoverDeletedKey(string, BeginRecoverDeletedKeyOptions)

Recupera la chiave eliminata nell'insieme di credenziali specificato. Questa operazione può essere eseguita solo su un insieme di credenziali abilitato per l'eliminazione temporanea.

Questa funzione restituisce un poller dell'operazione a esecuzione prolungata che consente di attendere a tempo indeterminato fino a quando non viene ripristinata la chiave eliminata.

Questa operazione richiede l'autorizzazione chiavi/ripristino.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const deletePoller = await client.beginDeleteKey(keyName);
await deletePoller.pollUntilDone();

const recoverPoller = await client.beginRecoverDeletedKey(keyName);
const recoveredKey = await recoverPoller.pollUntilDone();

Recupera la chiave eliminata alla versione più recente.
createEcKey(string, CreateEcKeyOptions)

Il metodo createEcKey crea una nuova chiave a curva ellittica in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createEcKey(keyName, { curve: "P-256" });
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.
createKey(string, string, CreateKeyOptions)

L'operazione di creazione della chiave può essere usata per creare qualsiasi tipo di chiave in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createKey(keyName, "RSA");
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.
createOctKey(string, CreateOctKeyOptions)

Il metodo createOctKey crea una nuova chiave oct in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createOctKey("MyKey", { hsm: true });
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.
createRsaKey(string, CreateRsaKeyOptions)

Il metodo createRSAKey crea una nuova chiave RSA in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createRsaKey("MyKey", { keySize: 2048 });
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.
getCryptographyClient(string, GetCryptographyClientOptions)

Ottiene un CryptographyClient per la chiave specificata.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

// Get a cryptography client for a given key
const cryptographyClient = client.getCryptographyClient("MyKey");
getDeletedKey(string, GetDeletedKeyOptions)

Il metodo getDeletedKey restituisce la chiave eliminata specificata insieme alle relative proprietà. Questa operazione richiede l'autorizzazione keys/get.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

await client.getDeletedKey(keyName);

Ottiene la chiave eliminata specificata.
getKey(string, GetKeyOptions)

Il metodo getKey ottiene una chiave specificata ed è applicabile a qualsiasi chiave archiviata in Azure Key Vault. Questa operazione richiede l'autorizzazione keys/get.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const latestKey = await client.getKey(keyName);
console.log(`Latest version of the key ${keyName}: `, latestKey);

const specificKey = await client.getKey(keyName, { version: latestKey.properties.version! });
console.log(`The key ${keyName} at the version ${latestKey.properties.version!}: `, specificKey);

Ottenere una chiave specificata da un determinato insieme di credenziali delle chiavi.
getKeyAttestation(string, GetKeyAttestationOptions)

Il metodo getKeyAttestation ottiene una chiave specificata e il relativo BLOB di attestazione ed è applicabile a qualsiasi chiave archiviata nel modulo di protezione hardware gestito di Azure Key Vault. Questa operazione richiede l'autorizzazione keys/get.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT MANAGED HSM NAME>";
const url = `https://${vaultName}.managedhsm.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const latestKey = await client.getKeyAttestation(keyName);
console.log(`Latest version of the key ${keyName}: `, latestKey);

const specificKey = await client.getKeyAttestation(keyName, {
  version: latestKey.properties.version!,
});
console.log(`The key ${keyName} at the version ${latestKey.properties.version!}: `, specificKey);

Ottenere una chiave specificata da un determinato insieme di credenziali delle chiavi.
getKeyRotationPolicy(string, GetKeyRotationPolicyOptions)

Ottiene i criteri di rotazione di una chiave di Key Vault. Per impostazione predefinita, tutte le chiavi hanno un criterio che invierà una notifica di 30 giorni prima della scadenza.

Questa operazione richiede l'autorizzazione keys/get. Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.getKeyRotationPolicy(keyName);
getRandomBytes(number, GetRandomBytesOptions)

Ottiene il numero richiesto di byte contenenti valori casuali da un modulo di protezione hardware gestito. Questa operazione richiede l'autorizzazione managedHsm/rng.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const bytes = await client.getRandomBytes(10);
importKey(string, JsonWebKey, ImportKeyOptions)

L'operazione di importazione della chiave può essere usata per importare qualsiasi tipo di chiave in un insieme di credenziali delle chiavi di Azure. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Questa operazione richiede l'autorizzazione chiavi/importazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const jsonWebKey = {
  kty: "RSA",
  kid: "test-key-123",
  use: "sig",
  alg: "RS256",
  n: new Uint8Array([112, 34, 56, 98, 123, 244, 200, 99]),
  e: new Uint8Array([1, 0, 1]),
  d: new Uint8Array([45, 67, 89, 23, 144, 200, 76, 233]),
  p: new Uint8Array([34, 89, 100, 77, 204, 56, 29, 77]),
  q: new Uint8Array([78, 99, 201, 45, 188, 34, 67, 90]),
  dp: new Uint8Array([23, 45, 78, 56, 200, 144, 32, 67]),
  dq: new Uint8Array([12, 67, 89, 144, 99, 56, 23, 45]),
  qi: new Uint8Array([78, 90, 45, 201, 34, 67, 120, 55]),
};

const result = await client.importKey("MyKey", jsonWebKey);

Importa una chiave creata esternamente, la archivia e restituisce parametri e proprietà chiave al client.
listDeletedKeys(ListDeletedKeysOptions)

Scorre le chiavi eliminate nell'insieme di credenziali. Nella risposta vengono fornite le proprietà e l'identificatore di chiave completi. Non vengono restituiti valori per le chiavi. Questa operazione richiede l'autorizzazione keys/list.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}

Elencare tutte le chiavi nell'insieme di credenziali
listPropertiesOfKeys(ListPropertiesOfKeysOptions)

Scorre la versione più recente di tutte le chiavi nell'insieme di credenziali. Nella risposta vengono fornite le proprietà e l'identificatore di chiave completi. Non vengono restituiti valori per le chiavi. Questa operazione richiede l'autorizzazione keys/list.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}

Elencare tutte le chiavi nell'insieme di credenziali
listPropertiesOfKeyVersions(string, ListPropertiesOfKeyVersionsOptions)

Scorre tutte le versioni della chiave specificata nell'insieme di credenziali. Nella risposta vengono forniti l'identificatore di chiave, le proprietà e i tag completi. Questa operazione richiede l'autorizzazione keys/list.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}
purgeDeletedKey(string, PurgeDeletedKeyOptions)

L'operazione di eliminazione della chiave eliminata rimuove definitivamente la chiave, senza la possibilità di ripristino. Questa operazione può essere abilitata solo in un insieme di credenziali abilitato per l'eliminazione temporanea. Questa operazione richiede l'autorizzazione chiavi/ripulitura.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const deletePoller = await client.beginDeleteKey(keyName);
await deletePoller.pollUntilDone();

await client.purgeDeletedKey(keyName);

Elimina definitivamente la chiave specificata.
releaseKey(string, string, ReleaseKeyOptions)

Rilascia una chiave da un modulo di protezione hardware gestito.

L'operazione della chiave di rilascio è applicabile a tutti i tipi di chiave. L'operazione richiede che la chiave sia contrassegnata come esportabile e l'autorizzazione chiavi/rilascio.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.releaseKey("myKey", "<attestation-target>");
restoreKeyBackup(Uint8Array, RestoreKeyBackupOptions)

Ripristina una chiave di cui è stato eseguito il backup e tutte le relative versioni in un insieme di credenziali. Questa operazione richiede l'autorizzazione chiavi/ripristino.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const backupContents = await client.backupKey(keyName);

const key = await client.restoreKeyBackup(backupContents);

Ripristina una chiave di cui è stato eseguito il backup in un insieme di credenziali.
rotateKey(string, RotateKeyOptions)

Ruota la chiave in base ai criteri chiave generando una nuova versione della chiave. Questa operazione richiede l'autorizzazione chiavi/rotazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

// Set the key's automated rotation policy to rotate the key 30 days before expiry.
const policy = await client.updateKeyRotationPolicy(keyName, {
  lifetimeActions: [
    {
      action: "Rotate",
      timeBeforeExpiry: "P30D",
    },
  ],
  // You may also specify the duration after which any newly rotated key will expire.
  // In this case, any new key versions will expire after 90 days.
  expiresIn: "P90D",
});

// You can get the current key rotation policy of a given key by calling the getKeyRotationPolicy method.
const currentPolicy = await client.getKeyRotationPolicy(keyName);

// Finally, you can rotate a key on-demand by creating a new version of the given key.
const rotatedKey = await client.rotateKey(keyName);
updateKeyProperties(string, string, UpdateKeyPropertiesOptions)

Il metodo updateKeyProperties modifica le proprietà specificate di una chiave archiviata esistente. Le proprietà non specificate nella richiesta vengono lasciate invariate. Impossibile modificare il valore di una chiave stessa. Questa operazione richiede l'autorizzazione chiavi/set.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.createKey(keyName, "RSA");
await client.updateKeyProperties(keyName, result.properties.version, {
  enabled: false,
});

Aggiorna le proprietà associate a una chiave specificata in un determinato insieme di credenziali delle chiavi.
updateKeyProperties(string, UpdateKeyPropertiesOptions)

Il metodo updateKeyProperties modifica le proprietà specificate della versione più recente di una chiave archiviata esistente. Le proprietà non specificate nella richiesta vengono lasciate invariate. Impossibile modificare il valore di una chiave stessa. Questa operazione richiede l'autorizzazione chiavi/set.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.createKey(keyName, "RSA");
await client.updateKeyProperties(keyName, result.properties.version, {
  enabled: false,
});

Aggiorna le proprietà associate a una chiave specificata in un determinato insieme di credenziali delle chiavi.
updateKeyRotationPolicy(string, KeyRotationPolicyProperties, UpdateKeyRotationPolicyOptions)

Aggiorna i criteri di rotazione di una chiave di Key Vault. Questa operazione richiede l'autorizzazione chiavi/aggiornamento.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const myPolicy = await client.getKeyRotationPolicy(keyName);

const setPolicy = await client.updateKeyRotationPolicy(keyName, myPolicy);

Dettagli costruttore

KeyClient(string, TokenCredential, KeyClientOptions)

Crea un'istanza di KeyClient.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

// Build the URL to reach your key vault
const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`; // or `https://${vaultName}.managedhsm.azure.net` for managed HSM.

// Lastly, create our keys client and connect to the service
const client = new KeyClient(url, credential);

new KeyClient(vaultUrl: string, credential: TokenCredential, pipelineOptions?: KeyClientOptions)

Parametri

vaultUrl

string

URL dell'insieme di credenziali delle chiavi. Deve avere questa forma: https://${your-key-vault-name}.vault.azure.net. È necessario verificare che questo URL faccia riferimento a una risorsa del modulo di protezione hardware gestito o a un insieme di credenziali delle chiavi valido. Per informazioni dettagliate, vedere https://aka.ms/azsdk/blog/vault-uri.

credential
TokenCredential

Oggetto che implementa l'interfaccia TokenCredential utilizzata per autenticare le richieste al servizio. Usare il pacchetto @azure/identity per creare credenziali adatte alle proprie esigenze.

pipelineOptions
KeyClientOptions

Opzioni della pipeline usate per configurare le richieste API di Key Vault. Omettere questo parametro per usare la configurazione della pipeline predefinita.

Dettagli proprietà

vaultUrl

URL di base dell'insieme di credenziali

vaultUrl: string

Valore della proprietà

string

Dettagli metodo

backupKey(string, BackupKeyOptions)

Richiede il download di un backup della chiave specificata nel client. Tutte le versioni della chiave verranno scaricate. Questa operazione richiede l'autorizzazione chiavi/backup.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const backupContents = await client.backupKey(keyName);

Esegue il backup della chiave specificata.

function backupKey(name: string, options?: BackupKeyOptions): Promise<undefined | Uint8Array>

Parametri

name

string

Nome della chiave.

options
BackupKeyOptions

Parametri facoltativi.

Restituisce

Promise<undefined | Uint8Array>

beginDeleteKey(string, BeginDeleteKeyOptions)

L'operazione di eliminazione si applica a qualsiasi chiave archiviata in Azure Key Vault. Le singole versioni di una chiave non possono essere eliminate, ma solo tutte le versioni di una determinata chiave contemporaneamente.

Questa funzione restituisce un poller dell'operazione a esecuzione prolungata che consente di attendere a tempo indeterminato fino a quando la chiave non viene eliminata.

Questa operazione richiede l'autorizzazione chiavi/eliminazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);
await poller.pollUntilDone();

Elimina una chiave da un insieme di credenziali delle chiavi specificato.

function beginDeleteKey(name: string, options?: BeginDeleteKeyOptions): Promise<PollerLike<PollOperationState<DeletedKey>, DeletedKey>>

Parametri

name

string

Nome della chiave.

options
BeginDeleteKeyOptions

Parametri facoltativi.

Restituisce

Promise<PollerLike<PollOperationState<DeletedKey>, DeletedKey>>

beginRecoverDeletedKey(string, BeginRecoverDeletedKeyOptions)

Recupera la chiave eliminata nell'insieme di credenziali specificato. Questa operazione può essere eseguita solo su un insieme di credenziali abilitato per l'eliminazione temporanea.

Questa funzione restituisce un poller dell'operazione a esecuzione prolungata che consente di attendere a tempo indeterminato fino a quando non viene ripristinata la chiave eliminata.

Questa operazione richiede l'autorizzazione chiavi/ripristino.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const deletePoller = await client.beginDeleteKey(keyName);
await deletePoller.pollUntilDone();

const recoverPoller = await client.beginRecoverDeletedKey(keyName);
const recoveredKey = await recoverPoller.pollUntilDone();

Recupera la chiave eliminata alla versione più recente.

function beginRecoverDeletedKey(name: string, options?: BeginRecoverDeletedKeyOptions): Promise<PollerLike<PollOperationState<DeletedKey>, DeletedKey>>

Parametri

name

string

Nome della chiave eliminata.

options
BeginRecoverDeletedKeyOptions

Parametri facoltativi.

Restituisce

Promise<PollerLike<PollOperationState<DeletedKey>, DeletedKey>>

createEcKey(string, CreateEcKeyOptions)

Il metodo createEcKey crea una nuova chiave a curva ellittica in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createEcKey(keyName, { curve: "P-256" });
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.

function createEcKey(name: string, options?: CreateEcKeyOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

options
CreateEcKeyOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

createKey(string, string, CreateKeyOptions)

L'operazione di creazione della chiave può essere usata per creare qualsiasi tipo di chiave in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createKey(keyName, "RSA");
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.

function createKey(name: string, keyType: string, options?: CreateKeyOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

keyType

string

Tipo della chiave. Uno dei seguenti: 'EC', 'EC-HSM', 'RSA', 'RSA-HSM', 'oct'.

options
CreateKeyOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

createOctKey(string, CreateOctKeyOptions)

Il metodo createOctKey crea una nuova chiave oct in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createOctKey("MyKey", { hsm: true });
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.

function createOctKey(name: string, options?: CreateOctKeyOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

options
CreateOctKeyOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

createRsaKey(string, CreateRsaKeyOptions)

Il metodo createRSAKey crea una nuova chiave RSA in Azure Key Vault. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createRsaKey("MyKey", { keySize: 2048 });
console.log("result: ", result);

Crea una nuova chiave, la archivia, quindi restituisce i parametri chiave e le proprietà al client.

function createRsaKey(name: string, options?: CreateRsaKeyOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

options
CreateRsaKeyOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

getCryptographyClient(string, GetCryptographyClientOptions)

Ottiene un CryptographyClient per la chiave specificata.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

// Get a cryptography client for a given key
const cryptographyClient = client.getCryptographyClient("MyKey");

function getCryptographyClient(keyName: string, options?: GetCryptographyClientOptions): CryptographyClient

Parametri

keyName

string

options
GetCryptographyClientOptions

Restituisce

CryptographyClient

getDeletedKey(string, GetDeletedKeyOptions)

Il metodo getDeletedKey restituisce la chiave eliminata specificata insieme alle relative proprietà. Questa operazione richiede l'autorizzazione keys/get.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

await client.getDeletedKey(keyName);

Ottiene la chiave eliminata specificata.

function getDeletedKey(name: string, options?: GetDeletedKeyOptions): Promise<DeletedKey>

Parametri

name

string

Nome della chiave.

options
GetDeletedKeyOptions

Parametri facoltativi.

Restituisce

Promise<DeletedKey>

getKey(string, GetKeyOptions)

Il metodo getKey ottiene una chiave specificata ed è applicabile a qualsiasi chiave archiviata in Azure Key Vault. Questa operazione richiede l'autorizzazione keys/get.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const latestKey = await client.getKey(keyName);
console.log(`Latest version of the key ${keyName}: `, latestKey);

const specificKey = await client.getKey(keyName, { version: latestKey.properties.version! });
console.log(`The key ${keyName} at the version ${latestKey.properties.version!}: `, specificKey);

Ottenere una chiave specificata da un determinato insieme di credenziali delle chiavi.

function getKey(name: string, options?: GetKeyOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

options
GetKeyOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

getKeyAttestation(string, GetKeyAttestationOptions)

Il metodo getKeyAttestation ottiene una chiave specificata e il relativo BLOB di attestazione ed è applicabile a qualsiasi chiave archiviata nel modulo di protezione hardware gestito di Azure Key Vault. Questa operazione richiede l'autorizzazione keys/get.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT MANAGED HSM NAME>";
const url = `https://${vaultName}.managedhsm.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const latestKey = await client.getKeyAttestation(keyName);
console.log(`Latest version of the key ${keyName}: `, latestKey);

const specificKey = await client.getKeyAttestation(keyName, {
  version: latestKey.properties.version!,
});
console.log(`The key ${keyName} at the version ${latestKey.properties.version!}: `, specificKey);

Ottenere una chiave specificata da un determinato insieme di credenziali delle chiavi.

function getKeyAttestation(name: string, options?: GetKeyAttestationOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

options
GetKeyAttestationOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

getKeyRotationPolicy(string, GetKeyRotationPolicyOptions)

Ottiene i criteri di rotazione di una chiave di Key Vault. Per impostazione predefinita, tutte le chiavi hanno un criterio che invierà una notifica di 30 giorni prima della scadenza.

Questa operazione richiede l'autorizzazione keys/get. Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.getKeyRotationPolicy(keyName);

function getKeyRotationPolicy(keyName: string, options?: GetKeyRotationPolicyOptions): Promise<KeyRotationPolicy>

Parametri

keyName

string

Nome della chiave.

options
GetKeyRotationPolicyOptions

Parametri facoltativi.

Restituisce

Promise<KeyRotationPolicy>

getRandomBytes(number, GetRandomBytesOptions)

Ottiene il numero richiesto di byte contenenti valori casuali da un modulo di protezione hardware gestito. Questa operazione richiede l'autorizzazione managedHsm/rng.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const bytes = await client.getRandomBytes(10);

function getRandomBytes(count: number, options?: GetRandomBytesOptions): Promise<Uint8Array>

Parametri

count

number

Numero di byte da generare tra 1 e 128 inclusi.

options
GetRandomBytesOptions

Parametri facoltativi.

Restituisce

Promise<Uint8Array>

importKey(string, JsonWebKey, ImportKeyOptions)

L'operazione di importazione della chiave può essere usata per importare qualsiasi tipo di chiave in un insieme di credenziali delle chiavi di Azure. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Questa operazione richiede l'autorizzazione chiavi/importazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const jsonWebKey = {
  kty: "RSA",
  kid: "test-key-123",
  use: "sig",
  alg: "RS256",
  n: new Uint8Array([112, 34, 56, 98, 123, 244, 200, 99]),
  e: new Uint8Array([1, 0, 1]),
  d: new Uint8Array([45, 67, 89, 23, 144, 200, 76, 233]),
  p: new Uint8Array([34, 89, 100, 77, 204, 56, 29, 77]),
  q: new Uint8Array([78, 99, 201, 45, 188, 34, 67, 90]),
  dp: new Uint8Array([23, 45, 78, 56, 200, 144, 32, 67]),
  dq: new Uint8Array([12, 67, 89, 144, 99, 56, 23, 45]),
  qi: new Uint8Array([78, 90, 45, 201, 34, 67, 120, 55]),
};

const result = await client.importKey("MyKey", jsonWebKey);

Importa una chiave creata esternamente, la archivia e restituisce parametri e proprietà chiave al client.

function importKey(name: string, key: JsonWebKey, options?: ImportKeyOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave importata.

key
JsonWebKey

Chiave Web JSON.

options
ImportKeyOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

listDeletedKeys(ListDeletedKeysOptions)

Scorre le chiavi eliminate nell'insieme di credenziali. Nella risposta vengono fornite le proprietà e l'identificatore di chiave completi. Non vengono restituiti valori per le chiavi. Questa operazione richiede l'autorizzazione keys/list.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}

Elencare tutte le chiavi nell'insieme di credenziali

function listDeletedKeys(options?: ListDeletedKeysOptions): PagedAsyncIterableIterator<DeletedKey, DeletedKey[], PageSettings>

Parametri

options
ListDeletedKeysOptions

Parametri facoltativi.

Restituisce

PagedAsyncIterableIterator<DeletedKey, DeletedKey[], PageSettings>

listPropertiesOfKeys(ListPropertiesOfKeysOptions)

Scorre la versione più recente di tutte le chiavi nell'insieme di credenziali. Nella risposta vengono fornite le proprietà e l'identificatore di chiave completi. Non vengono restituiti valori per le chiavi. Questa operazione richiede l'autorizzazione keys/list.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}

Elencare tutte le chiavi nell'insieme di credenziali

function listPropertiesOfKeys(options?: ListPropertiesOfKeysOptions): PagedAsyncIterableIterator<KeyProperties, KeyProperties[], PageSettings>

Parametri

options
ListPropertiesOfKeysOptions

Parametri facoltativi.

Restituisce

PagedAsyncIterableIterator<KeyProperties, KeyProperties[], PageSettings>

listPropertiesOfKeyVersions(string, ListPropertiesOfKeyVersionsOptions)

Scorre tutte le versioni della chiave specificata nell'insieme di credenziali. Nella risposta vengono forniti l'identificatore di chiave, le proprietà e i tag completi. Questa operazione richiede l'autorizzazione keys/list.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}

function listPropertiesOfKeyVersions(name: string, options?: ListPropertiesOfKeyVersionsOptions): PagedAsyncIterableIterator<KeyProperties, KeyProperties[], PageSettings>

Parametri

name

string

Nome della chiave per cui recuperare le versioni

options
ListPropertiesOfKeyVersionsOptions

Parametri facoltativi.

Restituisce

PagedAsyncIterableIterator<KeyProperties, KeyProperties[], PageSettings>

purgeDeletedKey(string, PurgeDeletedKeyOptions)

L'operazione di eliminazione della chiave eliminata rimuove definitivamente la chiave, senza la possibilità di ripristino. Questa operazione può essere abilitata solo in un insieme di credenziali abilitato per l'eliminazione temporanea. Questa operazione richiede l'autorizzazione chiavi/ripulitura.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const deletePoller = await client.beginDeleteKey(keyName);
await deletePoller.pollUntilDone();

await client.purgeDeletedKey(keyName);

Elimina definitivamente la chiave specificata.

function purgeDeletedKey(name: string, options?: PurgeDeletedKeyOptions): Promise<void>

Parametri

name

string

Nome della chiave.

options
PurgeDeletedKeyOptions

Parametri facoltativi.

Restituisce

Promise<void>

releaseKey(string, string, ReleaseKeyOptions)

Rilascia una chiave da un modulo di protezione hardware gestito.

L'operazione della chiave di rilascio è applicabile a tutti i tipi di chiave. L'operazione richiede che la chiave sia contrassegnata come esportabile e l'autorizzazione chiavi/rilascio.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.releaseKey("myKey", "<attestation-target>");

function releaseKey(name: string, targetAttestationToken: string, options?: ReleaseKeyOptions): Promise<ReleaseKeyResult>

Parametri

name

string

Nome della chiave.

targetAttestationToken

string

Asserzione di attestazione per la destinazione della versione della chiave.

options
ReleaseKeyOptions

Parametri facoltativi.

Restituisce

Promise<ReleaseKeyResult>

restoreKeyBackup(Uint8Array, RestoreKeyBackupOptions)

Ripristina una chiave di cui è stato eseguito il backup e tutte le relative versioni in un insieme di credenziali. Questa operazione richiede l'autorizzazione chiavi/ripristino.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const backupContents = await client.backupKey(keyName);

const key = await client.restoreKeyBackup(backupContents);

Ripristina una chiave di cui è stato eseguito il backup in un insieme di credenziali.

function restoreKeyBackup(backup: Uint8Array, options?: RestoreKeyBackupOptions): Promise<KeyVaultKey>

Parametri

backup

Uint8Array

BLOB di backup associato a un bundle di chiavi.

options
RestoreKeyBackupOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

rotateKey(string, RotateKeyOptions)

Ruota la chiave in base ai criteri chiave generando una nuova versione della chiave. Questa operazione richiede l'autorizzazione chiavi/rotazione.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

// Set the key's automated rotation policy to rotate the key 30 days before expiry.
const policy = await client.updateKeyRotationPolicy(keyName, {
  lifetimeActions: [
    {
      action: "Rotate",
      timeBeforeExpiry: "P30D",
    },
  ],
  // You may also specify the duration after which any newly rotated key will expire.
  // In this case, any new key versions will expire after 90 days.
  expiresIn: "P90D",
});

// You can get the current key rotation policy of a given key by calling the getKeyRotationPolicy method.
const currentPolicy = await client.getKeyRotationPolicy(keyName);

// Finally, you can rotate a key on-demand by creating a new version of the given key.
const rotatedKey = await client.rotateKey(keyName);

function rotateKey(name: string, options?: RotateKeyOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave da ruotare.

options
RotateKeyOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

updateKeyProperties(string, string, UpdateKeyPropertiesOptions)

Il metodo updateKeyProperties modifica le proprietà specificate di una chiave archiviata esistente. Le proprietà non specificate nella richiesta vengono lasciate invariate. Impossibile modificare il valore di una chiave stessa. Questa operazione richiede l'autorizzazione chiavi/set.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.createKey(keyName, "RSA");
await client.updateKeyProperties(keyName, result.properties.version, {
  enabled: false,
});

Aggiorna le proprietà associate a una chiave specificata in un determinato insieme di credenziali delle chiavi.

function updateKeyProperties(name: string, keyVersion: string, options?: UpdateKeyPropertiesOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

keyVersion

string

Versione della chiave.

options
UpdateKeyPropertiesOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

updateKeyProperties(string, UpdateKeyPropertiesOptions)

Il metodo updateKeyProperties modifica le proprietà specificate della versione più recente di una chiave archiviata esistente. Le proprietà non specificate nella richiesta vengono lasciate invariate. Impossibile modificare il valore di una chiave stessa. Questa operazione richiede l'autorizzazione chiavi/set.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.createKey(keyName, "RSA");
await client.updateKeyProperties(keyName, result.properties.version, {
  enabled: false,
});

Aggiorna le proprietà associate a una chiave specificata in un determinato insieme di credenziali delle chiavi.

function updateKeyProperties(name: string, options?: UpdateKeyPropertiesOptions): Promise<KeyVaultKey>

Parametri

name

string

Nome della chiave.

options
UpdateKeyPropertiesOptions

Parametri facoltativi.

Restituisce

Promise<KeyVaultKey>

updateKeyRotationPolicy(string, KeyRotationPolicyProperties, UpdateKeyRotationPolicyOptions)

Aggiorna i criteri di rotazione di una chiave di Key Vault. Questa operazione richiede l'autorizzazione chiavi/aggiornamento.

Esempio di utilizzo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const myPolicy = await client.getKeyRotationPolicy(keyName);

const setPolicy = await client.updateKeyRotationPolicy(keyName, myPolicy);

function updateKeyRotationPolicy(keyName: string, policy: KeyRotationPolicyProperties, options?: UpdateKeyRotationPolicyOptions): Promise<KeyRotationPolicy>

Parametri

keyName

string

Nome della chiave.

policy
KeyRotationPolicyProperties
options
UpdateKeyRotationPolicyOptions

Parametri facoltativi.

Restituisce

Promise<KeyRotationPolicy>