Usare JavaScript SDK in Node.js per gestire directory e file in Azure Data Lake Archiviazione Gen2
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 Archiviazione Gen2.
Pacchetti (Gestione pacchetti Node) | Esempi | di commenti e suggerimenti
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, sarà 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");
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.
Connessione utilizzando 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.
Connessione 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 Archiviazione di Azure.
L'uso di chiavi di accesso e stringa di connessione deve essere limitato alle app di verifica iniziali o ai prototipi di sviluppo che non accedono a dati sensibili o di produzione. In caso contrario, le classi di autenticazione basate su token disponibili in Azure SDK devono essere sempre preferite quando si esegue l'autenticazione alle risorse di Azure.
Microsoft consiglia ai client di usare l'ID Microsoft Entra o una firma di accesso condiviso per autorizzare l'accesso ai dati in Archiviazione di Azure. Per altre informazioni, vedere 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. Questo esempio usa 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 per eseguire questa operazione.
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}`);
}
}