Rozpoczynanie pracy z usługą Azure Blob Storage i typeScript

• .NET
• Java
• JavaScript
• TypeScript
• Python
• Przejdź

W tym artykule pokazano, jak nawiązać połączenie z usługą Azure Blob Storage przy użyciu biblioteki klienta usługi Azure Blob Storage dla języka JavaScript. Po nawiązaniu połączenia kod może działać na kontenerach, obiektach blob i funkcjach usługi Blob Storage.

Kod źródłowy biblioteki źródłowej biblioteki referencyjnej | | interfejsu API pakietu (npm) | Prześlij opinię

Wymagania wstępne

• Subskrypcja platformy Azure — utwórz jedną bezpłatnie
• Konto usługi Azure Storage — tworzenie konta magazynu
• Node.js LTS
• W przypadku aplikacji klienckich (przeglądarki) potrzebne są narzędzia do tworzenia pakietów.

konfigurowanie projektu

1. Otwórz wiersz polecenia i przejdź do folderu projektu. Zmień YOUR-DIRECTORY nazwę folderu na:

   cd YOUR-DIRECTORY
   

2. Jeśli nie masz package.json jeszcze pliku w katalogu, zainicjuj projekt w celu utworzenia pliku:

   npm init -y
   

3. Zainstaluj język TypeScript i bibliotekę klienta usługi Azure Blob Storage dla języka JavaScript z dołączonymi typami TypeScript:

   npm install typescript @azure/storage-blob
   

4. Jeśli chcesz używać połączeń bez hasła przy użyciu identyfikatora Entra firmy Microsoft, zainstaluj bibliotekę klienta tożsamości platformy Azure dla języka JavaScript:

   npm install @azure/identity
   

Autoryzowanie dostępu i nawiązywanie połączenia z usługą Blob Storage

Identyfikator entra firmy Microsoft zapewnia najbezpieczniejsze połączenie, zarządzając tożsamością połączenia (tożsamością zarządzaną). Ta funkcja bez hasła umożliwia tworzenie aplikacji, która nie wymaga żadnych wpisów tajnych (kluczy ani parametry połączenia) przechowywanych w kodzie.

Konfigurowanie dostępu tożsamości do chmury platformy Azure

Aby nawiązać połączenie z platformą Azure bez haseł, musisz skonfigurować tożsamość platformy Azure lub użyć istniejącej tożsamości. Po skonfigurowaniu tożsamości upewnij się, że przypisano odpowiednie role do tożsamości.

Aby autoryzować dostęp bez hasła za pomocą identyfikatora Entra firmy Microsoft, musisz użyć poświadczeń platformy Azure. Jakiego typu poświadczenia potrzebujesz, zależy od tego, gdzie działa aplikacja. Użyj tej tabeli jako przewodnika.

Środowisko	Method
Środowisko programistyczne	Visual Studio Code
Środowisko programistyczne	Jednostka usługi
Aplikacje hostowane na platformie Azure	Konfiguracja aplikacji hostowanych na platformie Azure
Lokalne	Konfiguracja aplikacji lokalnej

Konfigurowanie ról konta magazynu

Zasób magazynu musi mieć co najmniej jedną z następujących ról RBAC platformy Azure przypisanych do zasobu tożsamości, z którym planujesz nawiązać połączenie. Skonfiguruj role usługi Azure Storage dla każdej tożsamości utworzonej w poprzednim kroku: Chmura platformy Azure, programowanie lokalne, środowisko lokalne.

Po zakończeniu instalacji każda tożsamość musi mieć co najmniej jedną z odpowiednich ról:

• Rola dostępu do danych , taka jak:

  • Czytelnik danych obiektu blob usługi Storage
  • Współautor danych w usłudze Blob Storage

• Rola zasobu — taka jak:

  • Czytelnik
  • Współautor

Kompilowanie aplikacji

Podczas kompilowania aplikacji kod będzie współdziałać przede wszystkim z trzema typami zasobów:

• Konto magazynu, które jest unikatową przestrzenią nazw najwyższego poziomu dla danych usługi Azure Storage.
• Kontenery, które organizują dane obiektów blob na koncie magazynu.
• Obiekty blob, które przechowują dane bez struktury, takie jak dane tekstowe i binarne.

Na poniższym diagramie przedstawiono relacje między tymi zasobami.

Każdy typ zasobu jest reprezentowany przez co najmniej jednego skojarzonego klienta języka JavaScript:

Klasa	opis
BlobServiceClient	Reprezentuje punkt końcowy usługi Blob Storage dla konta magazynu.
ContainerClient	Umożliwia manipulowanie kontenerami usługi Azure Storage i ich obiektami blob.
Obiekt blobClient	Umożliwia manipulowanie obiektami blob usługi Azure Storage.

Tworzenie obiektu BlobServiceClient

Obiekt BlobServiceClient jest najwyższym obiektem w zestawie SDK. Ten klient umożliwia manipulowanie usługą, kontenerami i obiektami blob.

Bez hasła

Po skonfigurowaniu ról tożsamości konta usługi Azure Storage i środowiska lokalnego utwórz plik TypeScript zawierający @azure/identity pakiet. Utwórz poświadczenie, takie jak DefaultAzureCredential, aby zaimplementować połączenia bez hasła z usługą Blob Storage. Użyj tego poświadczenia, aby uwierzytelnić się za pomocą obiektu 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);
    }
  });

Pakiet dotenv służy do odczytywania nazwy konta magazynu z .env pliku. Nie należy zaewidencjonować tego pliku w kontroli źródła. Jeśli używasz lokalnej jednostki usługi w ramach konfiguracji DefaultAzureCredential, wszystkie informacje o zabezpieczeniach dla tego poświadczenia również zostaną wprowadzone do .env pliku.

Jeśli planujesz wdrożyć aplikację na serwerach i klientach uruchomionych poza platformą Azure, utwórz jedno z poświadczeń spełniających Twoje potrzeby.

Klucz konta

Utwórz wartość StorageSharedKeyCredential na podstawie nazwy konta magazynu i klucza konta. Następnie przekaż konstruktor klasy StorageSharedKeyCredential do konstruktora klasy BlobServiceClient , aby utworzyć klienta.

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

Pakiet dotenv służy do odczytywania nazwy konta magazynu i klucza z .env pliku. Nie należy zaewidencjonować tego pliku w kontroli źródła.

Aby uzyskać informacje na temat uzyskiwania kluczy konta i wytycznych dotyczących najlepszych rozwiązań dotyczących prawidłowego zarządzania kluczami i ich ochrony, zobacz Zarządzanie kluczami dostępu do konta magazynu.

Token sygnatury dostępu współdzielonego

Utwórz identyfikator URI do zasobu przy użyciu punktu końcowego usługi blob i tokenu SAS. Następnie utwórz obiekt BlobServiceClient za pomocą identyfikatora URI. Token SAS jest serią par nazwa/wartość w ciągu zapytania w formacie, takim jak:

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

W zależności od tego, które narzędzie jest używane do generowania tokenu SYGNATURy dostępu współdzielonego, do tokenu SYGNATURy dostępu współdzielonego może zostać już dodane zapytanie ? .

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

Pakiet dotenv jest używany do odczytywania nazwy konta magazynu i tokenu .env sas z pliku. Nie należy zaewidencjonować tego pliku w kontroli źródła.

Aby wygenerować tokeny SAS i zarządzać nimi, zobacz dowolny z następujących artykułów:

• Udzielanie ograniczonego dostępu do zasobów usługi Azure Storage za pomocą sygnatur dostępu współdzielonego (SAS)

• Tworzenie sygnatury dostępu współdzielonego usługi dla kontenera lub obiektu blob

Tworzenie obiektu ContainerClient

Obiekt ContainerClient można utworzyć z obiektu BlobServiceClient lub bezpośrednio.

Tworzenie obiektu ContainerClient z obiektu BlobServiceClient

Utwórz obiekt ContainerClient z obiektu 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);
    }
  });

Bezpośrednie tworzenie elementu ContainerClient

Bez hasła

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

Klucz konta

// 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 sygnatury dostępu współdzielonego

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

Pakiet dotenv służy do odczytywania nazwy konta magazynu z .env pliku. Nie należy zaewidencjonować tego pliku w kontroli źródła.

Tworzenie obiektu BlobClient

Możesz utworzyć dowolne obiekty BlobClient wymienione poniżej z klasy ContainerClient lub bezpośrednio.

Lista klientów obiektów blob:

• Obiekt blobClient
• BlockBlobClient
• AppendBlobClient
• BlobLeaseClient
• PageBlobClient

Tworzenie obiektu BlobClient z obiektu 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);
    }
  });

Bezpośrednie tworzenie obiektu blobClient

Bez hasła

// 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
}
*/

Klucz konta

// 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 sygnatury dostępu współdzielonego

/**
 * 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>

Pakiet dotenv służy do odczytywania nazwy konta magazynu z .env pliku. Nie należy zaewidencjonować tego pliku w kontroli źródła.

Zobacz też

• Pakiet (npm)
• Dokumentacja interfejsu API
• Kod źródłowy biblioteki
• Prześlij opinię