Aan de slag met Azure Blob Storage en JavaScript

• .NET
• Java
• JavaScript
• TypeScript
• Python

In dit artikel leest u hoe u verbinding maakt met Azure Blob Storage met behulp van de Azure Blob Storage-clientbibliotheek v12 voor JavaScript. Zodra de code is verbonden, kan uw code worden uitgevoerd op containers, blobs en functies van de Blob Storage-service.

De voorbeeldcodefragmenten zijn beschikbaar in GitHub als runnable Node.js-bestanden.

Broncodevoorbeelden van API-referentiepakket | (npm) | Library | geven feedback |

Vereisten

• Azure-abonnement: u kunt een gratis abonnement nemen
• Azure Storage-account: maak een opslagaccount
• Node.js LTS
• Voor clienttoepassingen (browsertoepassingen) hebt u bundelprogramma's nodig.

Uw project instellen

1. Open een opdrachtprompt en ga naar de projectmap. Ga naar YOUR-DIRECTORY de mapnaam:

   cd YOUR-DIRECTORY
   

2. Als u nog geen bestand in uw map hebt package.json , initialiseert u het project om het bestand te maken:

   npm init -y
   

3. Installeer de Azure Blob Storage-clientbibliotheek voor JavaScript:

   npm install @azure/storage-blob
   

4. Als u wachtwoordloze verbindingen wilt gebruiken met behulp van Microsoft Entra ID, installeert u de Azure Identity-clientbibliotheek voor JavaScript:

   npm install @azure/identity
   

Toegang autoriseren en verbinding maken met Blob Storage

Microsoft Entra ID biedt de veiligste verbinding door de verbindingsidentiteit (beheerde identiteit) te beheren. Met deze functionaliteit zonder wachtwoord kunt u een toepassing ontwikkelen waarvoor geen geheimen (sleutels of verbindingsreeks s) zijn vereist die zijn opgeslagen in de code.

Identiteitstoegang tot de Azure-cloud instellen

Als u zonder wachtwoorden verbinding wilt maken met Azure, moet u een Azure-identiteit instellen of een bestaande identiteit gebruiken. Zodra de identiteit is ingesteld, moet u de juiste rollen toewijzen aan de identiteit.

Als u toegang zonder wachtwoord wilt autoriseren met Microsoft Entra ID, moet u een Azure-referentie gebruiken. Welk type referentie u nodig hebt, is afhankelijk van waar uw toepassing wordt uitgevoerd. Gebruik deze tabel als richtlijn.

Omgeving	Methode
Ontwikkelomgeving	Visual Studio Code
Ontwikkelomgeving	Service/principal
Apps die in Azure worden gehost	Installatie van door Azure gehoste apps
On-premises	Installatie van on-premises apps

Opslagaccountrollen instellen

Voor uw opslagresource moeten een of meer van de volgende Azure RBAC-rollen zijn toegewezen aan de identiteitsresource waarmee u verbinding wilt maken. Stel de Azure Storage-rollen in voor elke identiteit die u in de vorige stap hebt gemaakt: Azure-cloud, lokale ontwikkeling, on-premises.

Nadat u de installatie hebt voltooid, heeft elke identiteit ten minste één van de juiste rollen nodig:

• Een rol voor gegevenstoegang , zoals:

  • Lezer voor opslagblobgegevens
  • Inzender voor Storage Blob-gegevens

• Een resourcerol , zoals:

  • Lezer
  • Inzender

Uw toepassing bouwen

Tijdens het bouwen van uw toepassing werkt uw code voornamelijk met drie typen resources:

• Het opslagaccount, de unieke naamruimte op het hoogste niveau voor uw Azure Storage-gegevens.
• Containers, die de blobgegevens in uw opslagaccount organiseren.
• Blobs, die ongestructureerde gegevens opslaan, zoals tekst en binaire gegevens.

Het volgende diagram geeft de relatie tussen deze resources weer.

Elk type resource wordt vertegenwoordigd door een of meer gekoppelde JavaScript-clients:

Klasse	Omschrijving
BlobServiceClient	Vertegenwoordigt het Blob Storage-eindpunt voor uw opslagaccount.
ContainerClient	Hiermee kunt u Azure Storage-containers en hun blobs bewerken.
BlobClient	Hiermee kunt u Azure Storage-blobs bewerken.

Een BlobServiceClient-object maken

Het BlobServiceClient-object is het bovenste object in de SDK. Met deze client kunt u de service, containers en blobs bewerken.

Wachtwoordloos

Zodra uw Azure Storage-accountidentiteitsrollen en uw lokale omgeving zijn ingesteld, maakt u een JavaScript-bestand dat het @azure/identity pakket bevat. Maak een referentie, zoals defaultAzureCredential, om wachtwoordloze verbindingen met Blob Storage te implementeren. Gebruik deze referentie om te verifiëren met een BlobServiceClient-object .

// connect-with-default-azure-credential.js
const { BlobServiceClient } = require('@azure/storage-blob');
const { DefaultAzureCredential } = require('@azure/identity');
require('dotenv').config()

const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME;
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 = '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}`));

Het dotenv pakket wordt gebruikt om de naam van uw opslagaccount uit een .env bestand te lezen. Dit bestand mag niet worden ingecheckt bij broncodebeheer. Als u een lokale service-principal gebruikt als onderdeel van uw DefaultAzureCredential-configuratie, gaan alle beveiligingsgegevens voor die referentie ook naar het .env bestand.

Als u van plan bent om de toepassing te implementeren op servers en clients die buiten Azure worden uitgevoerd, maakt u een van de referenties die aan uw behoeften voldoen.

Accountsleutel

Maak een StorageSharedKeyCredential op basis van de naam en accountsleutel van het opslagaccount. Geef vervolgens de StorageSharedKeyCredential door aan de blobServiceClient-klasseconstructor om een client te maken.

// connect-with-account-name-and-key.js
const { BlobServiceClient, StorageSharedKeyCredential } = require('@azure/storage-blob');
require('dotenv').config()

const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME;
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY;
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() {

  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(ex.message));

Het dotenv pakket wordt gebruikt om de naam en sleutel van uw opslagaccount uit een .env bestand te lezen. Dit bestand mag niet worden ingecheckt bij broncodebeheer.

Zie Toegangssleutels voor opslagaccounts beheren voor informatie over het verkrijgen van accountsleutels en aanbevolen procedures voor het correct beheren en beveiligen van uw sleutels.

SAS-token

Maak een URI voor uw resource met behulp van het blob-service-eindpunt en het SAS-token. Maak vervolgens een BlobServiceClient met de Uri. Het SAS-token is een reeks naam-/waardeparen in de querytekenreeks in de indeling, zoals:

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

Afhankelijk van het hulpprogramma dat u gebruikt om uw SAS-token te genereren, kan de querystring ? al worden toegevoegd aan het SAS-token.

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

Het dotenv pakket wordt gebruikt om de naam van uw opslagaccount en sas-token uit een .env bestand te lezen. Dit bestand mag niet worden ingecheckt bij broncodebeheer.

Als u SAS-tokens wilt genereren en beheren, raadpleegt u een van de volgende artikelen:

• Beperkte toegang verlenen tot Azure Storage-resources door middel van een SAS

• Een service-SAS maken voor een container of blob

Een ContainerClient-object maken

U kunt het ContainerClient-object maken vanuit de BlobServiceClient of rechtstreeks.

ContainerClient-object maken vanuit BlobServiceClient

Maak het ContainerClient-object op basis van de BlobServiceClient.

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

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

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

// Azure Storage resource key
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY;
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() {
  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()) {
      console.log(`Blob ${i++}: ${blob.name}`);
    }
  } catch (err) {
    console.log(err);
    throw err;
  }
}

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

ContainerClient rechtstreeks maken

Wachtwoordloos

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

// Azure authentication for credential dependency
const { DefaultAzureCredential } = require('@azure/identity');

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

// Azure Storage resource name
const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME;
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 = `test`;

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


  } catch (err) {
    console.log(err);
    throw err;
  }
}

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

Accountsleutel

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

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

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

// Azure Storage resource key
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY;
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() {
  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()) {
        console.log(`Blob ${i++}: ${blob.name}`);
    }
    

  } catch (err) {
    console.log(err);
    throw err;
  }
}

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

SAS-token

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

Het dotenv pakket wordt gebruikt om de naam van uw opslagaccount uit een .env bestand te lezen. Dit bestand mag niet worden ingecheckt bij broncodebeheer.

Een BlobClient-object maken

U kunt een van de Onderstaande BlobClient-objecten maken, hetzij vanuit een ContainerClient, hetzij rechtstreeks.

Lijst met Blob-clients:

• BlobClient
• BlockBlobClient
• AppendBlobClient
• BlobLeaseClient
• PageBlobClient

BlobClient-object maken vanuit ContainerClient

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

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

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

// Azure Storage resource key
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY;
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`;
const blobName = `my-blob`;

// Create ContainerClient
const containerClient = new ContainerClient(
  `${baseUrl}/${containerName}`,
  sharedKeyCredential
);  

async function main() {
  try {
  
    // Create BlobClient object
    const blobClient = containerClient.getBlobClient(blobName);

    // do something with blobClient...
    const properties = await blobClient.getProperties();
    console.log(`Blob ${blobName} properties:`);

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

    // do something with blockBlobClient...
    const downloadResponse = await blockBlobClient.download(0);

  } catch (err) {
    console.log(err);
    throw err;
  }
}

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

BlobClient rechtstreeks maken

Wachtwoordloos

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

// Azure authentication for credential dependency
const { DefaultAzureCredential } = require('@azure/identity');

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

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

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

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

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

async function main(){

  // Create a client that can authenticate with Azure Active Directory
  const client = new BlockBlobClient(
    `${baseUrl}/${containerName}/${blobName}`,
    new DefaultAzureCredential()
  );

  // Get file url - available before contents are uploaded
  console.log(`blob.url: ${client.url}`);

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

  // Get results
  return result;
}

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

Accountsleutel

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

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

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

// Azure Storage resource key
const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY;
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`;
const blobName = `my-blob`;

const fileContentsAsString = "Hello there.";

async function main() {
  try {

    // create blob from BlockBlobClient
    const blockBlobClient = new BlockBlobClient(
      `${baseUrl}/${containerName}/${blobName}`,
      sharedKeyCredential
    );

    // Upload data to the blob  
    await blockBlobClient.upload(
      fileContentsAsString,
      fileContentsAsString.length
    );
    console.log(`blob ${blockBlobClient.url} created`);
  } catch (err) {
    console.log(err);
    throw err;
  }
}

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

SAS-token

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

Het dotenv pakket wordt gebruikt om de naam van uw opslagaccount uit een .env bestand te lezen. Dit bestand mag niet worden ingecheckt bij broncodebeheer.

Zie ook

• Package (npm)
• Voorbeelden
• API-naslaginformatie
• Broncode van bibliotheek
• Feedback geven