In diesem Artikel erfahren Sie, wie Sie mithilfe der Azure Blob Storage-Clientbibliothek für JavaScript eine Verbindung mit Azure Blob Storage herstellen. Nach der Verbindung kann Ihr Code Container, Blobs und Features des Blob Storage-Diensts verwenden.
Für Clientanwendungen (Browser) benötigen Sie Bündelungstools.
Einrichten des Projekts
Öffnen Sie eine Eingabeaufforderung, und wechseln Sie in Ihren Projektordner. Ändern Sie YOUR-DIRECTORY in den Ordnernamen:
cd YOUR-DIRECTORY
Wenn Sie noch keine package.json-Datei in Ihrem Verzeichnis haben, initialisieren Sie das Projekt, um die Datei zu erstellen:
npm init -y
Installieren Sie TypeScript und die Azure Blob Storage Clientbibliothek für JavaScript mit TypeScript-Typen:
npm install typescript @azure/storage-blob
Wenn Sie kennwortlose Verbindungen mit Microsoft Entra ID verwenden möchten, installieren Sie die Azure Identity-Clientbibliothek für JavaScript:
npm install @azure/identity
Autorisieren des Zugriffs und Herstellen einer Verbindung mit Blob Storage
Microsoft Entra ID bietet die sicherste Verbindung, durch die Verwaltung der Verbindungsidentität (verwaltete Identität). Mit der kennwortlosen Funktionalität können Sie eine Anwendung entwickeln, die keine Speicherung von Geheimnissen (Schlüsseln oder Verbindungszeichenfolgen) im Code erfordert.
Einrichten des Identitätszugriffs auf die Azure Cloud
Um ohne Kennwörter eine Verbindung mit Azure herzustellen, müssen Sie eine Azure-Identität einrichten oder eine vorhandene Identität verwenden. Nachdem die Identität eingerichtet wurde, stellen Sie sicher, dass Sie der Identität die entsprechenden Rollen zuweisen.
Um den kennwortlosen Zugriff mit der Microsoft Entra ID zu autorisieren, müssen Sie Azure-Anmeldeinformationen verwenden. Welche Art von Anmeldeinformation Sie benötigen, hängt davon ab, wo Ihre Anwendung ausgeführt wird. Verwenden Sie diese Tabelle als Richtlinie.
Für Ihre Speicherressource muss mindestens eine der folgenden Azure RBAC-Rollen derjenigen Identitätsressource zugewiesen werden, mit der Sie eine Verbindung herstellen möchten. Richten Sie die Azure Storage-Rollen für jede Identität ein, die Sie im vorherigen Schritt erstellt haben: „Azure Cloud“, „Lokale Entwicklung“, „Lokal“.
Nachdem Sie die Einrichtung abgeschlossen haben, benötigt jede Identität mindestens eine geeignete Rolle:
Nachdem Ihre Identitätsrollen für Ihr Azure Storage-Konto und Ihre lokale Umgebung eingerichtet wurden, erstellen Sie eine TypeScript-Datei, die das Paket @azure/identity enthält. Erstellen Sie Anmeldeinformationen, z. B. DefaultAzureCredential, um kennwortlose Verbindungen mit Blob Storage zu implementieren. Authentifizieren Sie sich mit diesen Anmeldeinformationen beim Objekt 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);
}
});
Das Paket dotenv wird verwendet, um den Namen Ihres Speicherkontos aus einer .env-Datei zu lesen. Diese Datei sollte nicht in die Quellcodeverwaltung eingecheckt werden. Wenn Sie einen lokalen Dienstprinzipal als Teil Ihrer DefaultAzureCredential-Einrichtung verwenden, werden alle Sicherheitsinformationen für diese Anmeldeinformationen auch in der .env-Datei gespeichert.
Wenn Sie planen, die Anwendung auf außerhalb von Azure betriebenen Servern und Clients bereitzustellen, erstellen Sie eine der Arten von Anmeldeinformationen, die Ihren Anforderungen entspricht.
Erstellen Sie mithilfe des Speicherkontonamens und des Kontoschlüssels ein Element des Typs StorageSharedKeyCredential. Übergeben Sie StorageSharedKeyCredential an den Klassenkonstruktor BlobServiceClient, um einen Client zu erstellen.
// 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);
}
});
Das Paket dotenv wird verwendet, um den Namen und Schlüssel Ihres Speicherkontos aus einer .env-Datei zu lesen. Diese Datei sollte nicht in die Quellcodeverwaltung eingecheckt werden.
Informationen zum Abrufen von Kontoschlüsseln und Best Practices-Richtlinien für die ordnungsgemäße Verwaltung und Sicherung Ihrer Schlüssel finden Sie unter Verwalten von Speicherkonto-Zugriffsschlüsseln.
Wichtig
Der Kontozugriffsschlüssel sollte mit Vorsicht verwendet werden. Wenn Ihr Kontozugriffsschlüssel verloren geht oder versehentlich an einem unsicheren Ort gespeichert wird, kann Ihr Dienst anfällig werden. Jeder, der über den Zugriffsschlüssel verfügt, kann Anforderungen für das Speicherkonto autorisieren und hat somit Zugriff auf alle Daten. DefaultAzureCredential bietet erweiterte Sicherheitsfeatures und Vorteile und ist der empfohlene Ansatz zum Verwalten der Autorisierung für Azure-Dienste.
Erstellen Sie einen URI zu Ihrer Ressource mithilfe des Blob-Dienstendpunkts und des SAS-Tokens. Erstellen Sie dann mit dem URI einen BlobServiceClient. Das SAS-Token besteht aus einer Reihe von Name-Wert-Paaren in der Abfragezeichenfolge im folgenden Format:
Je nachdem, welches Tool Sie zum Generieren Ihres SAS-Tokens verwenden, wurde die Abfragezeichenfolge ? möglicherweise bereits dem SAS-Token hinzugefügt.
// 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);
}
});
Das Paket dotenv wird verwendet, um den Namen und das SAS-Token Ihres Speicherkontos aus einer .env-Datei zu lesen. Diese Datei sollte nicht in die Quellcodeverwaltung eingecheckt werden.
Informationen zum Generieren und Verwalten von SAS-Token finden Sie in den folgenden Artikeln:
Für Szenarien, in denen SAS (Shared Access Signatures) verwendet werden, empfiehlt Microsoft die Verwendung einer Benutzerdelegierungs-SAS. Eine Benutzerdelegierungs-SAS wird mit Microsoft Entra-Anmeldeinformationen und nicht mithilfe des Kontoschlüssels geschützt. Weitere Informationen finden Sie unter Erstellen einer SAS für die Benutzerdelegierung mit JavaScript.
Erstellen des Objekts ContainerClient
Sie können das Objekt ContainerClient entweder anhand von BlobServiceClient oder direkt erstellen.
Erstellen des Objekts ContainerClient anhand von BlobServiceClient
Erstellen Sie das Objekt ContainerClient anhand von 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);
}
});
// 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);
}
});
// 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);
}
});
Wichtig
Der Kontozugriffsschlüssel sollte mit Vorsicht verwendet werden. Wenn Ihr Kontozugriffsschlüssel verloren geht oder versehentlich an einem unsicheren Ort gespeichert wird, kann Ihr Dienst anfällig werden. Jeder, der über den Zugriffsschlüssel verfügt, kann Anforderungen für das Speicherkonto autorisieren und hat somit Zugriff auf alle Daten. DefaultAzureCredential bietet erweiterte Sicherheitsfeatures und Vorteile und ist der empfohlene Ansatz zum Verwalten der Autorisierung für Azure-Dienste.
// 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);
}
});
Hinweis
Für Szenarien, in denen SAS (Shared Access Signatures) verwendet werden, empfiehlt Microsoft die Verwendung einer Benutzerdelegierungs-SAS. Eine Benutzerdelegierungs-SAS wird mit Microsoft Entra-Anmeldeinformationen und nicht mithilfe des Kontoschlüssels geschützt. Weitere Informationen finden Sie unter Erstellen einer SAS für die Benutzerdelegierung mit JavaScript.
Das Paket dotenv wird verwendet, um den Namen Ihres Speicherkontos aus einer .env-Datei zu lesen. Diese Datei sollte nicht in die Quellcodeverwaltung eingecheckt werden.
Erstellen des Objekts BlobClient
Sie können jedes der unten aufgeführten Objekte des Typs BlobClient entweder anhand von ContainerClient oder direkt erstellen.
// 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
}
*/
// 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);
}
});
Wichtig
Der Kontozugriffsschlüssel sollte mit Vorsicht verwendet werden. Wenn Ihr Kontozugriffsschlüssel verloren geht oder versehentlich an einem unsicheren Ort gespeichert wird, kann Ihr Dienst anfällig werden. Jeder, der über den Zugriffsschlüssel verfügt, kann Anforderungen für das Speicherkonto autorisieren und hat somit Zugriff auf alle Daten. DefaultAzureCredential bietet erweiterte Sicherheitsfeatures und Vorteile und ist der empfohlene Ansatz zum Verwalten der Autorisierung für Azure-Dienste.
/**
* 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>
Hinweis
Für Szenarien, in denen SAS (Shared Access Signatures) verwendet werden, empfiehlt Microsoft die Verwendung einer Benutzerdelegierungs-SAS. Eine Benutzerdelegierungs-SAS wird mit Microsoft Entra-Anmeldeinformationen und nicht mithilfe des Kontoschlüssels geschützt. Weitere Informationen finden Sie unter Erstellen einer SAS für die Benutzerdelegierung mit JavaScript.
Das Paket dotenv wird verwendet, um den Namen Ihres Speicherkontos aus einer .env-Datei zu lesen. Diese Datei sollte nicht in die Quellcodeverwaltung eingecheckt werden.