Introdução ao TypeScript e Armazenamento de Blobs do Azure

• .NET
• Java
• JavaScript
• TypeScript
• Python

Este artigo mostra como se conectar ao Armazenamento de Blobs do Azure usando a biblioteca cliente do Armazenamento de Blobs do Azure para JavaScript. Após se conectar, seu código pode operar em contêineres, blobs e recursos do serviço de Armazenamento de Blobs.

Pacote (npm) | Referência da API | Código-fonte da biblioteca | Enviar Comentários

Pré-requisitos

• Assinatura do Azure - criar uma gratuitamente
• Conta de armazenamento do Azure – criar uma conta de armazenamento
• Node.js LTS
• Para aplicativos cliente (navegador), você precisa de ferramentas de agrupamento.

Configurar o seu projeto

1. Abra um prompt de comando e mude para a pasta do projeto. Altere YOUR-DIRECTORY para o nome da pasta:

   cd YOUR-DIRECTORY
   

2. Se você ainda não tiver um arquivo package.json no diretório, inicialize o projeto para criar o arquivo:

   npm init -y
   

3. Instale o TypeScript e a biblioteca cliente do Armazenamento de Blobs do Azure para JavaScript com tipos de TypeScript incluídos:

   npm install typescript @azure/storage-blob
   

4. Se você quiser usar conexões sem senha usando o Microsoft Entra ID, instale a biblioteca de clientes da Identidade do Azure para JavaScript:

   npm install @azure/identity
   

Autorizar o acesso e se conectar ao Armazenamento de Blobs

O Microsoft Entra ID fornece a conexão mais segura gerenciando a identidade de conexão (identidade gerenciada). Essa funcionalidade sem senha permite que você desenvolva um aplicativo que não requer nenhum segredo (chaves ou cadeias de conexão) armazenado no código.

Configurar o acesso de identidade à nuvem do Azure

Para se conectar ao Azure sem senhas, você precisa configurar uma identidade do Azure ou usar uma identidade existente. Depois que a identidade for configurada, atribua as funções apropriadas à identidade.

Para autorizar o acesso sem senha com o Microsoft Entra ID, você precisará usar uma credencial do Azure. O tipo de credencial necessário depende do local em que o aplicativo é executado. Use essa tabela como um guia.

Ambiente	Método
Ambiente do Desenvolvedor	Visual Studio Code
Ambiente do Desenvolvedor	Entidade de serviço
Aplicativos hospedados no Azure	Configurar aplicativos hospedados
Local	Configuração do aplicativo local

Funções da conta de armazenamento

Seu recurso de armazenamento precisa ter uma ou mais das funções do Azure RBAC atribuídas ao recurso de identidade com o qual você planeja se conectar. Configure as funções do Armazenamento do Microsoft Azure para cada identidade criada na etapa anterior: nuvem do Azure, desenvolvimento local, local.

Depois de concluir a configuração, cada identidade precisa de pelo menos uma das funções apropriadas:

• Uma função de acesso a dados, como:

  • Leitor de Dados do Blob de Armazenamento
  • Colaborador de dados de blob de armazenamento

• Uma função de recurso, como:

  • Leitor
  • Colaborador

Crie seu aplicativo

Conforme você compila seu aplicativo, seu código interagirá principalmente com três tipos de recursos:

• A conta de armazenamento, que é o namespace exclusivo de nível superior para os dados de Armazenamento do Microsoft Azure.
• Contêineres, que organizam os dados de blob em sua conta de armazenamento.
• Blobs, que armazenam dados não estruturados, como texto e dados binários.

O diagrama a seguir mostra a relação entre esses recursos.

Cada tipo de recurso é representado por um ou mais clientes JavaScript associados:

Classe	Descrição
BlobServiceClient	Representa o ponto de extremidade do Armazenamento de Blob para sua conta de armazenamento.
ContainerClient	Permite manipular os contêineres do Armazenamento do Microsoft Azure e seus blobs.
BlobClient	Permite manipular os blobs do Armazenamento do Microsoft Azure.

Criar um objeto BlobServiceClient

O objeto BlobServiceClient é o principal objeto no SDK. Esse cliente permite que você manipule os serviços, contêineres e blobs.

Sem senha

Depois que suas funções de identidade da conta de armazenamento do Azure e seu ambiente local estiverem configurados, crie um arquivo TypeScript que inclua o pacote @azure/identity. Crie uma credencial, como DefaultAzureCredential, para implementar conexões sem senha com o Armazenamento de Blobs. Use essa credencial para autenticar com um objeto BlobServiceClient.

// connect-with-default-azure-credential.js
// You must set up RBAC for your identity with one of the following roles:
// - Storage Blob Data Reader
// - Storage Blob Data Contributor
import { DefaultAzureCredential } from '@azure/identity';
import { BlobServiceClient } from '@azure/storage-blob';
import * as dotenv from 'dotenv';
dotenv.config();

const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
if (!accountName) throw Error('Azure Storage accountName not found');

const blobServiceClient = new BlobServiceClient(
  `https://${accountName}.blob.core.windows.net`,
  new DefaultAzureCredential()
);

async function main() {
  const containerName = 'my-container';
  const blobName = 'my-blob';

  const timestamp = Date.now();
  const fileName = `my-new-file-${timestamp}.txt`;

  // create container client
  const containerClient = await blobServiceClient.getContainerClient(
    containerName
  );

  // create blob client
  const blobClient = await containerClient.getBlockBlobClient(blobName);

  // download file
  const downloadResult = await blobClient.downloadToFile(fileName);

  if (downloadResult.errorCode) throw Error(downloadResult.errorCode);

  console.log(
    `${fileName} downloaded ${downloadResult.contentType}, isCurrentVersion: ${downloadResult.isCurrentVersion}`
  );
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

O pacote dotenv é usado para ler o nome da conta de armazenamento de um arquivo .env. Esse arquivo não deve ser verificado no controle do código-fonte. Se você usar uma entidade de serviço local como parte da configuração DefaultAzureCredential, qualquer informação de segurança dessa credencial também entrará no arquivo .env.

Se você planeja implantar o aplicativo em servidores e clientes que são executados fora do Azure, crie uma das credenciais que atenda às suas necessidades.

Chave de conta

Crie um StorageSharedKeyCredential do nome da conta de armazenamento e da chave de conta. Em seguida, passe o StorageSharedKeyCredential para o construtor da classe BlobServiceClient para criar um cliente.

// connect-with-account-name-and-key.js
import {
  BlobServiceClient,
  StorageSharedKeyCredential
} from '@azure/storage-blob';
import * as dotenv from 'dotenv';
import path from 'path';
dotenv.config();

const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY as string;
if (!accountName) throw Error('Azure Storage accountName not found');
if (!accountKey) throw Error('Azure Storage accountKey not found');

const sharedKeyCredential = new StorageSharedKeyCredential(
  accountName,
  accountKey
);

const blobServiceClient = new BlobServiceClient(
  `https://${accountName}.blob.core.windows.net`,
  sharedKeyCredential
);

async function main(): Promise<void> {
  const containerName = 'my-container';
  const blobName = 'my-blob';

  const timestamp = Date.now();
  const fileName = path.join(
    __dirname,
    '../files',
    `my-new-file-${timestamp}.txt`
  );

  // create container client
  const containerClient = await blobServiceClient.getContainerClient(
    containerName
  );

  // create blob client
  const blobClient = await containerClient.getBlockBlobClient(blobName);

  // download file
  const downloadResult = await blobClient.downloadToFile(fileName);

  if (downloadResult.errorCode) throw Error(downloadResult.errorCode);

  console.log(
    `${fileName} downloaded, created on ${downloadResult.createdOn}}`
  );
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

O pacote dotenv é usado para ler o nome da conta de armazenamento e chave de um arquivo .env. Esse arquivo não deve ser verificado no controle do código-fonte.

Para obter informações sobre como obter chaves de conta e diretrizes de melhores práticas para gerenciar e proteger corretamente suas chaves, consulte Gerenciar chaves de acesso da conta de armazenamento.

Token SAS

Crie um URI para o recurso usando o ponto de extremidade de serviço de blob e o token SAS. Em seguida, crie um BlobServiceClient com o URI. O token SAS é uma série de pares nome/valor na querystring no formato como:

https://YOUR-RESOURCE-NAME.blob.core.windows.net?YOUR-SAS-TOKEN

Dependendo de qual ferramenta você usa para gerar seu token SAS, a querystring ? já pode ser adicionada ao token SAS.

// connect-with-sas-token.js
import { BlobServiceClient } from '@azure/storage-blob';
import * as dotenv from 'dotenv';
dotenv.config();

const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME;
const sasToken = process.env.AZURE_STORAGE_SAS_TOKEN;
if (!accountName) throw Error('Azure Storage accountName not found');
if (!sasToken) throw Error('Azure Storage accountKey not found');

// https://YOUR-RESOURCE-NAME.blob.core.windows.net?YOUR-SAS-TOKEN
const blobServiceUri = `https://${accountName}.blob.core.windows.net?${sasToken}`;

// SAS tokens do not require an additional credential because
// the token is the credential
const credential = undefined;

const blobServiceClient = new BlobServiceClient(blobServiceUri, credential);

async function main() {
  const containerName = 'my-container';
  const blobName = 'my-blob';

  const timestamp = Date.now();
  const fileName = `my-new-file-${timestamp}.txt`;

  // create container client
  const containerClient = await blobServiceClient.getContainerClient(
    containerName
  );

  // create blob client
  const blobClient = await containerClient.getBlockBlobClient(blobName);

  // download file
  const downloadResult = await blobClient.downloadToFile(fileName);

  if (downloadResult.errorCode) throw Error(downloadResult.errorCode);

  console.log(
    `${fileName} downloaded ${downloadResult.contentType}, isCurrentVersion: ${downloadResult.isCurrentVersion}`
  );
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

O pacote dotenv é usado para ler o nome da conta de armazenamento e o token SAS de um arquivo .env. Esse arquivo não deve ser verificado no controle do código-fonte.

Para gerar e gerenciar tokens SAS, consulte qualquer um destes artigos:

• Conceder acesso limitado aos recursos de Armazenamento do Azure usando as SAS (assinaturas de acesso compartilhado)

• Criar uma SAS de serviço para um contêiner ou blob

Criar um objeto ContainerClient

Você pode criar o objeto ContainerClient do BlobServiceClient ou diretamente.

Criar objeto ContainerClient do BlobServiceClient

Criar objeto ContainerClient do BlobServiceClient.

// Azure Storage dependency
import {
  BlobServiceClient,
  StorageSharedKeyCredential
} from '@azure/storage-blob';

// For development environment - include environment variables from .env
import * as dotenv from 'dotenv';
dotenv.config();

// Azure Storage resource name
const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
if (!accountName) throw Error('Azure Storage accountName not found');

// Azure Storage resource key
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY as string;
if (!accountKey) throw Error('Azure Storage accountKey not found');

// Create credential
const sharedKeyCredential = new StorageSharedKeyCredential(
  accountName,
  accountKey
);

const baseUrl = `https://${accountName}.blob.core.windows.net`;
const containerName = `my-container`;

// Create BlobServiceClient
const blobServiceClient = new BlobServiceClient(
  `${baseUrl}`,
  sharedKeyCredential
);

async function main(): Promise<void> {
  try {
    // Create container client
    const containerClient = await blobServiceClient.getContainerClient(
      containerName
    );

    // do something with containerClient...
    let i = 1;

    // List blobs in container
    for await (const blob of containerClient.listBlobsFlat({
      includeMetadata: true,
      includeSnapshots: false,
      includeTags: true,
      includeVersions: false,
      prefix: ''
    })) {
      console.log(`Blob ${i++}: ${blob.name}`);
    }
  } catch (err) {
    console.log(err);
    throw err;
  }
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

Criar ContainerClient diretamente

Sem senha

// Azure Storage dependency
import { ContainerClient } from '@azure/storage-blob';

// Azure authentication for credential dependency
import { DefaultAzureCredential } from '@azure/identity';

// For development environment - include environment variables from .env
import * as dotenv from 'dotenv';
dotenv.config();

// Azure Storage resource name
const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
if (!accountName) throw Error('Azure Storage accountName not found');

// Azure SDK needs base URL
const baseUrl = `https://${accountName}.blob.core.windows.net`;

// Unique container name
const timeStamp = Date.now();
const containerName = `my-container`;

async function main(): Promise<void> {
  try {
    // create container client from DefaultAzureCredential
    const containerClient = new ContainerClient(
      `${baseUrl}/${containerName}`,
      new DefaultAzureCredential()
    );

    // do something with containerClient...
    let i = 1;

    // List blobs in container
    for await (const blob of containerClient.listBlobsFlat({
      includeMetadata: true,
      includeSnapshots: false,
      includeTags: true,
      includeVersions: false,
      prefix: ''
    })) {
      console.log(`Blob ${i++}: ${blob.name}`);
    }
  } catch (err) {
    console.log(err);
    throw err;
  }
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

Chave de conta

// Azure Storage dependency
import {
  ContainerClient,
  StorageSharedKeyCredential
} from '@azure/storage-blob';

// For development environment - include environment variables from .env
import * as dotenv from 'dotenv';
dotenv.config();

// Azure Storage resource name
const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
if (!accountName) throw Error('Azure Storage accountName not found');

// Azure Storage resource key
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY as string;
if (!accountKey) throw Error('Azure Storage accountKey not found');

const sharedKeyCredential = new StorageSharedKeyCredential(
  accountName,
  accountKey
);

const baseUrl = `https://${accountName}.blob.core.windows.net`;
const containerName = `my-container`;

async function main(): Promise<void> {
  try {
    // create container from ContainerClient
    const containerClient = new ContainerClient(
      `${baseUrl}/${containerName}`,
      sharedKeyCredential
    );

    // do something with containerClient...
    let i = 1;

    // List blobs in container
    for await (const blob of containerClient.listBlobsFlat({
      includeMetadata: true,
      includeSnapshots: false,
      includeTags: true,
      includeVersions: false,
      prefix: ''
    })) {
      console.log(`Blob ${i++}: ${blob.name}`);
    }
  } catch (err) {
    console.log(err);
    throw err;
  }
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

Token SAS

// Azure Storage dependency
import { ContainerClient } from '@azure/storage-blob';

// For development environment - include environment variables
import * as dotenv from 'dotenv';
dotenv.config();

const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
if (!accountName) throw Error('Azure Storage accountName not found');

// Container must exist prior to running this script
const containerName = `my-container`;

// SAS token must have LIST permissions on container that haven't expired
const sasToken = process.env.AZURE_STORAGE_SAS_TOKEN as string;

// Create SAS URL
const sasUrl = `https://${accountName}.blob.core.windows.net/${containerName}?${sasToken}`;

async function main(): Promise<void> {
  try {
    // create container client from SAS token
    const containerClient = new ContainerClient(sasUrl);

    // do something with containerClient...
    let i = 1;

    // List blobs in container
    for await (const blob of containerClient.listBlobsFlat({
      includeMetadata: true,
      includeSnapshots: false,
      includeTags: true,
      includeVersions: false,
      prefix: ''
    })) {
      console.log(`Blob ${i++}: ${blob.name}`);
    }
  } catch (err) {
    console.log(err);
    throw err;
  }
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

O pacote dotenv é usado para ler o nome da conta de armazenamento de um arquivo .env. Esse arquivo não deve ser verificado no controle do código-fonte.

Criar um objeto BlobClient

Você pode criar qualquer um dos objetos BlobClient, listados abaixo, de um ContainerClient ou diretamente.

Lista de clientes blob:

• BlobClient
• BlockBlobClient
• AppendBlobClient
• BlobLeaseClient
• PageBlobClient

Criar objeto BlobClient do ContainerClient

// Azure Storage dependency
import {
  BlobClient,
  BlobDownloadHeaders,
  BlobGetPropertiesHeaders,
  BlobGetPropertiesResponse,
  BlockBlobClient,
  ContainerClient
} from '@azure/storage-blob';

// For development environment - include environment variables from .env
import * as dotenv from 'dotenv';
import { getContainerClientFromDefaultAzureCredential } from './auth-get-client';
dotenv.config();

const containerName = `my-container`;
const containerClient: ContainerClient =
  getContainerClientFromDefaultAzureCredential(containerName);

const blobName = `my-blob`;

async function main(containerClient: ContainerClient): Promise<void> {
  // Create BlobClient object
  const blobClient: BlobClient = containerClient.getBlobClient(blobName);

  // do something with blobClient...
  const properties: BlobGetPropertiesHeaders = await blobClient.getProperties();
  if (properties.errorCode) throw Error(properties.errorCode);

  console.log(`Blob ${blobName} properties:`);

  // get BlockBlobClient from blobClient
  const blockBlobClient: BlockBlobClient = blobClient.getBlockBlobClient();

  // do something with blockBlobClient...
  const downloadResponse: BlobDownloadHeaders = await blockBlobClient.download(
    0
  );
  if (downloadResponse.errorCode) throw Error(downloadResponse.errorCode);
}

main(containerClient)
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

Criar BlobClient diretamente

Sem senha

// Azure Storage dependency
import {
  BlockBlobClient,
  BlockBlobUploadHeaders,
  BlockBlobUploadResponse
} from '@azure/storage-blob';
import { getBlockBlobClientFromDefaultAzureCredential } from './auth-get-client';

// For development environment - include environment variables from .env
import * as dotenv from 'dotenv';
dotenv.config();

// Container must exist prior to running this script
const containerName = `my-container`;

// Random blob name and contents
const timeStamp = Date.now();
const blobName = `${timeStamp}-my-blob.txt`;
const fileContentsAsString = 'Hello there.';

const blockBlobClient: BlockBlobClient =
  getBlockBlobClientFromDefaultAzureCredential(containerName, blobName);

async function main(
  blockBlobClient: BlockBlobClient
): Promise<BlockBlobUploadHeaders> {
  // Get file url - available before contents are uploaded
  console.log(`blob.url: ${blockBlobClient.url}`);

  // Upload file contents
  const result: BlockBlobUploadHeaders = await blockBlobClient.upload(
    fileContentsAsString,
    fileContentsAsString.length
  );

  if (result.errorCode) throw Error(result.errorCode);

  // Get results
  return result;
}

main(blockBlobClient)
  .then((result) => {
    console.log(result);
    console.log(`success`);
  })
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

/*

Response looks like this:

{
  etag: '"0x8DAD247F1F4896E"',
  lastModified: 2022-11-29T20:26:07.000Z,
  contentMD5: <Buffer 9d 6a 29 63 87 20 77 db 67 4a 27 a3 9c 49 2e 61>,
  clientRequestId: 'a07fdd1f-5937-44c7-984f-0699a48a05c0',
  requestId: '3580e726-201e-0045-1a30-0474f6000000',
  version: '2021-04-10',
  date: 2022-11-29T20:26:06.000Z,
  isServerEncrypted: true,
  'content-length': '0',
  server: 'Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0',
  'x-ms-content-crc64': 'BLv7vb1ONT8=',
  body: undefined
}
*/

Chave de conta

// Azure Storage dependency
import {
  BlockBlobClient,
  BlockBlobUploadHeaders,
  BlockBlobUploadResponse,
  StorageSharedKeyCredential
} from '@azure/storage-blob';

// For development environment - include environment variables from .env
import * as dotenv from 'dotenv';
dotenv.config();

// Azure Storage resource name
const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
if (!accountName) throw Error('Azure Storage accountName not found');

// Azure Storage resource key
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY as string;
if (!accountKey) throw Error('Azure Storage accountKey not found');

// Create credential
const sharedKeyCredential: StorageSharedKeyCredential =
  new StorageSharedKeyCredential(accountName, accountKey);

const baseUrl = `https://${accountName}.blob.core.windows.net`;
const containerName = `my-container`;
const blobName = `my-blob`;

const fileContentsAsString = 'Hello there.';

async function main(): Promise<void> {
  try {
    // create blob from BlockBlobClient
    const blockBlobClient = new BlockBlobClient(
      `${baseUrl}/${containerName}/${blobName}`,
      sharedKeyCredential
    );

    // Upload data to the blob
    const blockBlobUploadResponse: BlockBlobUploadHeaders =
      await blockBlobClient.upload(
        fileContentsAsString,
        fileContentsAsString.length
      );
    if (blockBlobUploadResponse.errorCode)
      throw Error(blockBlobUploadResponse.errorCode);
    console.log(`blob ${blockBlobClient.url} created`);
  } catch (err) {
    console.log(err);
    throw err;
  }
}

main()
  .then(() => console.log(`success`))
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });

Token SAS

/**
 * Best practice - use managed identity to avoid keys & connection strings
 * managed identity is implemented with @azure/identity's DefaultAzureCredential
 *
 * The identity that the managed identity chain selects must have the
 * correct roles applied in order to work correctly.
 *
 * For local development: add your personal identity on your resource group
 * az role assignment create --assignee "<your-username>" \
 *   --role "Blob Data Contributor" \
 *   --resource-group "<your-resource-group-name>"
 **/

//const logger = require('@azure/logger');
//logger.setLogLevel('info');

//<Snippet_Dependencies>
import {
  BlobSASPermissions,
  BlobSASSignatureValues,
  BlobServiceClient,
  BlockBlobClient,
  BlockBlobUploadHeaders,
  BlockBlobUploadResponse,
  generateBlobSASQueryParameters,
  SASProtocol,
  SASQueryParameters,
  ServiceGetUserDelegationKeyResponse
} from '@azure/storage-blob';

// used for local environment variables
import * as dotenv from 'dotenv';
dotenv.config();

// Get BlobServiceClient
import { getBlobServiceClientFromDefaultAzureCredential } from './auth-get-client';
const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
const blobServiceClient: BlobServiceClient =
  getBlobServiceClientFromDefaultAzureCredential();

//</Snippet_Dependencies>

//<Snippet_CreateBlobSas>
// Server creates User Delegation SAS Token for blob
async function createBlobSas(
  blobServiceClient: BlobServiceClient,
  blobName: string
): Promise<string> {
  const containerName = 'my-container';

  // Best practice: create time limits
  const TEN_MINUTES = 10 * 60 * 1000;
  const NOW = new Date();

  // Best practice: set start time a little before current time to
  // make sure any clock issues are avoided
  const TEN_MINUTES_BEFORE_NOW = new Date(NOW.valueOf() - TEN_MINUTES);
  const TEN_MINUTES_AFTER_NOW = new Date(NOW.valueOf() + TEN_MINUTES);

  // Best practice: delegation key is time-limited
  // When using a user delegation key, container must already exist
  const userDelegationKey: ServiceGetUserDelegationKeyResponse =
    await blobServiceClient.getUserDelegationKey(
      TEN_MINUTES_BEFORE_NOW,
      TEN_MINUTES_AFTER_NOW
    );

  if (userDelegationKey.errorCode) throw Error(userDelegationKey.errorCode);

  // Need only create/write permission to upload file
  const blobPermissionsForAnonymousUser = 'cw';

  // Best practice: SAS options are time-limited
  const sasOptions: BlobSASSignatureValues = {
    blobName,
    containerName,
    permissions: BlobSASPermissions.parse(blobPermissionsForAnonymousUser),
    protocol: SASProtocol.HttpsAndHttp,
    startsOn: TEN_MINUTES_BEFORE_NOW,
    expiresOn: TEN_MINUTES_AFTER_NOW
  };

  const sasQueryParameters: SASQueryParameters = generateBlobSASQueryParameters(
    sasOptions,
    userDelegationKey,
    accountName
  );

  const sasToken: string = sasQueryParameters.toString();

  return sasToken;
}
//</Snippet_CreateBlobSas>

//<Snippet_UploadToBlob>
// Client or another process uses SAS token to upload content to blob
async function uploadStringToBlob(
  blobName: string,
  sasToken,
  textAsString: string
): Promise<BlockBlobUploadHeaders> {
  // Get environment variables
  const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME as string;
  const containerName = 'my-container';

  // Create Url SAS token as query string with typical `?` delimiter
  const sasUrl = `https://${accountName}.blob.core.windows.net/${containerName}/${blobName}?${sasToken}`;
  console.log(`\nBlobUrl = ${sasUrl}\n`);

  // Create blob client from SAS token url
  const blockBlobClient = new BlockBlobClient(sasUrl);

  // Upload string
  const blockBlobUploadResponse: BlockBlobUploadHeaders =
    await blockBlobClient.upload(textAsString, textAsString.length, undefined);

  if (blockBlobUploadResponse.errorCode)
    throw Error(blockBlobUploadResponse.errorCode);

  return blockBlobUploadResponse;
}
//</Snippet_UploadToBlob>

//<Snippet_Main>
async function main(blobServiceClient: BlobServiceClient) {
  // Create random blob name for text file
  const blobName = `${(0 | (Math.random() * 9e6)).toString(36)}.txt`;

  // Server creates SAS Token
  const userDelegationSasForBlob: string = await createBlobSas(
    blobServiceClient,
    blobName
  );

  // Server hands off SAS Token & blobName to client to
  // Upload content
  const result: BlockBlobUploadHeaders = await uploadStringToBlob(
    blobName,
    userDelegationSasForBlob,
    'Hello Blob World'
  );

  if (result.errorCode) throw Error(result.errorCode);
  console.log(`\n${blobName} uploaded successfully ${result.lastModified}\n`);
}

main(blobServiceClient)
  .then(() => {
    console.log(`success`);
  })
  .catch((err: unknown) => {
    if (err instanceof Error) {
      console.log(err.message);
    }
  });
//</Snippet_Main>

O pacote dotenv é usado para ler o nome da conta de armazenamento de um arquivo .env. Esse arquivo não deve ser verificado no controle do código-fonte.

Confira também

• Pacote (npm)
• Referência de API
• Código-fonte da biblioteca
• Enviar comentários