Compartir a través de

Biblioteca cliente de claves de Azure Key Vault para JavaScript: versión 4.10.0

Azure Key Vault es un servicio que permite cifrar claves de autenticación, claves de cuenta de almacenamiento, claves de cifrado de datos, archivos .pfx y contraseñas mediante claves protegidas. Si desea obtener más información sobre Azure Key Vault, puede que desee revisar: ¿Qué es Azure Key Vault?

HSM administrado de Azure Key Vault es un servicio en la nube totalmente administrado, de alta disponibilidad, de un solo inquilino y compatible con los estándares que permite proteger las claves criptográficas para las aplicaciones en la nube mediante HSM validados por FIPS 140-2 de nivel 3. Si desea obtener más información sobre HSM administrado de Azure Key Vault, puede que desee revisar: ¿Qué es HSM administrado de Azure Key Vault?

El cliente de la biblioteca de claves de Azure Key Vault admite claves RSA, claves de curva elíptica (EC), así como claves simétricas (oct) al ejecutarse en un HSM administrado, cada una con compatibilidad correspondiente en módulos de seguridad de hardware (HSM). Ofrece operaciones para crear, recuperar, actualizar, eliminar, purgar, realizar copias de seguridad, restaurar y enumerar las claves y sus versiones.

Use la biblioteca cliente para claves de Azure Key Vault en la aplicación de Node.js para:

  • Cree claves mediante la curva elíptica o el cifrado RSA, respaldado opcionalmente por módulos de seguridad de hardware (HSM).
  • Importar, eliminar y actualizar claves.
  • Obtenga una o varias claves y claves eliminadas, con sus atributos.
  • Recupere una clave eliminada y restaure una clave de copia de seguridad.
  • Obtenga las versiones de una clave.

Con el cliente de criptografía disponible en esta biblioteca también tiene acceso a:

  • Cifrado
  • Descifrar
  • de firma
  • Verificar
  • Ajuste de claves
  • Desencapsulado de claves

Nota: Este paquete no se puede usar en el explorador debido a las limitaciones del servicio Azure Key Vault, consulte este documento para obtener instrucciones.

Vínculos clave:

Cómo empezar

Entornos admitidos actualmente

Prerrequisitos

Instalación del paquete

Instalación de la biblioteca cliente de claves de Azure Key Vault mediante npm

npm install @azure/keyvault-keys

Instalación de la biblioteca de identidades

Los clientes de Azure Key Vault se autentican mediante la biblioteca de identidades de Azure. Instálelo también mediante npm

npm install @azure/identity

Configurar TypeScript

Los usuarios de TypeScript deben tener instaladas definiciones de tipo de nodo:

npm install @types/node

También debe habilitar compilerOptions.allowSyntheticDefaultImports en el tsconfig.json. Tenga en cuenta que si ha habilitado compilerOptions.esModuleInterop, allowSyntheticDefaultImports está habilitado de forma predeterminada. Consulte manual de opciones del compilador de TypeScript para obtener más información.

Conceptos clave

  • El cliente de clave es la interfaz principal para interactuar con los métodos de API relacionados con las claves de la API de Azure Key Vault desde una aplicación de JavaScript. Una vez inicializado, proporciona un conjunto básico de métodos que se pueden usar para crear, leer, actualizar y eliminar claves.
  • Una versión de clave es una versión de una clave en Key Vault. Cada vez que un usuario asigna un valor a un nombre de clave único, se crea una nueva versión de de esa clave. La recuperación de una clave por un nombre siempre devolverá el valor más reciente asignado, a menos que se proporcione una versión específica a la consulta.
  • eliminación temporal permite a los almacenes de claves admitir la eliminación y purga como dos pasos independientes, por lo que las claves eliminadas no se pierden inmediatamente. Esto solo sucede si Key Vault tiene de eliminación temporal habilitada.
  • Se puede generar una de copia de seguridad de clave a partir de cualquier clave creada. Estas copias de seguridad se incluyen como datos binarios y solo se pueden usar para regenerar una clave eliminada anteriormente.
  • El cliente de criptografía es una interfaz independiente que interactúa con los métodos de api de claves en la API de Key Vault. Este cliente solo se centra en las operaciones de criptografía que se pueden ejecutar mediante una clave que ya se ha creado en Key Vault. Obtenga más información sobre este cliente en la sección de criptografía de.

Autenticación con Azure Active Directory

El servicio Key Vault se basa en Azure Active Directory para autenticar las solicitudes en sus API. El paquete @azure/identity proporciona una variedad de tipos de credenciales que la aplicación puede usar para hacerlo. El LÉAME para @azure/identity proporciona más detalles y ejemplos para empezar.

Para interactuar con el servicio Azure Key Vault, deberá crear una instancia de la clase KeyClient, una dirección URL del almacén de y un objeto de credencial. Los ejemplos que se muestran en este documento usan un objeto de credencial denominado DefaultAzureCredential, que es adecuado para la mayoría de los escenarios, incluidos los entornos de desarrollo y producción locales. Además, se recomienda usar una identidad administrada para la autenticación en entornos de producción.

Puede encontrar más información sobre las distintas formas de autenticación y sus tipos de credenciales correspondientes en la documentación de Azure Identity.

Este es un ejemplo rápido. En primer lugar, importe DefaultAzureCredential y KeyClient. Una vez importados, podemos conectarse al servicio Key Vault:

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);

Especificación de la versión de la API del servicio Azure Key Vault

De forma predeterminada, este paquete usa la versión más reciente del servicio Azure Key Vault, que es 7.2. Puede cambiar la versión del servicio que se usa estableciendo la opción serviceVersion en el constructor de cliente, como se muestra a continuación:

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.

// Change the Azure Key Vault service API version being used via the `serviceVersion` option
const client = new KeyClient(url, credential, {
  serviceVersion: "7.0", // Or 7.1
});

Ejemplos

En las secciones siguientes se proporcionan fragmentos de código que abarcan algunas de las tareas comunes mediante claves de Azure Key Vault. Los escenarios que se tratan aquí constan de:

Creación de una clave

createKey crea una clave que se almacenará en Azure Key Vault. Si ya existe una clave con el mismo nombre, se crea una nueva versión de la clave.

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);

El segundo parámetro enviado a createKey es el tipo de la clave. El tipo de claves compatibles dependerá de la SKU y de si usa Azure Key Vault o un HSM administrado de Azure. Para obtener una up-tolista de fechas de tipos de clave admitidos, consulte Acerca de las claves

Obtención de una clave

La manera más sencilla de leer las claves del almacén es obtener una clave por nombre. Esto recuperará la versión más reciente de la clave. Opcionalmente, puede obtener una versión diferente de la clave si la especifica como parte de los parámetros opcionales.

getKey recupera un almacén de claves anterior en Key Vault.

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);

Creación y actualización de claves con atributos

Los atributos siguientes también se pueden asignar a cualquier clave de un almacén de claves:

  • tags: cualquier conjunto de valores de clave que se pueden usar para buscar y filtrar claves.
  • keyOps: matriz de las operaciones que esta clave podrá realizar (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
  • enabled: valor booleano que determina si el valor de clave se puede leer o no.
  • notBefore: fecha determinada después de la cual se puede recuperar el valor de clave.
  • expires: fecha determinada después de la cual no se puede recuperar el valor de clave.

Un objeto con estos atributos se puede enviar como el tercer parámetro de createKey, justo después del nombre y el valor de la clave, como se indica a continuación:

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", {
  enabled: false,
});
console.log("result: ", result);

Esto creará una nueva versión de la misma clave, que tendrá los atributos proporcionados más recientes.

Los atributos también se pueden actualizar a una versión de clave existente con updateKeyProperties, como se indica a continuación:

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,
});

Eliminación de una clave

El método beginDeleteKey inicia la eliminación de una clave. Este proceso se producirá en segundo plano en cuanto estén disponibles los recursos necesarios.

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();

Si de eliminación temporal está habilitada para Key Vault, esta operación solo etiquetará la clave como una clave de eliminada. No se puede actualizar una clave eliminada. Solo se pueden leer, recuperar o purgar.

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);

// You can use the deleted key immediately:
const deletedKey = poller.getResult();

// The key is being deleted. Only wait for it if you want to restore it or purge it.
await poller.pollUntilDone();

// You can also get the deleted key this way:
await client.getDeletedKey(keyName);

// Deleted keys can also be recovered or purged:

// recoverDeletedKey also returns a poller, just like beginDeleteKey.
const recoverPoller = await client.beginRecoverDeletedKey(keyName);
await recoverPoller.pollUntilDone();

// And here is how to purge a deleted key
await client.purgeDeletedKey(keyName);

Dado que las claves tardan algún tiempo en eliminarse por completo, beginDeleteKey devuelve un objeto Poller que realiza un seguimiento de la operación de larga duración subyacente según nuestras directrices: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

El sondeo recibido le permitirá obtener la clave eliminada llamando a poller.getResult(). También puede esperar hasta que finalice la eliminación ejecutando llamadas de servicio individuales hasta que se elimine la clave o esperando hasta que se realice el proceso:

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);

// You can use the deleted key immediately:
let deletedKey = poller.getResult();

// Or you can wait until the key finishes being deleted:
deletedKey = await poller.pollUntilDone();
console.log(deletedKey);

Otra manera de esperar hasta que la clave se elimine por completo es realizar llamadas individuales, como se indica a continuación:

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 delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const poller = await client.beginDeleteKey(keyName);

while (!poller.isDone()) {
  await poller.poll();
  await delay(5000);
}

console.log(`The key ${keyName} is fully deleted`);

Configuración de la rotación automática de claves

Con KeyClient, puede configurar la rotación automática de claves para una clave especificando la directiva de rotación. Además, KeyClient proporciona un método para rotar una clave a petición mediante la creación de una nueva versión de la clave especificada.

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);

Iteración de listas de claves

Con KeyClient, puede recuperar e iterar todas las claves de una instancia de Azure Key Vault, así como a través de todas las claves eliminadas y las versiones de una clave específica. Los siguientes métodos de API están disponibles:

  • listPropertiesOfKeys enumerará todas las claves no eliminadas por sus nombres, solo en sus versiones más recientes.
  • listDeletedKeys enumerará todas las claves eliminadas por sus nombres, solo en sus versiones más recientes.
  • listPropertiesOfKeyVersions enumerará todas las versiones de una clave en función de un nombre de clave.

Que se puede usar de la manera siguiente:

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);
}

Todos estos métodos devolverán todos los resultados disponibles a la vez. Para recuperarlos por páginas, agregue .byPage() justo después de invocar el método de API que desea usar, como se indica a continuación:

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 page of client.listPropertiesOfKeys().byPage()) {
  for (const keyProperties of page) {
    console.log("Key properties: ", keyProperties);
  }
}

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

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

Criptografía

Esta biblioteca también ofrece un conjunto de utilidades criptográficas disponibles a través de CryptographyClient. De forma similar a la KeyClient, CryptographyClient se conectará a Azure Key Vault con el conjunto de credenciales proporcionado. Una vez conectado, CryptographyClient puede cifrar, descifrar, firmar, comprobar, ajustar claves y desencapsular claves.

A continuación, podemos conectarse al servicio del almacén de claves del mismo modo que con el KeyClient. Tendremos que copiar algunas configuraciones del almacén de claves a las que nos conectamos a nuestras variables de entorno. Una vez que se encuentren en nuestro entorno, podemos acceder a ellos con el código siguiente:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } 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);

// Create or retrieve a key from the keyvault
const myKey = await client.createKey("MyKey", "RSA");

// Lastly, create our cryptography client and connect to the service
const cryptographyClient = new CryptographyClient(myKey, credential);

Cifrar

encrypt cifrará un mensaje.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } 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 myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey.id, credential);

const encryptResult = await cryptographyClient.encrypt({
  algorithm: "RSA1_5",
  plaintext: Buffer.from("My Message"),
});
console.log("encrypt result: ", encryptResult.result);

Descifrar

decrypt descifrará un mensaje cifrado.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } 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 myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey.id, credential);

const encryptResult = await cryptographyClient.encrypt({
  algorithm: "RSA1_5",
  plaintext: Buffer.from("My Message"),
});
console.log("encrypt result: ", encryptResult.result);

const decryptResult = await cryptographyClient.decrypt({
  algorithm: "RSA1_5",
  ciphertext: encryptResult.result,
});
console.log("decrypt result: ", decryptResult.result.toString());

Signo

sign firmará criptográficamente el resumen (hash) de un mensaje con una firma.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";
import { createHash } from "node:crypto";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

let myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const signatureValue = "MySignature";
const hash = createHash("sha256");

const digest = hash.update(signatureValue).digest();
console.log("digest: ", digest);

const signResult = await cryptographyClient.sign("RS256", digest);
console.log("sign result: ", signResult.result);

Firmar datos

signData firmarán criptográficamente un mensaje con una firma.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } 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 myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const signResult = await cryptographyClient.signData("RS256", Buffer.from("My Message"));
console.log("sign result: ", signResult.result);

Verificar

verify comprobará criptográficamente que el resumen firmado se firmó con la firma especificada.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";
import { createHash } from "node:crypto";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const hash = createHash("sha256");
hash.update("My Message");
const digest = hash.digest();

const signResult = await cryptographyClient.sign("RS256", digest);
console.log("sign result: ", signResult.result);

const verifyResult = await cryptographyClient.verify("RS256", digest, signResult.result);
console.log("verify result: ", verifyResult.result);

Comprobar datos

verifyData comprobará criptográficamente que el mensaje firmado se firmó con la firma especificada.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } 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 myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const buffer = Buffer.from("My Message");

const signResult = await cryptographyClient.signData("RS256", buffer);
console.log("sign result: ", signResult.result);

const verifyResult = await cryptographyClient.verifyData("RS256", buffer, signResult.result);
console.log("verify result: ", verifyResult.result);

Encapsular clave

wrapKey ajustará una clave con una capa de cifrado.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } 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 myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const wrapResult = await cryptographyClient.wrapKey("RSA-OAEP", Buffer.from("My Key"));
console.log("wrap result:", wrapResult.result);

Desencapsular clave

unwrapKey desencapsulará una clave ajustada.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } 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 myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const wrapResult = await cryptographyClient.wrapKey("RSA-OAEP", Buffer.from("My Key"));
console.log("wrap result:", wrapResult.result);

const unwrapResult = await cryptographyClient.unwrapKey("RSA-OAEP", wrapResult.result);
console.log("unwrap result: ", unwrapResult.result);

Solución de problemas

Consulte nuestra guía de solución de problemas de para obtener más información sobre cómo diagnosticar varios escenarios de error.

Habilitar el registro puede ayudar a descubrir información útil sobre errores. Para ver un registro de solicitudes y respuestas HTTP, establezca la variable de entorno AZURE_LOG_LEVEL en info. Como alternativa, el registro se puede habilitar en tiempo de ejecución llamando a setLogLevel en el @azure/logger:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Pasos siguientes

Puede encontrar más ejemplos de código a través de los vínculos siguientes:

Contribución

Si desea contribuir a esta biblioteca, lea la guía de contribución de para obtener más información sobre cómo compilar y probar el código.