KeyClient class

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

URL di base dell'insieme di credenziali

vaultUrl: string

Valore della proprietà

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

Il metodo createExternalKey crea una nuova chiave in Azure Key Vault che è supportata da una chiave memorizzata in un sistema di gestione delle chiavi esterno. Se la chiave denominata esiste già, Azure Key Vault crea una nuova versione della chiave. Richiede l'autorizzazione chiavi/creazione.

Il tipo di chiave e la dimensione della chiave non devono essere specificati per le chiavi esterne; il servizio li deriva dalla chiave esterna di riferimento.

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}.managedhsm.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createExternalKey(keyName, { id: "my-external-key-id" });
console.log("result: ", result);

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

function createExternalKey(name: string, externalKey: ExternalKey, options?: CreateKeyOptions): Promise<KeyVaultKey>

Parametri

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

• Un CryptographyClient usando le stesse opzioni, le credenziali e il client HTTP di questo KeyClient

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti

Scarta una chiave simmetrica che in precedenza era avvolta tramite secureWrapKey. L'operazione di unwrap si svolge all'interno di un Trusted Execution Environment (TEE) attestato dal Microsoft attestazione di Azure Service (MAA).

Questa operazione richiede il keys/unwrapKey permesso.

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}.managedhsm.azure.net`;

const client = new KeyClient(url, credential);

const wrapped = await client.secureWrapKey("myKey", "RSA-OAEP-256");
const unwrapped = await client.secureUnwrapKey(
  "myKey",
  wrapped.algorithm,
  wrapped.result,
  "<attestation-target>",
);
console.log(unwrapped.keyID, unwrapped.algorithm, unwrapped.result);

function secureUnwrapKey(name: string, algorithm: SecureKeyWrapAlgorithm, value: Uint8Array, targetAttestationToken: string, options?: SecureUnwrapKeyOptions): Promise<SecureKeyOperationResult>

Parametri

Valori restituiti

Avvolge una chiave AES a 256 bit generata all'interno di un Trusted Execution Environment (TEE) utilizzando una chiave di crittografia della chiave precedentemente memorizzata in Azure Key Vault.

A differenza di wrapKey, la chiave che viene avvolta viene generata dal servizio all'interno di un TEE invece che fornita dal chiamante, il che fornisce ulteriore protezione al materiale simmetrico della chiave.

Questa operazione richiede il keys/wrapKey permesso.

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}.managedhsm.azure.net`;

const client = new KeyClient(url, credential);

const wrapped = await client.secureWrapKey("myKey", "RSA-OAEP-256");
console.log(wrapped.keyID, wrapped.algorithm, wrapped.result);

function secureWrapKey(name: string, algorithm: SecureKeyWrapAlgorithm, options?: SecureWrapKeyOptions): Promise<SecureKeyOperationResult>

Parametri

Valori restituiti

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

Valori restituiti

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

Valori restituiti

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

Valori restituiti