Vytváření a používání tokenů SAS účtu se službou Azure Blob Storage a JavaScriptem

• .NET
• Java
• JavaScript
• Python

V tomto článku se dozvíte, jak vytvořit a používat tokeny SAS účtu k používání klientské knihovny Azure Blob Storage v12 pro JavaScript. Po připojení může váš kód pracovat s kontejnery, objekty blob a funkcemi služby Blob Storage.

Ukázkové fragmenty kódu jsou k dispozici na GitHubu jako spustitelné soubory Node.js.

Package (npm) | Samples | API reference | Library source code | Give Feedback

Tokeny SAS účtu

Token SAS účtu je jedním typem tokenu SAS pro delegování přístupu, které poskytuje Azure Storage. Token SAS účtu poskytuje přístup ke službě Azure Storage. Token je při vytváření pouze tak omezující, jak ho definujete. Vzhledem k tomu, že ho kdokoli s tímto tokenem může použít pro přístup k vašemu účtu úložiště, měli byste tento token definovat s nejvíce omezujícími oprávněními, která token stále umožňují dokončit požadované úlohy.

Mezi osvědčené postupy pro vytváření tokenů patří omezení oprávnění:

• Služby: objekt blob, soubor, fronta, tabulka
• Typy prostředků: služba, kontejner nebo objekt
• Oprávnění, jako je vytvoření, čtení, zápis, aktualizace a odstranění

Přidání požadovaných závislostí do aplikace

Zahrňte požadované závislosti pro vytvoření tokenu SAS účtu.

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

Získání proměnných prostředí pro vytvoření přihlašovacích údajů sdíleného klíče

Pomocí názvu a klíče účtu služby Blob Storage vytvořte storageSharedKeyCredential. Tento klíč je nutný k vytvoření tokenu SAS a k použití tokenu SAS.

Vytvořte StorageSharedKeyCredential pomocí názvu účtu úložiště a klíče účtu. Potom pomocí StorageSharedKeyCredential inicializujete objekt 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

Zbývající fragmenty vzorového kódu předpokládají následující asynchronní často používaný kód pro Node.js.

async function main() {

    const sasToken = await createAccountSas();

    await useSasToken(sasToken);
}

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

Vytvoření tokenu SAS

Vzhledem k tomu, že tento token lze použít s objekty blob, frontami, tabulkami a soubory, jsou některá nastavení širší než jen možnosti objektů blob.

1. Vytvořte objekt možností.

   Rozsah schopností tokenu SAS je definován accountSASSignatureValues.

   Pomocí následujících pomocných funkcí poskytovaných sadou SDK vytvořte správné typy hodnot pro tyto hodnoty:

   • AccountSASServices.parse("btqf").toString():
     • b: objekt blob
     • t: tabulka
     • q: dotaz
     • f: soubor
   • resourceTypes: AccountSASResourceTypes.parse("sco"). toString()
     • s: služba
     • c: kontejner – například kontejner objektů blob, tabulka nebo fronta
     • o: objekt – objekt blob, řádek, zpráva
   • oprávnění: AccountSASPermissions.parse("rwdlacupi")
     • r: čtení
     • w: write
     • d: odstranění
     • l: list
     • f: filtr
     • a: add
     • c: create
     • u: update
     • t: přístup značek
     • p: proces – například zpracování zpráv ve frontě
     • i: Nastavení zásad neměnnosti

2. Předat objekt generateAccountSASQueryParameters funkce spolu s SharedKeyCredential, vytvořit token SAS.

   Před vrácením tokenu SAS předdělte oddělovač řetězce dotazu . ?

   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. Token SAS zabezpečte, dokud se nepoužije.

Použití služby Blob Service s tokenem SAS účtu

BlobServiceClient

Pokud chcete použít token SAS účtu, musíte ho zkombinovat s názvem účtu a vytvořit identifikátor URI. Předáním identifikátoru URI vytvořte objekt blobServiceClient. Jakmile budete mít objekt blobServiceClient, můžete ho použít pro přístup ke službě 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));

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

Balíček dotenv se používá ke čtení názvu účtu úložiště ze .env souboru. Tento soubor by neměl být vrácen do správy zdrojového kódu.

Viz také

• Typy tokenů SAS
• Jak funguje sdílený přístupový podpis
• Referenční materiály k rozhraní API
• Zdrojový kód knihovny
• Váš názor