Usare JavaScript SDK in Node.js per gestire directory e file in Azure Data Lake Storage
Questo articolo illustra come usare Node.js per creare e gestire directory e file negli account di archiviazione con uno spazio dei nomi gerarchico.
Per informazioni su come ottenere, impostare e aggiornare gli elenchi di controllo di accesso (ACL) di directory e file, vedere Usare JavaScript SDK in Node.js per gestire gli elenchi di controllo di accesso in Azure Data Lake Storage.
Pacchetti (Gestione pacchetti nodi) | Esempi | Fornisci feedback
Prerequisiti
Una sottoscrizione di Azure. Per altre informazioni, vedere Ottenere la versione di valutazione gratuita di Azure.
Un account di archiviazione con spazio dei nomi gerarchico abilitato. Per crearne uno, seguire queste istruzioni.
Se si usa questo pacchetto in un'applicazione Node.js, è necessario Node.js 8.0.0 o versione successiva.
Impostare il progetto
Installare la libreria client di Data Lake per JavaScript aprendo una finestra del terminale e quindi digitando il comando seguente.
npm install @azure/storage-file-datalake
Importare il storage-file-datalake pacchetto inserendo questa istruzione all'inizio del file di codice.
const {
AzureStorageDataLake,
DataLakeServiceClient,
StorageSharedKeyCredential
} = require("@azure/storage-file-datalake");
Nota
L'accesso multi-protocollo in Data Lake Storage consente alle applicazioni di usare sia le API BLOB che le API Data Lake Storage Gen2 per lavorare con i dati negli account di archiviazione con spazio dei nomi gerarchico (HNS) abilitato. Quando si usano funzionalità specifiche di Data Lake Storage Gen2, ad esempio operazioni di directory e ACL, usare le API data Lake Storage Gen2, come illustrato in questo articolo.
Quando si scelgono le API da usare in uno scenario specifico, prendere in considerazione il carico di lavoro e le esigenze dell'applicazione, insieme ai problemi noti e all'impatto di HNS su carichi di lavoro e applicazioni.
Effettuare la connessione all'account
Per usare i frammenti di codice in questo articolo, è necessario creare un'istanza di DataLakeServiceClient che rappresenta l'account di archiviazione.
Connettersi con Microsoft Entra ID
È possibile usare la libreria client di identità di Azure per JS per autenticare l'applicazione con l'ID Microsoft Entra.
Creare un'istanza di DataLakeServiceClient e passare una nuova istanza della classe DefaultAzureCredential .
function GetDataLakeServiceClientAD(accountName) {
const dataLakeServiceClient = new DataLakeServiceClient(
`https://${accountName}.dfs.core.windows.net`,
new DefaultAzureCredential());
return dataLakeServiceClient;
}
Per altre informazioni sull'uso di DefaultAzureCredential per autorizzare l'accesso ai dati, vedere Panoramica: Autenticare le app JavaScript in Azure con Azure SDK.
Connettersi usando una chiave dell'account
È possibile autorizzare l'accesso ai dati usando le chiavi di accesso dell'account (Chiave condivisa). In questo esempio viene creata un'istanza di DataLakeServiceClient autorizzata con la chiave dell'account.
function GetDataLakeServiceClient(accountName, accountKey) {
const sharedKeyCredential =
new StorageSharedKeyCredential(accountName, accountKey);
const dataLakeServiceClient = new DataLakeServiceClient(
`https://${accountName}.dfs.core.windows.net`, sharedKeyCredential);
return dataLakeServiceClient;
}
Questo metodo di autorizzazione funziona solo per le applicazioni Node.js. Se si prevede di eseguire il codice in un browser, è possibile autorizzare usando Microsoft Entra ID.
Attenzione
L'autorizzazione con chiave condivisa non è consigliata, perché potrebbe essere meno sicura. Per una sicurezza ottimale, disabilitare l'autorizzazione tramite chiave condivisa per l'account di archiviazione, come descritto in Impedire l'autorizzazione con chiave condivisa per un account di archiviazione di Azure.
L'uso di chiavi di accesso e stringhe di connessione deve essere limitato ai modelli di verifica delle app iniziali o ai prototipi di sviluppo che non accedono a dati sensibili o di produzione. Diversamente, per l'autenticazione alle risorse di Azure vanno sempre preferite le classi di autenticazione basate su token disponibili in Azure SDK.
Microsoft consiglia che i client usino Microsoft Entra ID o una firma di accesso condiviso per autorizzare l'accesso ai dati in Archiviazione di Azure. Per ulteriori informazioni, consultare Autorizzare le operazioni per l'accesso ai dati.
Creazione di un contenitore
Un contenitore funge da file system per i file. È possibile crearne uno ottenendo un'istanza FileSystemClient e quindi chiamando il metodo FileSystemClient.Create .
In questo esempio viene creato un contenitore denominato my-file-system.
async function CreateFileSystem(dataLakeServiceClient) {
const fileSystemName = "my-file-system";
const fileSystemClient = dataLakeServiceClient.getFileSystemClient(fileSystemName);
const createResponse = await fileSystemClient.create();
}
Creare una directory
Creare un riferimento alla directory recuperando un'istanza directoryClient e quindi chiamando il metodo DirectoryClient.create .
In questo esempio viene aggiunta una directory denominata my-directory a un contenitore.
async function CreateDirectory(fileSystemClient) {
const directoryClient = fileSystemClient.getDirectoryClient("my-directory");
await directoryClient.create();
}
Rinominare o spostare una directory
Rinominare o spostare una directory chiamando il metodo DirectoryClient.rename . Passare il percorso della directory desiderata un parametro.
In questo esempio viene rinominata una sottodirectory con il nome my-directory-renamed.
async function RenameDirectory(fileSystemClient) {
const directoryClient = fileSystemClient.getDirectoryClient("my-directory");
await directoryClient.move("my-directory-renamed");
}
In questo esempio viene spostata una directory denominata my-directory-renamed in una sottodirectory di una directory denominata my-directory-2.
async function MoveDirectory(fileSystemClient) {
const directoryClient = fileSystemClient.getDirectoryClient("my-directory-renamed");
await directoryClient.move("my-directory-2/my-directory-renamed");
}
Eliminare una directory
Eliminare una directory chiamando il metodo DirectoryClient.delete .
Questo esempio illustra come eliminare una directory denominata my-directory.
async function DeleteDirectory(fileSystemClient) {
const directoryClient = fileSystemClient.getDirectoryClient("my-directory");
await directoryClient.delete();
}
Caricare un file in una directory
Prima di tutto, leggere un file. In questo esempio viene usato il modulo Node.js fs . Creare quindi un riferimento al file nella directory di destinazione creando un'istanza fileClient e quindi chiamando il metodo FileClient.create. Caricare un file chiamando il metodo FileClient.append . Assicurarsi di completare il caricamento chiamando il metodo FileClient.flush .
In questo esempio viene caricato un file di testo in una directory denominata my-directory.'
async function UploadFile(fileSystemClient) {
const fs = require('fs')
var content = "";
fs.readFile('mytestfile.txt', (err, data) => {
if (err) throw err;
content = data.toString();
})
const fileClient = fileSystemClient.getFileClient("my-directory/uploaded-file.txt");
await fileClient.create();
await fileClient.append(content, 0, content.length);
await fileClient.flush(content.length);
}
Scaricare da una directory
Creare prima di tutto un'istanza fileSystemClient che rappresenta il file da scaricare. Usare il metodo FileSystemClient.read per leggere il file. Quindi, scrivere il file. In questo esempio viene usato il modulo Node.js fs a tale scopo.
Nota
Questo metodo di download di un file funziona solo per le applicazioni Node.js. Se si prevede di eseguire il codice in un browser, vedere la libreria client Archiviazione di Azure File Data Lake per il file leggimi JavaScript per un esempio di come eseguire questa operazione in un browser.
async function DownloadFile(fileSystemClient) {
const fileClient = fileSystemClient.getFileClient("my-directory/uploaded-file.txt");
const downloadResponse = await fileClient.read();
const downloaded = await streamToString(downloadResponse.readableStreamBody);
async function streamToString(readableStream) {
return new Promise((resolve, reject) => {
const chunks = [];
readableStream.on("data", (data) => {
chunks.push(data.toString());
});
readableStream.on("end", () => {
resolve(chunks.join(""));
});
readableStream.on("error", reject);
});
}
const fs = require('fs');
fs.writeFile('mytestfiledownloaded.txt', downloaded, (err) => {
if (err) throw err;
});
}
Elencare il contenuto della directory
In questo esempio vengono stampati i nomi di ogni directory e file che si trova in una directory denominata my-directory.
async function ListFilesInDirectory(fileSystemClient) {
let i = 1;
let iter = await fileSystemClient.listPaths({path: "my-directory", recursive: true});
for await (const path of iter) {
console.log(`Path ${i++}: ${path.name}, is directory: ${path.isDirectory}`);
}
}