Hochladen, Herunterladen und Auflisten von Blobs mit der Clientbibliothek für Node.js v2How to upload, download, and list blobs using the client library for Node.js v2

In dieser Schrittanleitung erfahren Sie, wie Sie mit der Clientbibliothek für Node.js v2 Blobs in Azure Blob Storage hochladen, herunterladen und auflisten.In this how-to guide, you learn how to use the client library for Node.js v2 to upload, download, and list blobs with Azure Blob storage.

Tipp

Die neueste Version der Azure Storage-Clientbibliothek für Node.js ist v10.The latest version of the Azure Storage client library for Node.js is v10. Microsoft empfiehlt, nach Möglichkeit die neueste Version der Clientbibliothek zu verwenden.Microsoft recommends that you use the latest version of the client library when possible. Informationen zum Einstieg in v10 finden Sie unter Schnellstart: Hochladen, Herunterladen, Auflisten und Löschen von Blobs mit der Azure Storage-Clientbibliothek für JavaScript v10 (Vorschau).To get started using v10, see Quickstart: Upload, download, list, and delete blobs using Azure Storage client library for JavaScript v10 (preview).

VoraussetzungenPrerequisites

Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.If you don't have an Azure subscription, create a free account before you begin.

Erstellen Sie ein Azure-Speicherkonto im Azure-Portal.Create an Azure storage account in the Azure portal. Hilfe zur Erstellung des Kontos finden Sie unter Erstellen eines Speicherkontos.For help creating the account, see Create a storage account.

Herunterladen der BeispielanwendungDownload the sample application

Bei der Beispielanwendung handelt es sich um eine einfache Node.js-Konsolenanwendung.The sample application is a simple Node.js console application. Klonen Sie zunächst das Repository auf Ihren Computer, indem Sie den folgenden Befehl verwenden:To begin, clone the repository to your machine using the following command:

git clone https://github.com/Azure-Samples/storage-blobs-node-quickstart.git

Suchen Sie zum Öffnen der Anwendung nach dem Ordner storage-blobs-node-quickstart, und öffnen Sie ihn in Ihrer bevorzugten Bearbeitungsumgebung.To open the application, look for the storage-blobs-node-quickstart folder and open it in your favorite code editing environment.

Kopieren Ihrer Anmeldeinformationen aus dem Azure-PortalCopy your credentials from the Azure portal

Die Beispielanwendung muss den Zugriff auf Ihr Speicherkonto authentifizieren.The sample application needs to authenticate access to your storage account. Fügen Sie zum Authentifizieren der Anwendung die Anmeldeinformationen für Ihr Speicherkonto in Form einer Verbindungszeichenfolge hinzu.To authenticate, add your storage account credentials to the application as a connection string. Führen Sie zum Anzeigen der Anmeldeinformationen Ihres Speicherkontos die folgenden Schritte aus:View your storage account credentials by following these steps:

  1. Navigieren Sie zum Azure-Portal.Navigate to the Azure portal.

  2. Suchen Sie nach Ihrem Speicherkonto.Locate your storage account.

  3. Wählen Sie im Abschnitt Einstellungen der Speicherkontoübersicht die Option Zugriffsschlüssel.In the Settings section of the storage account overview, select Access keys. Hier können Sie Ihre Kontozugriffsschlüssel und die vollständige Verbindungszeichenfolge für jeden Schlüssel anzeigen.Here, you can view your account access keys and the complete connection string for each key.

  4. Suchen Sie unter key1 nach dem Wert für die Verbindungszeichenfolge, und wählen Sie dann die Schaltfläche Kopieren, um die Verbindungszeichenfolge zu kopieren.Find the Connection string value under key1, and select the Copy button to copy the connection string. Der Wert der Verbindungszeichenfolge wird in einem späteren Schritt einer Umgebungsvariablen hinzugefügt.You will add the connection string value to an environment variable in the next step.

    Screenshot: Kopieren einer Verbindungszeichenfolge aus dem Azure-Portal

Konfigurieren der SpeicherverbindungszeichenfolgeConfigure your storage connection string

Vor dem Ausführen der Anwendung müssen Sie die Verbindungszeichenfolge für das Speicherkonto angeben.Before running the application, you must provide the connection string for your storage account. Das Beispielrepository enthält eine Datei mit dem Namen .env.example.The sample repository includes a file named .env.example. Sie können diese Datei umbenennen, indem Sie die Erweiterung .example entfernen, sodass die Datei nur noch .env heißt.You can rename this file by removing the .example extension, which results in a file named .env. Fügen Sie in der Datei .env Ihren Wert für die Verbindungszeichenfolge nach dem Schlüssel AZURE_STORAGE_CONNECTION_STRING hinzu.Inside the .env file, add your connection string value after the AZURE_STORAGE_CONNECTION_STRING key.

Installieren erforderlicher PaketeInstall required packages

Führen Sie im Anwendungsverzeichnis npm install aus, um die erforderlichen Pakete für die Anwendung zu installieren.In the application directory, run npm install to install the required packages for the application.

npm install

Ausführen des BeispielsRun the sample

Nachdem nun die Abhängigkeiten installiert wurden, können Sie das Beispiel ausführen, indem Sie den folgenden Befehl ausgeben:Now that the dependencies are installed, you can run the sample by issuing the following command:

npm start

Die Ausgabe des Skripts sollte ungefähr wie folgt aussehen:The output from the script will be similar to the following:

Containers:
 - container-one
 - container-two
Container "demo" is created
Blob "quickstart.txt" is uploaded
Local file "./readme.md" is uploaded
Blobs in "demo" container:
 - quickstart.txt
 - readme.md
Blob downloaded blob content: "hello Blob SDK"
Blob "quickstart.txt" is deleted
Container "demo" is deleted
Done

Wenn Sie für dieses Beispiel ein neues Speicherkonto verwenden, werden unter „Container“ möglicherweise keine Containernamen angezeigt.If you are using a new storage account for this example, then you may not see any container names listed under the label "Containers".

Grundlegendes zum CodeUnderstanding the code

Der erste Ausdruck wird verwendet, um Werte in Umgebungsvariablen zu laden.The first expression is used to load values into environment variables.

if (process.env.NODE_ENV !== 'production') {
    require('dotenv').load();
}

Das Modul dotenv lädt Umgebungsvariablen, wenn die App lokal zum Debuggen ausgeführt wird.The dotenv module loads environment variables when running the app locally for debugging. Werte werden in der Datei .env definiert und in den aktuellen Ausführungskontext geladen.Values are defined in a file named .env and loaded into the current execution context. In Kontexten von Produktionsumgebungen stellt die Serverkonfiguration diese Werte zur Verfügung, weshalb dieser Code nur ausgeführt wird, wenn das Skript nicht im Kontext einer Produktionsumgebung ausgeführt wird.In production contexts, the server configuration provides these values and that is why this code is only run when the script is not running under a "production" context.

const path = require('path');
const storage = require('azure-storage');

Die Module haben den folgenden Zweck:The purpose of the modules is as follows:

Datei namens .env in den aktuellen Ausführungskontextfile named .env into the current execution context

  • path ist erforderlich, um den absoluten Dateipfad der Datei zu ermitteln, die in Blobspeicher hochgeladen werden soll.path is required in order to determine the absolute file path of the file to upload to blob storage
  • azure-storage ist das Azure Storage-Clientbibliothek-Modul für Node.js.azure-storage is the Azure Storage client library module for Node.js

Anschließend wird die Variable blobService als neue Instanz des Azure Blob-Diensts initialisiert.Next, the blobService variable is initialized as a new instance of the Azure Blob service.

const blobService = storage.createBlobService();

In der folgenden Implementierung sind die blobService-Funktionen jeweils von einem Promise-Element (Zusage) umschlossen, mit dem der Zugriff auf die async-Funktion und den await-Operator von JavaScript ermöglicht wird, um das Rückrufverhalten der Azure Storage-API zu optimieren.In the following implementation, each of the blobService functions is wrapped in a Promise, which allows access to JavaScript's async function and await operator to streamline the callback nature of the Azure Storage API. Wenn für jede Funktion eine erfolgreiche Antwort zurückgegeben wird, wird die Zusage mit relevanten Daten und einer spezifischen Nachricht für die Aktion aufgelöst.When a successful response returns for each function, the promise resolves with relevant data along with a message specific to the action.

Auflisten von ContainernList containers

Die Funktion listContainers ruft listContainersSegmented auf, um Sammlungen von Containern in Gruppen zurückzugeben.The listContainers function calls listContainersSegmented which returns collections of containers in groups.

const listContainers = async () => {
    return new Promise((resolve, reject) => {
        blobService.listContainersSegmented(null, (err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `${data.entries.length} containers`, containers: data.entries });
            }
        });
    });
};

Die Größe der Gruppen ist über ListContainersOptions konfigurierbar.The size of the groups is configurable via ListContainersOptions. Der Aufruf von listContainersSegmented gibt Blobmetadaten als Array von ContainerResult-Instanzen zurück.Calling listContainersSegmented returns blob metadata as an array of ContainerResult instances. Ergebnisse werden in Batches mit einem Inkrement von 5.000 (Segmenten) zurückgegeben.Results are returned in 5,000 increment batches (segments). Wenn in einem Container mehr als 5.000 Blobs vorhanden sind, enthalten die Ergebnisse einen Wert für continuationToken.If there are more than 5,000 blobs in a container, then the results include a value for continuationToken. Zum Auflisten nachfolgender Segmente aus dem Blobcontainer können Sie das Fortsetzungstoken als zweites Argument zurück an listContainersSegment übergeben.To list subsequent segments from the blob container, you can pass the continuation token back into listContainersSegment as the second argument.

Erstellen eines ContainersCreate a container

Die Funktion createContainer ruft createContainerIfNotExists auf und legt die passende Zugriffsebene für das Blob fest.The createContainer function calls createContainerIfNotExists and sets the appropriate access level for the blob.

const createContainer = async (containerName) => {
    return new Promise((resolve, reject) => {
        blobService.createContainerIfNotExists(containerName, { publicAccessLevel: 'blob' }, err => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `Container '${containerName}' created` });
            }
        });
    });
};

Der zweite Parameter (options) für createContainerIfNotExists akzeptiert einen Wert für publicAccessLevel.The second parameter (options) for createContainerIfNotExists accepts a value for publicAccessLevel. Der Wert blob für publicAccessLevel gibt an, dass bestimmte Blobdaten öffentlich verfügbar gemacht werden.The value blob for publicAccessLevel specifies that specific blob data is exposed to the public. Diese Einstellung ist anders als die Zugriffsebene container, bei der die Möglichkeit gewährt wird, den Inhalt des Containers aufzulisten.This setting is in contrast to container level access, which grants the ability to list the contents of the container.

Durch die Verwendung von createContainerIfNotExists kann die Anwendung den Befehl mehrfach createContainer ausführen, ohne Fehler zurückzugeben, wenn der Container bereits vorhanden ist.The use of createContainerIfNotExists allows the application to run the createContainer command multiple times without returning errors when the container already exists. In einer Produktionsumgebung rufen Sie createContainerIfNotExists häufig nur einmal auf, da derselbe Container für die gesamte Anwendung verwendet wird.In a production environment, you often only call createContainerIfNotExists once as the same container is used throughout the application. In diesen Fällen können Sie den Container im Voraus über das Portal oder die Azure CLI erstellen.In these cases, you can create the container ahead of time through the portal or via the Azure CLI.

Hochladen von TextUpload text

Die Funktion uploadString ruft createBlockBlobFromText auf, um eine beliebige Zeichenkette in den Blobcontainer zu schreiben (oder sie zu überschreiben).The uploadString function calls createBlockBlobFromText to write (or overwrite) an arbitrary string to the blob container.

const uploadString = async (containerName, blobName, text) => {
    return new Promise((resolve, reject) => {
        blobService.createBlockBlobFromText(containerName, blobName, text, err => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `Text "${text}" is written to blob storage` });
            }
        });
    });
};

Hochladen einer lokalen DateiUpload a local file

Für die Funktion uploadLocalFile wird die Funktion createBlockBlobFromLocalFile verwendet, um eine Datei aus dem Dateisystem in Blobspeicher hochzuladen und zu schreiben (bzw. zu überschreiben).The uploadLocalFile function uses createBlockBlobFromLocalFile to upload and write (or overwrite) a file from the file system into blob storage.

const uploadLocalFile = async (containerName, filePath) => {
    return new Promise((resolve, reject) => {
        const fullPath = path.resolve(filePath);
        const blobName = path.basename(filePath);
        blobService.createBlockBlobFromLocalFile(containerName, blobName, fullPath, err => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `Local file "${filePath}" is uploaded` });
            }
        });
    });
};

Weitere Ansätze zum Hochladen von Inhalt in Blobs sind die Verwendung von text und streams.Other approaches available to upload content into blobs include working with text and streams. Für die Überprüfung des Dateiuploads in Ihren Blobspeicher können Sie den Azure Storage-Explorer verwenden, um die Daten in Ihrem Konto anzuzeigen.To verify the file is uploaded to your blob storage, you can use the Azure Storage Explorer to view the data in your account.

Auflisten der BlobsList the blobs

Mit der Funktion listBlobs rufen Sie die listBlobsSegmented-Methode auf, um eine Liste mit Blobmetadaten in einem Container zurückzugeben.The listBlobs function calls the listBlobsSegmented method to return a list of blob metadata in a container.

const listBlobs = async (containerName) => {
    return new Promise((resolve, reject) => {
        blobService.listBlobsSegmented(containerName, null, (err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `${data.entries.length} blobs in '${containerName}'`, blobs: data.entries });
            }
        });
    });
};

Durch das Aufrufen von listBlobsSegmented werden Blobmetadaten als Array mit BlobResult-Instanzen zurückgegeben.Calling listBlobsSegmented returns blob metadata as an array of BlobResult instances. Ergebnisse werden in Batches mit einem Inkrement von 5.000 (Segmenten) zurückgegeben.Results are returned in 5,000 increment batches (segments). Wenn in einem Container mehr als 5.000 Blobs vorhanden sind, enthalten die Ergebnisse einen Wert für continuationToken.If there are more than 5,000 blobs in a container, then the results include a value for continuationToken. Zum Auflisten nachfolgender Segmente aus dem Blobcontainer können Sie das Fortsetzungstoken als zweites Argument zurück an listBlobSegmented übergeben.To list subsequent segments from the blob container, you can pass the continuation token back into listBlobSegmented as the second argument.

Herunterladen eines BlobsDownload a blob

In der Funktion downloadBlob wird getBlobToText verwendet, um den Inhalt des Blobs an den Speicherort des angegebenen absoluten Dateipfads herunterzuladen.The downloadBlob function uses getBlobToText to download the contents of the blob to the given absolute file path.

const downloadBlob = async (containerName, blobName) => {
    const dowloadFilePath = path.resolve('./' + blobName.replace('.txt', '.downloaded.txt'));
    return new Promise((resolve, reject) => {
        blobService.getBlobToText(containerName, blobName, (err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `Blob downloaded "${data}"`, text: data });
            }
        });
    });
};

Die hier gezeigte Implementierung ändert die Quelle und gibt den Blobinhalt als Zeichenkette zurück.The implementation shown here changes the source returns the contents of the blob as a string. Sie können den Blob auch als Datenstrom sowie direkt in eine lokale Datei herunterladen.You can also download the blob as a stream as well as directly to a local file.

Löschen eines BLOBsDelete a blob

Die Funktion deleteBlob ruft die Funktion deleteBlobIfExists auf.The deleteBlob function calls the deleteBlobIfExists function. Wie der Name schon erahnen lässt, gibt diese Funktion keinen Fehler zurück, wenn das Blob bereits gelöscht wurde.As the name implies, this function does not return an error if the blob is already deleted.

const deleteBlob = async (containerName, blobName) => {
    return new Promise((resolve, reject) => {
        blobService.deleteBlobIfExists(containerName, blobName, err => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `Block blob '${blobName}' deleted` });
            }
        });
    });
};

Löschen eines ContainersDelete a container

Container werden durch Aufrufen der deleteContainer-Methode aus dem Blobdienst und durch Übergabe des Containernamens gelöscht.Containers are deleted by calling the deleteContainer method off the blob service and passing in the container name.

const deleteContainer = async (containerName) => {
    return new Promise((resolve, reject) => {
        blobService.deleteContainer(containerName, err => {
            if (err) {
                reject(err);
            } else {
                resolve({ message: `Container '${containerName}' deleted` });
            }
        });
    });
};

Aufrufen von CodeCalling code

Zur Unterstützung der async/await-Syntax von JavaScript wird der gesamte Aufrufcode in eine Funktion namens execute eingebettet.In order to support JavaScript's async/await syntax, all the calling code is wrapped in a function named execute. Dann wird „execute“ aufgerufen und als Zusicherung behandelt.Then execute is called and handled as a promise.

async function execute() {
    // commands 
}

execute().then(() => console.log("Done")).catch((e) => console.log(e));

Der gesamte folgende Code wird innerhalb der Funktion „execute“ ausgeführt, in der der Kommentar // commands platziert ist.All of the following code runs inside the execute function where the // commands comment is placed.

Zunächst werden die relevanten Variablen deklariert, um Namen, Beispielinhalt zuzuweisen und auf die lokale Datei zu verweisen, die in den Blobspeicher hochgeladen wird.First, the relevant variables are declared to assign names, sample content and to point to the local file to upload to Blob storage.

const containerName = "demo";
const blobName = "quickstart.txt";
const content = "hello Node SDK";
const localFilePath = "./readme.md";
let response;

Um die Container im Speicherkonto aufzulisten, wird die Funktion „listContainers“ aufgerufen und die zurückgegebene Liste der Container wird im Ausgabefenster protokolliert.To list the containers in the storage account, the listContainers function is called and the returned list of containers is logged to the output window.

console.log("Containers:");
response = await listContainers();
response.containers.forEach((container) => console.log(` -  ${container.name}`));

Nachdem die Liste der Container verfügbar ist, können Sie mit der findIndex-Methode überprüfen, ob der zu erstellende Container bereits vorhanden ist.Once the list of containers is available, then you can use the Array findIndex method to see if the container you want to create already exists. Wenn der Container nicht vorhanden ist, wird er erstellt.If the container does not exist then the container is created.

const containerDoesNotExist = response.containers.findIndex((container) => container.name === containerName) === -1;

if (containerDoesNotExist) {
    await createContainer(containerName);
    console.log(`Container "${containerName}" is created`);
}

Als nächstes werden eine Zeichenkette und eine lokale Datei in den Blobspeicher hochgeladen.Next, a string and a local file is uploaded to Blob storage.

await uploadString(containerName, blobName, content);
console.log(`Blob "${blobName}" is uploaded`);

response = await uploadLocalFile(containerName, localFilePath);
console.log(response.message);

Der Vorgang zum Auflisten von Blobs ist identisch mit dem Auflisten von Containern.The process to list blobs is the same as listing containers. Der Aufruf von listBlobs gibt ein Array von Blobs im Container zurück und wird im Ausgabefenster protokolliert.The call to listBlobs returns an array of blobs in the container and are logged to the output window.

console.log(`Blobs in "${containerName}" container:`);
response = await listBlobs(containerName);
response.blobs.forEach((blob) => console.log(` - ${blob.name}`));

Um einen Blob herunterzuladen, wird die Antwort erfasst und verwendet, um auf den Wert des Blobs zuzugreifen.To download a blob, the response is captured and used to access the value of the blob. Aus der Antwort wird „readableStreamBody“ in eine Zeichenfolge umgewandelt und im Ausgabefenster abgemeldet.From the response readableStreamBody is converted to a string and logged out to the output window.

response = await downloadBlob(containerName, blobName);
console.log(`Downloaded blob content: "${response.text}"`);

Abschließend werden Blob und Container aus dem Speicherkonto gelöscht.Finally, the blob and container are deleted from the storage account.

await deleteBlob(containerName, blobName);
console.log(`Blob "${blobName}" is deleted`);

await deleteContainer(containerName);
console.log(`Container "${containerName}" is deleted`);

Bereinigen von RessourcenClean up resources

Alle in das Speicherkonto geschriebenen Daten werden am Ende des Codebeispiels automatisch gelöscht.All data written to the storage account is automatically deleted at the end of the code sample.

Ressourcen für die Entwicklung von Node.js-Anwendungen mit BlobsResources for developing Node.js applications with blobs

Sehen Sie sich diese zusätzlichen Ressourcen zur Node.js-Entwicklung mit Blobspeicher an:See these additional resources for Node.js development with Blob storage:

Binärdateien und QuellcodeBinaries and source code

Clientbibliothek – Referenz und BeispieleClient library reference and samples

Nächste SchritteNext steps

In diesem Artikel wurde veranschaulicht, wie Sie den Upload einer Datei zwischen einem lokalen Datenträger und Azure Blob Storage mit Node.js durchführen.This article demonstrates how to upload a file between a local disk and Azure Blob storage using Node.js. Weitere Informationen zur Arbeit mit Blobspeicher finden Sie im GitHub-Repository.To learn more about working with Blob storage, continue to the GitHub repository.