Usare JavaScript SDK in Node.js per gestire directory e file in Azure Data Lake Storage 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 Storage Gen2.

Pacchetto (Node Package Manager) | Campioni | Assegnare 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, è necessario Node.js 8.0.0 o versione successiva.

Configurare 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 nella parte superiore 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.

Connettersi usando una chiave dell'account

Questo è il modo più semplice per connettersi a un account.

In questo esempio viene creata un'istanza di DataLakeServiceClient usando una chiave account.


function GetDataLakeServiceClient(accountName, accountKey) {

  const sharedKeyCredential =
     new StorageSharedKeyCredential(accountName, accountKey);

  const datalakeServiceClient = new DataLakeServiceClient(
      `https://${accountName}.dfs.core.windows.net`, sharedKeyCredential);

  return datalakeServiceClient;
}

Nota

Questo metodo di autorizzazione funziona solo per le applicazioni Node.js. Se si prevede di eseguire il codice in un browser, è possibile autorizzare usando Azure Active Directory (Azure AD).

Connettersi usando Azure Active Directory (Azure AD)

È possibile usare la libreria client di Identità di Azure per JS per autenticare l'applicazione con Azure AD.

In questo esempio viene creata un'istanza di DataLakeServiceClient usando un ID client, un segreto client e un ID tenant. Per ottenere questi valori, vedere Acquisire un token da Azure AD per l'autorizzazione delle richieste da un'applicazione client.

function GetDataLakeServiceClientAD(accountName, clientID, clientSecret, tenantID) {

  const credential = new ClientSecretCredential(tenantID, clientID, clientSecret);

  const datalakeServiceClient = new DataLakeServiceClient(
      `https://${accountName}.dfs.core.windows.net`, credential);

  return datalakeServiceClient;
}

Creare un contenitore

Un contenitore funge da file system per i file. È possibile crearne uno ottenendo un'istanza di 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 ottenendo un'istanza di 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 sottocartella 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 sotto directory 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 a un file nella directory di destinazione creando un'istanza di 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 di FileSystemClient che rappresenta il file da scaricare. Usare il metodo FileSystemClient.read per leggere il file. Scrivere quindi 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 file di Archiviazione di Azure data lake per il file di lettura 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}`);
  }

}

Vedi anche