Tworzenie i używanie tokenów SAS konta za pomocą usługi Azure Blob Storage i języka JavaScript

• .NET
• Java
• JavaScript
• Python

W tym artykule przedstawiono sposób tworzenia i używania tokenów SAS konta do korzystania z biblioteki klienta usługi Azure Blob Storage w wersji 12 dla języka JavaScript. Po nawiązaniu połączenia kod może działać na kontenerach, obiektach blob i funkcjach usługi Blob Storage.

Przykładowe fragmenty kodu są dostępne w usłudze GitHub jako pliki Runnable Node.js.

Kod źródłowy biblioteki źródłowej interfejsu API package (npm)Samples | API Reference | Code | (Dokumentacja interfejsu API pakietu (npm) | Prześlij opinię

Tokeny sygnatury dostępu współdzielonego konta

Token SAS konta to jeden typ tokenu SAS na potrzeby delegowania dostępu udostępnianego przez usługę Azure Storage. Token SAS konta zapewnia dostęp do usługi Azure Storage. Token jest tak restrykcyjny, jak definiujesz go podczas tworzenia. Ponieważ każda osoba mająca token może używać go do uzyskiwania dostępu do konta magazynu, należy zdefiniować token z najbardziej restrykcyjnymi uprawnieniami, które nadal zezwalają tokenowi na wykonywanie wymaganych zadań.

Najlepsze rozwiązania dotyczące tworzenia tokenu obejmują ograniczanie uprawnień:

• Usługi: obiekt blob, plik, kolejka, tabela
• Typy zasobów: usługa, kontener lub obiekt
• Uprawnienia, takie jak tworzenie, odczytywanie, zapisywanie, aktualizowanie i usuwanie

Dodawanie wymaganych zależności do aplikacji

Uwzględnij wymagane zależności, aby utworzyć token SAS konta.

const { 
    BlobServiceClient, 
    generateAccountSASQueryParameters, 
    AccountSASPermissions, 
    AccountSASServices,
    AccountSASResourceTypes,
    StorageSharedKeyCredential,
    SASProtocol 
} = require('@azure/storage-blob');
require('dotenv').config()

Pobieranie zmiennych środowiskowych w celu utworzenia poświadczeń klucza współużytkowanego

Użyj nazwy i klucza konta usługi Blob Storage, aby utworzyć wartość StorageSharedKeyCredential. Ten klucz jest wymagany do utworzenia tokenu SYGNATURy dostępu współdzielonego i użycia tokenu SAS.

Utwórz wartość StorageSharedKeyCredential przy użyciu nazwy konta magazynu i klucza konta. Następnie użyj obiektu StorageSharedKeyCredential, aby zainicjować obiekt BlobServiceClient.

const constants = {
    accountName: process.env.AZURE_STORAGE_ACCOUNT_NAME,
    accountKey: process.env.AZURE_STORAGE_ACCOUNT_KEY
};
const sharedKeyCredential = new StorageSharedKeyCredential(
    constants.accountName,
    constants.accountKey
);

Async operation boilerplate

W pozostałych przykładowych fragmentach kodu przyjęto założenie następującego kodu asynchronicznego dla środowiska Node.js.

async function main() {

    const sasToken = await createAccountSas();

    await useSasToken(sasToken);
}

main()
    .then(() => {
        console.log(`done`);
    }).catch((ex) => {
        console.log(`Error: ${ex.message}`)
    });

Tworzenie tokenu SAS

Ponieważ ten token może być używany z obiektami blob, kolejkami, tabelami i plikami, niektóre ustawienia są bardziej szerokie niż tylko opcje obiektów blob.

1. Utwórz obiekt options.

   Zakres możliwości tokenu SAS jest definiowany przez accountSASSignatureValues.

   Użyj następujących funkcji pomocnika udostępnianych przez zestaw SDK, aby utworzyć poprawne typy wartości dla wartości:

   • AccountSASServices.parse("btqf").toString():
     • b: obiekt blob
     • t: tabela
     • q: zapytanie
     • f: plik
   • resourceTypes: AccountSASResourceTypes.parse("sco").toString()
     • s: usługa
     • c: kontener — taki jak kontener obiektów blob, tabela lub kolejka
     • o: object — obiekt blob, wiersz, komunikat
   • permissions: AccountSASPermissions.parse("rwdlacupi")
     • r: odczyt
     • w: zapis
     • d: usuwanie
     • l: lista
     • f: filtr
     • a: dodaj
     • c: create
     • u: aktualizacja
     • t: dostęp do tagów
     • p: proces — taki jak przetwarzanie komunikatów w kolejce
     • i: ustawianie zasad niezmienności

2. Przekaż obiekt do funkcji generateAccountSASQueryParameters wraz z funkcją SharedKeyCredential, aby utworzyć token SAS.

   Przed zwróceniem tokenu SAS należy wstępnie ustawić ogranicznik ciągu zapytania, ?.

   async function createAccountSas() {
   
       const sasOptions = {
   
           services: AccountSASServices.parse("btqf").toString(),          // blobs, tables, queues, files
           resourceTypes: AccountSASResourceTypes.parse("sco").toString(), // service, container, object
           permissions: AccountSASPermissions.parse("rwdlacupi"),          // permissions
           protocol: SASProtocol.Https,
           startsOn: new Date(),
           expiresOn: new Date(new Date().valueOf() + (10 * 60 * 1000)),   // 10 minutes
       };
   
       const sasToken = generateAccountSASQueryParameters(
           sasOptions,
           sharedKeyCredential 
       ).toString();
   
       console.log(`sasToken = '${sasToken}'\n`);
   
       // prepend sasToken with `?`
       return (sasToken[0] === '?') ? sasToken : `?${sasToken}`;
   }
   

3. Zabezpieczanie tokenu SAS do momentu jego użycia.

Używanie usługi Blob Service z tokenem SAS konta

BlobServiceClient

Aby użyć tokenu SAS konta, należy połączyć go z nazwą konta, aby utworzyć identyfikator URI. Przekaż identyfikator URI, aby utworzyć obiekt blobServiceClient. Po utworzeniu obiektu blobServiceClient możesz użyć tego klienta, aby uzyskać dostęp do usługi Blob Service.

// connect-with-sas-token.js
const { BlobServiceClient } = require('@azure/storage-blob');
require('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');

const blobServiceUri = `https://${accountName}.blob.core.windows.net`;

// https://YOUR-RESOURCE-NAME.blob.core.windows.net?YOUR-SAS-TOKEN
const blobServiceClient = new BlobServiceClient(
  `${blobServiceUri}?${sasToken}`,
  null
);

async function main(){
  
  const containerName = 'REPLACE-WITH-EXISTING-CONTAINER-NAME';
  const blobName = 'REPLACE-WITH-EXISTING-BLOB-NAME';

  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
  await blobClient.downloadToFile(fileName);

  console.log(`${fileName} downloaded`);
  
}

main()
  .then(() => console.log(`done`))
  .catch((ex) => console.log(`error: ${ex.message}`));

ContainerClient

// Azure Storage dependency
const {
  ContainerClient
} = require("@azure/storage-blob");

// For development environment - include environment variables
require("dotenv").config();

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

// Container must exist prior to running this script
const containerName = `test`;

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

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

async function main() {
  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()) {
        console.log(`Blob ${i++}: ${blob.name}`);
    }   
    
  } catch (err) {
    console.log(err);
    throw err;
  }
}

main()
  .then(() => console.log(`done`))
  .catch((ex) => console.log(ex.message));

Obiekt blobClient

// Azure Storage dependency
const { BlockBlobClient } = require("@azure/storage-blob");

// For development environment - include environment variables
require("dotenv").config();

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

// Container and blob must exist prior to running this script
// SAS token must have READ permissions on blob that haven't expired
const containerName = `test`;
const blobName = `my-text-file.txt`;

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

// Utility function to convert a Node.js Readable stream into a Buffer
async function streamToBuffer(readableStream) {
  return new Promise((resolve, reject) => {
      const chunks = [];
      readableStream.on('data', (data) => {
          chunks.push(data instanceof Buffer ? data : Buffer.from(data));
      });
      readableStream.on('end', () => {
          resolve(Buffer.concat(chunks));
      });
      readableStream.on('error', reject);
  });
}

async function main(){

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

  // Get blob url
  console.log(`blob.url: ${client.url}`);

  // Download file contents
  const result = await client.download();
  const content = await streamToBuffer(result.readableStreamBody);

  // Get results
  return content.toString();
}

main().then((result) => console.log(result)).catch((ex) => console.log(ex.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.

Zobacz też

• Typy tokenów SAS
• Jak działa sygnatura dostępu współdzielonego
• Dokumentacja interfejsu API
• Kod źródłowy biblioteki
• Prześlij opinię