Guida introduttiva: Gestire i BLOB con JavaScript v12 SDK in Node.js

Articolo
07/05/2022
7 minuti per la lettura

In questo argomento di avvio rapido viene illustrato come gestire i BLOB con Node.js. I BLOB sono oggetti che possono contenere grandi quantità di dati di testo o binari, tra cui immagini, documenti, flussi multimediali e dati di archiviazione.

Questi frammenti di codice di esempio illustrano come eseguire le operazioni seguenti con la libreria di pacchetti di archiviazione BLOB di Azure per JavaScript:

Ottenere la stringa di connessione
Creare un contenitore
Caricare BLOB in un contenitore
Elencare i BLOB in un contenitore
Scaricare BLOB
Eliminare un contenitore

Risorse aggiuntive:

Informazioni di riferimento | sulle API Codice sorgente | della libreria Pacchetto (npm) | Campioni

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Un account dell'Archiviazione di Azure. Creare un account di archiviazione.
Node.js LTS.
Microsoft Visual Studio Code

Modello a oggetti

Archiviazione BLOB è ottimizzata per archiviare enormi quantità di dati non strutturati. I dati non strutturati sono dati che non seguono una definizione o un modello di dati specifico, ad esempio dati di testo o binari. L’archiviazione BLOB offre tre tipi di risorse:

L'account di archiviazione
Un contenitore nell'account di archiviazione
Un oggetto BLOB in un contenitore

Il diagramma seguente mostra la relazione tra queste risorse.

Diagram of Blob storage architecture

Per interagire con queste risorse, usare le classi JavaScript seguenti:

BlobServiceClient: la classe BlobServiceClient consente di modificare le risorse di Archiviazione di Azure e i contenitori BLOB.
ContainerClient: la classe ContainerClient consente di modificare i contenitori di Archiviazione di Azure e i relativi oggetti BLOB.
BlobClient: la classe BlobClient consente di modificare gli oggetti BLOB di Archiviazione di Azure.

Creare il progetto Node.js

Creare un'applicazione JavaScript denominata blob-quickstart-v12.

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare una nuova directory per il progetto.
```
mkdir blob-quickstart-v12
```
Passare alla directory blob-quickstart-v12 appena creata.
```
cd blob-quickstart-v12
```
Creare un file package.json.
```
npm init -y
```
Aprire il progetto in Visual Studio Code:
```
code .
```

Installare il pacchetto npm per l'archiviazione BLOB

Installare il pacchetto npm di Archiviazione di Azure:
```
npm install @azure/storage-blob
```
Installare altre dipendenze usate in questa guida introduttiva:
```
npm install uuid dotenv
```

Creare un file JavaScript

Dalla directory del progetto:

Creare un file denominato index.js.

Copiare il seguente codice nel file. Man mano che si procede con questa guida introduttiva, verrà aggiunto altro codice.

const { BlobServiceClient } = require('@azure/storage-blob');
const { v1: uuidv1} = require('uuid');
require('dotenv').config()

async function main() {
    console.log('Azure Blob storage v12 - JavaScript quickstart sample');

    // Quick start code goes here

}

main()
.then(() => console.log('Done'))
.catch((ex) => console.log(ex.message));

Copiare le credenziali dal portale di Azure

Le richieste effettuate dall'applicazione di esempio ad Archiviazione di Azure devono essere autorizzate. Per autorizzare una richiesta, aggiungere all'applicazione le credenziali dell'account di archiviazione sotto forma di stringa di connessione. Per visualizzare le credenziali dell'account di archiviazione, seguire questa procedura:

Accedere al portale di Azure.
Individuare l'account di archiviazione.
Nel riquadro dei menu dell'account di archiviazione, in Sicurezza e rete selezionare Chiavi di accesso. Qui è possibile visualizzare le chiavi di accesso dell'account e la stringa di connessione completa per ogni chiave.
Nel riquadro Chiavi di accesso selezionare Mostra chiavi.
Nella sezione key1 individuare il valore stringa di connessione . Selezionare l'icona Copia negli Appunti per copiare la stringa di connessione. Il valore della stringa di connessione verrà aggiunto a una variabile di ambiente nella sezione successiva.

Configurare la stringa di connessione di archiviazione

Dopo aver copiato la stringa di connessione, scriverla in una nuova variabile di ambiente nel computer locale che esegue l'applicazione. Per impostare la variabile di ambiente, aprire una finestra della console e seguire le istruzioni per il sistema operativo specifico. Sostituire <yourconnectionstring> con la stringa di connessione effettiva.

Windows
Linux e macOS

setx AZURE_STORAGE_CONNECTION_STRING "<yourconnectionstring>"

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

Dopo aver aggiunto la variabile di ambiente in Windows, è necessario avviare una nuova istanza della finestra di comando.

Riavviare i programmi

Dopo aver aggiunto la variabile di ambiente, riavviare gli eventuali programmi in esecuzione che dovranno leggerla. Ad esempio, riavviare l'ambiente di sviluppo o l'editor prima di continuare.

Ottenere la stringa di connessione

Il codice seguente recupera la stringa di connessione per l'account di archiviazione dalla variabile di ambiente creata nella sezione Configurare la stringa di connessione di archiviazione.

Aggiungere questo codice all'interno della funzione main:

const AZURE_STORAGE_CONNECTION_STRING =
  process.env.AZURE_STORAGE_CONNECTION_STRING;

if (!AZURE_STORAGE_CONNECTION_STRING) {
  throw Error("Azure Storage Connection string not found");
}

Creare un contenitore

Decidere un nome per il nuovo contenitore. I nomi dei contenitori devono essere in minuscolo.

Per altre informazioni sulla denominazione di contenitori e BLOB, vedere Naming and Referencing Containers, Blobs, and Metadata (Assegnazione di nome e riferimento a contenitori, BLOB e metadati).

Aggiungere questo codice alla fine della funzione main:

// Create the BlobServiceClient object which will be used to create a container client
const blobServiceClient = BlobServiceClient.fromConnectionString(
  AZURE_STORAGE_CONNECTION_STRING
);

// Create a unique name for the container
const containerName = "quickstart" + uuidv1();

console.log("\nCreating container...");
console.log("\t", containerName);

// Get a reference to a container
const containerClient = blobServiceClient.getContainerClient(containerName);
// Create the container
const createContainerResponse = await containerClient.create();
console.log(
  "Container was created successfully. requestId: ",
  createContainerResponse.requestId
);

Il codice precedente crea un'istanza della classe BlobServiceClient chiamando il metodo fromConnectionString . Chiamare quindi il metodo getContainerClient per ottenere un riferimento a un contenitore. Infine, chiamare create per creare effettivamente il contenitore nell'account di archiviazione.

Caricare BLOB in un contenitore

Copiare il codice seguente alla fine della main funzione per caricare una stringa di testo in un BLOB:

// Create a unique name for the blob
const blobName = "quickstart" + uuidv1() + ".txt";

// Get a block blob client
const blockBlobClient = containerClient.getBlockBlobClient(blobName);

console.log("\nUploading to Azure storage as blob:\n\t", blobName);

// Upload data to the blob
const data = "Hello, World!";
const uploadBlobResponse = await blockBlobClient.upload(data, data.length);
console.log(
  "Blob was uploaded successfully. requestId: ",
  uploadBlobResponse.requestId
);

Il codice precedente ottiene un riferimento a un oggetto BlockBlobClient chiamando il metodo getBlockBlobClient in ContainerClient dalla sezione Creare un contenitore . Il codice carica i dati della stringa di testo nel BLOB chiamando il metodo upload .

Elencare i BLOB in un contenitore

Aggiungere il codice seguente alla fine della main funzione per elencare i BLOB nel contenitore.

console.log("\nListing blobs...");

// List the blob(s) in the container.
for await (const blob of containerClient.listBlobsFlat()) {
  console.log("\t", blob.name);
}

Il codice precedente chiama il metodo listBlobsFlat . In questo caso, al contenitore è stato aggiunto un unico BLOB, quindi l'operazione di recupero dell'elenco restituisce solo tale BLOB.

Scaricare BLOB

Aggiungere il codice seguente alla fine della main funzione per scaricare il BLOB creato in precedenza nel runtime dell'app.

// Get blob content from position 0 to the end
// In Node.js, get downloaded data by accessing downloadBlockBlobResponse.readableStreamBody
// In browsers, get downloaded data by accessing downloadBlockBlobResponse.blobBody
const downloadBlockBlobResponse = await blockBlobClient.download(0);
console.log("\nDownloaded blob content...");
console.log(
  "\t",
  await streamToText(downloadBlockBlobResponse.readableStreamBody)
);

Il codice precedente chiama il metodo di download .

Copiare il codice seguente dopo la main funzione per convertire nuovamente un flusso in una stringa.

// Convert stream to text
async function streamToText(readable) {
  readable.setEncoding('utf8');
  let data = '';
  for await (const chunk of readable) {
    data += chunk;
  }
  return data;
}

Eliminare un contenitore

Aggiungere questo codice alla fine della main funzione per eliminare il contenitore e tutti i RELATIVI BLOB:

// Delete container
console.log("\nDeleting container...");

const deleteContainerResponse = await containerClient.delete();
console.log(
  "Container was deleted successfully. requestId: ",
  deleteContainerResponse.requestId
);

Il codice precedente pulisce le risorse create dall'app rimuovendo l'intero contenitore usando il metodo delete . È anche possibile eliminare i file locali, se si vuole.

Eseguire il codice

Da un terminale di Visual Studio Code eseguire l'app.
```
node index.js
```

L'output dell'app è simile all'esempio seguente:

Azure Blob storage v12 - JavaScript quickstart sample

Creating container...
         quickstart4a0780c0-fb72-11e9-b7b9-b387d3c488da

Uploading to Azure Storage as blob:
         quickstart4a3128d0-fb72-11e9-b7b9-b387d3c488da.txt

Listing blobs...
         quickstart4a3128d0-fb72-11e9-b7b9-b387d3c488da.txt

Downloaded blob content...
         Hello, World!

Deleting container...
Done

Scorrere il codice nel debugger e controllare il portale di Azure durante il processo. Verificare che il contenitore venga creato. È possibile aprire il BLOB all'interno del contenitore e visualizzarne il contenuto.

Usare l'emulatore di archiviazione

Questa guida introduttiva ha creato un contenitore e un BLOB nel cloud di Azure. È anche possibile usare il pacchetto npm di archiviazione BLOB di Azure per creare queste risorse localmente nell'emulatore di Archiviazione di Azure per lo sviluppo e il test.

Eseguire la pulizia

Al termine di questa guida introduttiva, eliminare la blob-quickstart-v12 directory.
Se si usa la risorsa di archiviazione di Azure, usare l'interfaccia della riga di comando di Azure per rimuovere la risorsa di archiviazione.

Passaggi successivi

In questa guida di avvio rapido si è appreso come caricare, scaricare ed elencare i BLOB con JavaScript.

Per esercitazioni, esempi, guide di avvio rapido e altra documentazione, vedere:

Centro per sviluppatori Azure per JavaScript

Per informazioni su come distribuire un'app Web che usa l'archivio BLOB di Azure, vedere Esercitazione: Caricare i dati immagine nel cloud con Archiviazione di Azure
Per visualizzare le app di esempio di archiviazione BLOB, continuare con gli esempi javaScript della libreria di pacchetti di archiviazione BLOB di Azure v12.
Per altre informazioni, vedere la libreria client di Archiviazione BLOB di Azure per JavaScript.