Esercizio - Caricamenti e download di BLOB

  • 10 minuti

Per interagire con singoli BLOB in Archiviazione BLOB, usare un oggetto BlobClient. È possibile ottenere un oggetto BlobClient richiedendolo con il nome del BLOB da BlobContainerClient in cui si trova il BLOB. BlobClient include metodi per caricare, scaricare e gestire singoli BLOB in Archiviazione BLOB.

Recupero di un oggetto BlobClient

Per ottenere un oggetto BlobClient in base al nome, chiamare i metodi GetBlobClient nell'oggetto BlobContainerClient che contiene il BLOB usando il nome del BLOB. Un oggetto BlobClient consente di interagire con il BLOB caricando, scaricando o gestendo il BLOB in Archiviazione BLOB.

Lo spostamento dei dati da e verso un BLOB è un'operazione di rete che richiede tempo. L'SDK di Archiviazione di Azure per .NET fornisce l'implementazione asincrona di tutti i metodi che richiedono l'attività di rete. Quando possibile, è consigliabile usare queste implementazioni asincrone nell'applicazione.

Quando si usano oggetti dati di grandi dimensioni è consigliabile usare flussi anziché strutture in memoria come matrici di byte o stringhe. Questo approccio consente di evitare il buffering dell'intero contenuto in memoria prima di inviarlo alla destinazione. ASP.NET Core supporta la lettura e la scrittura di flussi da richieste e risposte.

Per ottenere un oggetto BlobClient in base al nome, chiamare i metodi getBlobClient nell'oggetto BlobContainerClient che contiene il BLOB usando il nome del BLOB. Un oggetto BlobClient consente di interagire con il BLOB caricando, scaricando o gestendo il BLOB in Archiviazione BLOB.

Quando si usano oggetti dati di grandi dimensioni è consigliabile usare flussi anziché strutture in memoria come matrici di byte o stringhe. Questo approccio consente di evitare il buffering dell'intero contenuto in memoria prima di inviarlo alla destinazione.

Creare nuovi BLOB

Per creare un nuovo BLOB, chiamare uno dei metodi Upload su un riferimento a un BLOB che non esiste nella risorsa di archiviazione. Questo approccio prevede due operazioni: creazione del BLOB nella risorsa di archiviazione e caricamento dei dati.

BlobClient blobClient = containerClient.GetBlobClient(name);

var response = blobClient.UploadAsync(fileStream);

Per creare un nuovo BLOB, chiamare uno dei metodi upload su un riferimento a un BLOB che non esiste nella risorsa di archiviazione. Questo approccio prevede due operazioni: creazione del BLOB nella risorsa di archiviazione e caricamento dei dati.

BlobClient blobClient = blobContainerClient.getBlobClient(name);
blobClient.upload(inputStream, contentLength);

Esercizio

Completare l'app aggiungendo il codice per il caricamento e il download, quindi distribuirla nel Servizio app di Azure per i test.

Caricamento

Per caricare un BLOB, si implementa il metodo BlobStorage.Save. Per prima cosa, si ottiene un oggetto BlobClient che rappresenta il BLOB chiamando GetBlobClient su un oggetto BlobContainerClient. Si usa quindi il metodo UploadAsync in BlobClient per salvare i dati Stream passati a questo metodo fino ad Archiviazione BLOB.

  • Nell'editor sostituire Save in BlobStorage.cs con il codice seguente. Usare CTRL+S per salvare il lavoro.

    public Task Save(Stream fileStream, string name)
{
    BlobServiceClient blobServiceClient = new BlobServiceClient(storageConfig.ConnectionString);

    // Get the container (folder) the file will be saved in
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(storageConfig.FileContainerName);

    // Get the Blob Client used to interact with (including create) the blob
    BlobClient blobClient = containerClient.GetBlobClient(name);

    // Upload the blob
    return blobClient.UploadAsync(fileStream);
}

    Nota

    Il codice di caricamento basato sul flusso illustrato di seguito è più efficiente rispetto alla lettura del file in una matrice di byte prima dell'invio ad Archiviazione BLOB. Tuttavia, la tecnica ASP.NET Core IFormFile usata per ottenere il file dal client non è un'implementazione di streaming end-to-end vera. Tale tecnica è adatta solo per la gestione di caricamenti di file di piccole dimensioni.

Per caricare un BLOB, si implementa il metodo BlobStorage.save. Per prima cosa, si ottiene un oggetto BlobClient che rappresenta il BLOB chiamando getBlobClient su un oggetto BlobContainerClient. Si usa quindi il metodo upload in BlobClient per salvare i dati InputStream passati a questo metodo fino ad Archiviazione BLOB.

  • Nell'editor sostituire save in BlobStorage.java con il codice seguente.

    public void save(String name, InputStream inputStream, long contentLength) {
    BlobClient blobClient = blobContainerClient.getBlobClient(name);
    blobClient.upload(inputStream, contentLength);
}

Scaricare

Per scaricare un file, viene restituito il metodo OpenReadAsync sull'oggetto BlobClient. Questo metodo restituisce un Stream, il che significa che il codice non deve caricare tutti i byte da Archiviazione BLOB contemporaneamente. È sufficiente restituire un riferimento al flusso BLOB, che ASP.NET Core può usare per trasmettere il file al browser.

  • Sostituire Load con questo codice e salvare il lavoro usando CTRL + S.

    public Task<Stream> Load(string name)
{
    BlobServiceClient blobServiceClient = new BlobServiceClient(storageConfig.ConnectionString);

    // Get the container the blobs are saved in
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(storageConfig.FileContainerName);

    // Get a client to operate on the blob so we can read it.
    BlobClient blobClient = containerClient.GetBlobClient(name);

    return blobClient.OpenReadAsync();
}

Per scaricare un file, usare il metodo openInputStream in BlobClient. Questo metodo restituisce un InputStream, il che significa che il codice non deve caricare tutti i byte da Archiviazione BLOB contemporaneamente. È sufficiente restituire un riferimento al flusso BLOB, che IndexBean può usare per trasmettere il contenuto al browser.

Sostituire read con questo codice e salvare il lavoro.

public InputStream read(String name) {
    BlobClient blobClient = blobContainerClient.getBlobClient(name);
    return blobClient.openInputStream();
}

Distribuire ed eseguire l'app in Azure

L'app è stata completata. Distribuirla e vederla funzionare.

  1. Creare un'app di Servizio app e configurarla con le impostazioni dell'app per la stringa di connessione dell'account di archiviazione e il nome del contenitore. Ottenere la stringa di connessione dell'account di archiviazione con az storage account show-connection-string e impostare il nome del contenitore su files.

    Il nome dell'app deve essere univoco a livello globale. Scegliere il proprio nome da compilare in <your-unique-app-name>. Usare anche il nome dell'account di archiviazione creato in precedenza per sostituire <your-unique-storage-account-name>. Eseguire ognuno dei comandi seguenti nell'ordine indicato nell'interfaccia della riga di comando di Azure:

    az appservice plan create \
--name blob-exercise-plan \
--resource-group "<rgn>[sandbox resource group name]</rgn>" \
--sku FREE --location eastus

    az webapp create \
--name <your-unique-app-name> \
--plan blob-exercise-plan \
--resource-group "<rgn>[sandbox resource group name]</rgn>"

    CONNECTIONSTRING=$(az storage account show-connection-string \
--name <your-unique-storage-account-name> \
--resource-group "<rgn>[sandbox resource group name]</rgn>" \
--output tsv)

    az webapp config appsettings set \
--name <your-unique-app-name> --resource-group "<rgn>[sandbox resource group name]</rgn>" \
--settings AzureStorageConfig:ConnectionString=$CONNECTIONSTRING AzureStorageConfig:FileContainerName=files

  2. Distribuire l'app. I comandi seguenti pubblicano il sito nella cartella pub, lo comprimono in site.zip e distribuiscono il file zip in servizio app.

    Nota

    Assicurarsi che la shell si trovi ancora nella directory mslearn-store-data-in-azure/store-app-data-with-azure-blob-storage/src/start prima di eseguire i comandi seguenti. È possibile usare cd mslearn-store-data-in-azure/store-app-data-with-azure-blob-storage/src/start per passare a questo percorso.

    dotnet publish -o pub
cd pub
zip -r ../site.zip *

    az webapp deploy \
--src-path ../site.zip \
--resource-group "<rgn>[sandbox resource group name]</rgn>" \
--name <your-unique-app-name>

    Per visualizzare l'app in esecuzione, aprire https://<your-unique-app-name>.azurewebsites.net in un browser. Dovrebbe apparire come nell'immagine seguente.

    Screenshot of the FileUploader web app for C#.

  3. Provare a caricare e scaricare alcuni file per testare l'app. Dopo aver caricato alcuni file, per visualizzare i BLOB nel contenitore, eseguire il codice seguente nella shell. Sostituire <your-unique-storage-account-name> con il nome dell'account di archiviazione creato in precedenza nel modulo:

    az storage blob list --account-name <your-unique-storage-account-name> --container-name files --query [].{Name:name} --output table

L'app è stata completata. Distribuirla e vederla funzionare. Usare il plug-in Maven per il Servizio app di Azure per creare un'app del Servizio app, configurarla e distribuirla.

  1. Nell'editor aprire il file pom.xml e aggiungere il seguente plugins sotto il tag xml build.

    <plugins>
   <plugin>
     <groupId>com.microsoft.azure</groupId>
     <artifactId>azure-webapp-maven-plugin</artifactId>
     <version>2.3.0</version>
     <configuration>
       <schemaVersion>v2</schemaVersion>
       <subscriptionId>${env.AZ_SUBSCRIPTION_ID}</subscriptionId>
       <resourceGroup>${env.AZ_RESOURCE_GROUP}</resourceGroup>
       <appName>${env.AZ_APP_NAME}</appName>
       <pricingTier>${env.AZ_PRICING_TIER}</pricingTier>
       <region>${env.AZ_REGION}</region>
       <runtime>
         <os>Linux</os>
         <javaVersion>Java 11</javaVersion>
         <webContainer>Tomcat 9.0</webContainer>
       </runtime>
       <deployment>
         <resources>
           <resource>
             <directory>${project.basedir}/target</directory>
             <includes>
               <include>*.war</include>
             </includes>
           </resource>
         </resources>
       </deployment>
             <appSettings>
               <property>
                  <name>STORAGE_CONNECTION_STRING</name>
                  <value>${env.AZ_STORAGE_CONNECTION_STRING}</value>
               </property>
               <property>
                  <name>STORAGE_CONTAINER_NAME</name>
                  <value>${env.AZ_STORAGE_CONTAINER_NAME}</value>
               </property>
            </appSettings>
     </configuration>
   </plugin>
   <plugin>  
     <groupId>org.apache.maven.plugins</groupId>  
     <artifactId>maven-war-plugin</artifactId>  
     <version>3.3.2</version>  
   </plugin> 
 </plugins>

  2. I comandi seguenti preparano le variabili di ambiente per il plug-in Maven per il Servizio app di Azure. Estrarre la stringa di connessione dell'account di archiviazione con az storage account show-connection-string, l'ID sottoscrizione con az account show e impostare l'area, i prezzi, il nome del contenitore e il nome dell'app. Il nome dell'app deve essere univoco a livello globale. Scegliere il proprio nome da compilare in <your-unique-app-name>.

    export AZ_SUBSCRIPTION_ID=$(az account show --query id --output tsv)
export AZ_RESOURCE_GROUP="<rgn>[sandbox resource group name]</rgn>"
export AZ_REGION=eastus
export AZ_APP_NAME=<your-unique-app-name>
export AZ_PRICING_TIER=F1
export AZ_STORAGE_CONNECTION_STRING=$(az storage account show-connection-string --name <your-unique-storage-account-name> --output tsv)
export AZ_STORAGE_CONTAINER_NAME=files

    Suggerimento

    Il livello minimo consigliato per la distribuzione di applicazioni Java reali è qualsiasi piano di servizio Premium V2.

  3. Distribuire l'app. Il comando seguente compila l'app in ROOT.war e distribuisce il file WAR in Servizio app. Il plug-in Maven per Servizio app di Azure esegue il provisioning delle risorse al primo tentativo di distribuzione.

    Nota

    Assicurarsi che la shell si trovi ancora nella directory mslearn-store-data-in-azure/store-java-ee-application-data-with-azure-blob-storage/start prima di eseguire i comandi seguenti. È possibile usare cd mslearn-store-data-in-azure/store-java-ee-application-data-with-azure-blob-storage/start per passare a questo percorso.

    mvn clean package azure-webapp:deploy

    Per visualizzare l'app in esecuzione, aprire https://<your-unique-app-name>.azurewebsites.net in un browser. Dovrebbe apparire come nell'immagine seguente.

    Screenshot of the FileUploader web app for Java.

    Suggerimento

    Questo modulo usa il plug-in Maven per il Servizio app di Azure per distribuire l'app in Tomcat 9 in tale servizio. Per altre opzioni, vedere la sezione Altre informazioni alla fine di questo modulo.

  4. Provare a caricare e scaricare alcuni file per testare l'app. Dopo aver caricato alcuni file, per visualizzare i BLOB nel contenitore, eseguire il codice seguente nella shell.

    az storage blob list --account-name <your-unique-storage-account-name> --container-name files --query [].{Name:name} --output table