Az Azure Blob Storage és a TypeScript használatának első lépései

• .NET
• Java
• JavaScript
• TypeScript
• Python

Ez a cikk bemutatja, hogyan csatlakozhat az Azure Blob Storage-hoz az Azure Blob Storage JavaScripthez készült ügyfélkódtárával. A csatlakozás után a kód a Blob Storage szolgáltatás tárolóira, blobokra és funkcióira is képes.

Csomag (npm) | API-referencia | kódtár forráskódja | Visszajelzés küldése

Előfeltételek

• Azure-előfizetés – hozzon létre egyet ingyenesen
• Azure Storage-fiók – tárfiók létrehozása
• Node.js LTS
• Az ügyfélalkalmazásokhoz csomagküldő eszközökre van szükség.

A projekt beállítása

1. Nyisson meg egy parancssort, és váltson a projektmappára. Módosítsa YOUR-DIRECTORY a mappa nevét:

   cd YOUR-DIRECTORY
   

2. Ha még nem rendelkezik fájllal package.json a címtárban, inicializálja a projektet a fájl létrehozásához:

   npm init -y
   

3. Telepítse a TypeScriptet és az Azure Blob Storage JavaScript-ügyfélkódtárát a TypeScript-típusok közé:

   npm install typescript @azure/storage-blob
   

4. Ha jelszó nélküli kapcsolatokat szeretne használni a Microsoft Entra ID használatával, telepítse az Azure Identity JavaScript-ügyfélkódtárát:

   npm install @azure/identity
   

Hozzáférés engedélyezése és csatlakozás a Blob Storage-hoz

A Microsoft Entra ID biztosítja a legbiztonságosabb kapcsolatot a kapcsolati identitás (felügyelt identitás) kezelésével. Ez a jelszó nélküli funkció lehetővé teszi olyan alkalmazás fejlesztését, amely nem igényel titkos kulcsokat (kulcsokat vagy kapcsolati sztring) a kódban.

Identitáshozzáférés beállítása az Azure-felhőhöz

Ha jelszó nélkül szeretne csatlakozni az Azure-hoz, be kell állítania egy Azure-identitást, vagy egy meglévő identitást kell használnia. Az identitás beállítása után mindenképpen rendelje hozzá a megfelelő szerepköröket az identitáshoz.

A Jelszó nélküli hozzáférés Microsoft Entra-azonosítóval való engedélyezéséhez Azure-hitelesítő adatokat kell használnia. A szükséges hitelesítő adatok típusa attól függ, hogy az alkalmazás hol fut. Használja ezt a táblázatot útmutatóként.

Environment	Method
Fejlesztői környezet	Visual Studio Code
Fejlesztői környezet	Egyszerű szolgáltatás
Azure-ban üzemeltetett alkalmazások	Az Azure által üzemeltetett alkalmazások beállítása
Helyszíni	Helyszíni alkalmazás beállítása

Tárfiók-szerepkörök beállítása

A tárolási erőforrásnak az alábbi Azure RBAC-szerepkörök közül legalább egynek hozzá kell rendelnie ahhoz az identitáserőforráshoz, amelyhez csatlakozni szeretne. Állítsa be az Azure Storage-szerepköröket az előző lépésben létrehozott összes identitáshoz: Azure-felhő, helyi fejlesztés, helyszíni.

A beállítás befejezése után minden identitásnak szüksége van legalább egy megfelelő szerepkörre:

• Adatelérési szerepkör – például:

  • Storage-blobadatok olvasója
  • Storage blobadat-közreműködő

• Erőforrás-szerepkör – például:

  • Olvasó
  • Közreműködő

Az alkalmazás összeállítása

Az alkalmazás létrehozásakor a kód elsősorban három erőforrástípussal fog működni:

• A tárfiók, amely az Azure Storage-adatok egyedi legfelső szintű névtere.
• Tárolók, amelyek a blobadatokat a tárfiókban rendezik.
• Blobok, amelyek strukturálatlan adatokat, például szöveges és bináris adatokat tárolnak.

Az alábbi ábra az ezen erőforrások közötti kapcsolatot mutatja be.

Minden erőforrástípust egy vagy több társított JavaScript-ügyfél jelöl:

Osztály	Leírás
BlobServiceClient	A tárfiók Blob Storage-végpontját jelöli.
ContainerClient	Lehetővé teszi az Azure Storage-tárolók és azok blobok manipulálására.
BlobClient	Lehetővé teszi az Azure Storage-blobok manipulálása.

BlobServiceClient-objektum létrehozása

A BlobServiceClient objektum az SDK legfelső objektuma. Ez az ügyfél lehetővé teszi a szolgáltatás, a tárolók és a blobok manipulálására.

Jelszó nélküli

Miután beállította az Azure Storage-fiók identitásszerepköreit és a helyi környezetet, hozzon létre egy TypeScript-fájlt, amely tartalmazza a @azure/identity csomagot. Hozzon létre egy hitelesítő adatot, például a DefaultAzureCredentialt a Blob Storage jelszó nélküli kapcsolatainak implementálásához. Ezzel a hitelesítő adatokkal hitelesítheti magát egy BlobServiceClient objektummal.

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

A dotenv csomag segítségével beolvassa a tárfiók nevét egy .env fájlból. Ezt a fájlt nem szabad beadni a forrásvezérlőbe. Ha a DefaultAzureCredential beállítás részeként helyi szolgáltatásnevet használ, a hitelesítő adatok biztonsági adatai is bekerülnek a .env fájlba.

Ha az alkalmazást az Azure-on kívül futó kiszolgálókon és ügyfeleken szeretné üzembe helyezni, hozzon létre egy olyan hitelesítő adatot , amely megfelel az igényeinek.

Fiókkulcs

Hozzon létre egy StorageSharedKeyCredential azonosítót a tárfiók nevéből és a fiókkulcsból. Ezután adja át a StorageSharedKeyCredential parancsot a BlobServiceClient osztálykonstruktornak egy ügyfél létrehozásához.

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

A dotenv csomag a tárfiók nevét és kulcsát egy fájlból .env olvassa be. Ezt a fájlt nem szabad beadni a forrásvezérlőbe.

A fiókkulcsok beszerzéséről és a kulcsok megfelelő kezelésére és védelmére vonatkozó ajánlott eljárásokról további információt a tárfiók hozzáférési kulcsainak kezelése című témakörben talál.

SAS-jogkivonat

Hozzon létre egy Uri-t az erőforráshoz a blobszolgáltatás végpontja és az SAS-jogkivonat használatával. Ezután hozzon létre egy BlobServiceClientet az Uri-val. Az SAS-jogkivonat név-érték párok sorozata a lekérdezésláncban a következő formátumban:

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

Attól függően, hogy melyik eszközt használja az SAS-jogkivonat létrehozásához, előfordulhat, hogy a lekérdezés ? már hozzáadható az SAS-jogkivonathoz.

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

A dotenv csomag a tárfiók nevének és sas-jogkivonatának beolvasására szolgál egy .env fájlból. Ezt a fájlt nem szabad beadni a forrásvezérlőbe.

SAS-jogkivonatok létrehozásához és kezeléséhez tekintse meg az alábbi cikkeket:

• Korlátozott hozzáférés engedélyezése az Azure Storage-erőforrásokhoz közös hozzáférésű jogosultságkódokkal

• Szolgáltatás SAS létrehozása tárolóhoz vagy blobhoz

ContainerClient-objektum létrehozása

A ContainerClient objektumot a BlobServiceClientből vagy közvetlenül is létrehozhatja.

ContainerClient-objektum létrehozása a BlobServiceClientből

Hozza létre a ContainerClient objektumot a BlobServiceClientből.

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

ContainerClient létrehozása közvetlenül

Jelszó nélküli

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

Fiókkulcs

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

SAS-jogkivonat

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

A dotenv csomag segítségével beolvassa a tárfiók nevét egy .env fájlból. Ezt a fájlt nem szabad beadni a forrásvezérlőbe.

BlobClient-objektum létrehozása

Az alábbiakban felsorolt BlobClient-objektumok bármelyikét létrehozhatja egy ContainerClientből vagy közvetlenül.

Blobügyfelek listája:

• BlobClient
• BlockBlobClient
• AppendBlobClient
• BlobLeaseClient
• PageBlobClient

BlobClient-objektum létrehozása a ContainerClientből

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

BlobClient létrehozása közvetlenül

Jelszó nélküli

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

Fiókkulcs

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

SAS-jogkivonat

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

A dotenv csomag segítségével beolvassa a tárfiók nevét egy .env fájlból. Ezt a fájlt nem szabad beadni a forrásvezérlőbe.

Kapcsolódó információk

• Csomag (npm)
• API-referencia
• Kódtár forráskódja
• Visszajelzés küldése