Lab 03: Recuperare le risorse e dei metadati di Archiviazione di Azure usando Azure Storage SDK per .NET

Interfaccia utente di Microsoft Azure

Considerata la natura dinamica degli strumenti cloud di Microsoft, è possibile rilevare modifiche all’interfaccia utente di Azure apportate dopo lo sviluppo di questo contenuto per la formazione. È quindi possibile che le istruzioni e le procedure del lab non siano allineate correttamente.

Microsoft aggiorna questo corso di formazione quando la community segnala le modifiche necessarie. Poiché gli aggiornamenti cloud vengono apportati spesso, tuttavia, è possibile che si rilevino modifiche all’interfaccia utente prima degli aggiornamenti del contenuto per la formazione. In questo caso, adattarsi alle modifiche e quindi eseguire le operazioni necessarie nei lab.

Istruzioni

Prima di iniziare

Accedere all’ambiente lab

Accedere alla macchina virtuale Windows 10 usando le credenziali seguenti:

  • Nome utente: Admin

  • Password: Pa55w.rd

Nota: il docente fornirà le istruzioni necessarie per la connessione all’ambiente lab virtuale.

Esaminare le applicazioni installate

Trovare la barra delle applicazioni nel desktop di Windows 10. La barra delle applicazioni include le icone per le applicazioni che verranno usate nel lab, tra cui:

  • Microsoft Edge

  • Esplora file

Diagramma dell’architettura

Diagramma dell'architettura che illustra un utente che recupera risorse e metadati di Archiviazione di Azure usando Azure Storage SDK per .NET.

Esercizio 1: Creare risorse di Azure

Attività 1: Aprire il portale di Azure

  1. Sulla barra delle applicazioni selezionare l’icona di Microsoft Edge.

  2. Nella finestra del browser passare al portale di Azure (https://portal.azure.com) e quindi accedere con l’account che verrà usato per questo lab.

    Nota: se si sta eseguendo l’accesso al portale di Azure per la prima volta, verrà visualizzata una presentazione del portale. Selezionare Attività iniziali per ignorare la presentazione e iniziare a usare il portale.

Attività 2: Creare un account di archiviazione

  1. Nel portale di Azure usare la casella di testo Cerca risorse, servizi e documentazione per cercare Account di archiviazione e quindi nell’elenco di risultati selezionare Account di archiviazione.

  2. Nel riquadro Account di archiviazione selezionare + Crea.

  3. Nella scheda Informazioni di base del pannello Crea un account di archiviazione eseguire le azioni seguenti e selezionare Rivedi:

Impostazione Azione
Elenco a discesa Sottoscrizione Mantenere il valore predefinito
Sezione Gruppo di risorse Selezionare Crea nuovo, immettere StorageMedia e quindi selezionare OK
Casella di testo Nome account di archiviazione  Immettere mediastor [nomeutente]
Elenco a discesa Area Selezionare (Stati Uniti) Stati Uniti orientali
Sezione Prestazioni Selezionare l’opzione Standard
Elenco a discesa Ridondanza Selezionare Archiviazione con ridondanza locale

Lo screenshot seguente mostra le impostazioni configurate nel pannello Crea un account di archiviazione.

Pannello Crea un account di archiviazione

  1. Nella scheda Rivedi esaminare le opzioni selezionate durante i passaggi precedenti.

  2. Selezionare Crea per creare l’account di archiviazione usando la configurazione specificata.

    Nota: prima di procedere con il lab, attendere il completamento dell’attività di creazione.

  3. Selezionare Vai alla risorsa.

  4. Nel pannello  Account di archiviazione  selezionare il collegamento  Endpoint  nella sezione  Impostazioni .

  5. Nella sezione Endpoint copiare il valore della casella di testo Servizio BLOB negli Appunti.

    Nota: questo valore dell’endpoint verrà utilizzato più avanti nel lab.

  6. Aprire il Blocco note e quindi incollare il valore del servizio BLOB copiato nel Blocco note.

  7. Nella sezione Sicurezza e rete del pannello Account di archiviazione selezionare Chiavi di accesso.

  8. Copiare il valore di Nome dell’account di archiviazione negli Appunti e incollarlo nel Blocco note.

  9. Nel pannello Chiavi di accesso selezionare Mostra chiavi.

  10. Esaminare le chiavi e quindi copiare il valore di una delle caselle Chiave negli Appunti.

    Nota: tutti questi valori verranno utilizzati più avanti in questo lab.

Verifica

In questo esercizio è stato creato un nuovo account Archiviazione da usare nel resto del lab.

Esercizio 2: Caricare un BLOB in un contenitore

Attività 1: Creare contenitori di account di archiviazione

  1. Nel pannello Account di archiviazione selezionare il collegamento Contenitori nella sezione Archiviazione dati.

  2. Nella sezione Contenitori selezionare + Contenitore.

  3. Nella finestra popup Nuovo contenitore eseguire le azioni seguenti e quindi selezionare Crea:

    Impostazione Azione
    Casella di testo Nome Immettere raster-graphics
    Elenco a discesa Livello di accesso pubblico Selezionare Privato (nessun accesso anonimo)

  4. Nella sezione Contenitori selezionare + Contenitore.

  5. Nella finestra popup Nuovo contenitore eseguire le azioni seguenti e quindi selezionare Crea:

    Impostazione Azione
    Casella di testo Nome Immettere compressed-audio
    Elenco a discesa Livello di accesso pubblico Selezionare Privato (nessun accesso anonimo)

  6. Nella sezione Contenitori osservare l’elenco aggiornato dei contenitori.

    Lo screenshot seguente mostra le impostazioni configurate nel pannello Crea un account di archiviazione.

    Pannello Crea un account di archiviazione

Attività 2: Caricare un BLOB dell’account di archiviazione

  1. Nella sezione Contenitori selezionare il contenitore raster-graphics creato di recente.

  2. Nel pannello Contenitore selezionare Carica.

  3. Nella finestra Carica BLOB eseguire le azioni seguenti e quindi selezionare Carica:

Impostazione Azione
Sezione File Selezionare l’icona Cartella
Finestra Esplora file Passare a Allfiles (F):\Allfiles\Labs\03\Starter\Images, selezionare il file graph.jpg e quindi selezionare Apri
Casella di controllo Sovrascrivi se i file esistono già Assicurarsi che la casella di controllo sia selezionata

Nota: prima di procedere con questo lab, attendere il completamento del caricamento del BLOB.

Verifica

In questo esercizio sono stati creati contenitori segnaposto nell’account di archiviazione e quindi uno dei contenitori è stato popolato con un BLOB.

Esercizio 3: Accedere ai contenitori con .NET SDK

Attività 1: Creare un progetto .NET

  1. Nella schermata Start selezionare il riquadro Visual Studio Code.

  2. Nel menu File selezionare Apri cartella, passare a Allfiles (F):\Allfiles\Labs\03\Starter\BlobManager, quindi scegliere Seleziona cartella.

  3. Nella finestra di Visual Studio Code, nella barra dei menu, selezionare Terminale e quindi Nuovo terminale.

  4. Nel terminale eseguire il comando seguente per creare un nuovo progetto .NET denominato BlobManager nella cartella corrente:

    dotnet new console --framework net6.0 --name BlobManager --output .

    Nota: il comando dotnet new creerà un nuovo progetto console in una cartella con lo stesso nome del progetto.

  5. Nel terminale eseguire il comando seguente per importare la versione 12.12.0 di Azure.Storage.Blobs da NuGet:

    dotnet add package Azure.Storage.Blobs --version 12.12.0

    Nota: il comando dotnet add package aggiungerà il pacchetto Azure.Storage.Blobs da NuGet. Per altre informazioni, vedere Azure.Storage.Blobs.

  6. Nel terminale eseguire il comando seguente per compilare l’applicazione Web .NET:

    dotnet build

  7. Selezionare Termina il terminale o l’icona del Cestino per chiudere il terminale aperto e tutti i processi associati.

Attività 2: Modificare la classe Program per accedere alla risorsa di archiviazione

  1. Nel riquadro Esplora risorse  della finestra di Visual Studio Code aprire il file Program.cs.

  2. Nella scheda dell’editor di codice per il file  Program.cs eliminare tutto il codice nel file esistente.

  3. Aggiungere la riga di codice seguente per importare gli spazi dei nomi Azure.Storage, Azure.Storage.Blobs e Azure.Storage.Blobs.Models dal pacchetto Azure.Storage.Blobs importato da NuGet:

    using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;

  4. Aggiungere le righe di codice seguenti per aggiungere direttive using per gli spazi dei nomi predefiniti che verranno usati in questo file:

    using System;
using System.Threading.Tasks;

  5. Immettere il codice seguente per creare una nuova classe Program:

    public class Program
{
}

  6. Nella classe Program immettere la riga di codice seguente per creare una nuova costante di tipo stringa denominata blobServiceEndpoint:

    private const string blobServiceEndpoint = "";

  7. Aggiornare la costante di tipo stringa blobServiceEndpoint impostandone il valore sull’ Endpoint di servizio BLOB primario dell’account di archiviazione registrato in precedenza in questo lab.

  8. Nella classe Program immettere la riga di codice seguente per creare una nuova costante di tipo stringa denominata storageAccountName:

    private const string storageAccountName = "";

  9. Aggiornare la costante di tipo stringa storageAccountName impostandone il valore sul  nome dell’account di archiviazione registrato in precedenza in questo lab.

  10. Nella classe Program immettere la riga di codice seguente per creare una nuova costante di tipo stringa denominata storageAccountKey:

    private const string storageAccountKey = "";

  11. Aggiornare la costante di tipo stringa storageAccountKey impostandone il valore sulla  chiave dell’account di archiviazione registrato in precedenza in questo lab.

  12. Nella classe Program immettere il codice seguente per creare un nuovo metodo Main asincrono:

    public static async Task Main(string[] args)
{
}

  13. Esaminare il file Program.cs, che ora dovrebbe includere:

    using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System;
using System.Threading.Tasks;    
public class Program
{
    private const string blobServiceEndpoint = "<primary-blob-service-endpoint>";
    private const string storageAccountName = "<storage-account-name>";
    private const string storageAccountKey = "<key>";    
    public static async Task Main(string[] args)
    {
    }
}

Attività 3: Connettersi all’endpoint del servizio BLOB di Archiviazione di Azure

  1. Nel metodo Main aggiungere la riga di codice seguente per creare una nuova istanza della classe StorageSharedKeyCredential usando le costanti storageAccountName e storageAccountKey come parametri del costruttore:

    StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);

  2. Nel metodo Main aggiungere la riga di codice seguente per creare una nuova istanza della classe BlobServiceClient usando la costante blobServiceEndpoint e la variabile accountCredentials come parametri del costruttore:

    BlobServiceClient serviceClient = new BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);

  3. Nel metodo Main aggiungere la riga di codice seguente per richiamare il metodo GetAccountInfoAsync della classe BlobServiceClient per recuperare i metadati dell’account dal servizio:

    AccountInfo info = await serviceClient.GetAccountInfoAsync();

  4. Nel metodo Main aggiungere la riga di codice seguente per eseguire il rendering di un messaggio di benvenuto:

    await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");

  5. Nel metodo Main aggiungere la riga di codice seguente per eseguire il rendering del nome dell’account di archiviazione:

    await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");

  6. Nel metodo Main aggiungere la riga di codice seguente per eseguire il rendering del tipo di account di archiviazione:

    await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");

  7. Nel metodo Main aggiungere la riga di codice seguente per eseguire il rendering dello SKU attualmente selezionato per l’account di archiviazione:

    await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");

  8. Esaminare il metodo Main, che ora dovrebbe includere:

    public static async Task Main(string[] args)
{
    StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
    BlobServiceClient serviceClient = new BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
    AccountInfo info = await serviceClient.GetAccountInfoAsync();
    await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
    await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
    await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
    await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
}

  9. Salvare il file Program.cs .

  10. Nella finestra di Visual Studio Code, nella barra dei menu, selezionare Terminale e quindi Nuovo terminale.

  11. Nel terminale eseguire il comando seguente per eseguire l’applicazione Web .NET:

    dotnet run

    Nota: se si verificano errori di compilazione, esaminare il file Program.cs nella cartella Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  12. Osservare l’output dell’applicazione console attualmente in esecuzione. L’output contiene i metadati per l’account di archiviazione recuperato dal servizio.

  13. Selezionare Termina il terminale o l’icona del Cestino per chiudere il terminale aperto e tutti i processi associati.

Attività 4: Enumerare i contenitori esistenti

  1. Nella classe Program immettere il codice seguente per creare un nuovo metodo statico privato denominato EnumerateContainersAsync, asincrono e con un singolo tipo di parametro BlobServiceClient:

    private static async Task EnumerateContainersAsync(BlobServiceClient client)
{        
}

  2. Nel metodo EnumerateContainersAsync immettere il codice seguente per creare un ciclo foreach asincrono che esegue l’iterazione sui risultati di una chiamata del metodo GetBlobContainersAsync della classe BlobServiceClient:

    await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
{
}

  3. All’interno del ciclo foreach immettere il codice seguente per stampare il nome di ogni contenitore:

    await Console.Out.WriteLineAsync($"Container:\t{container.Name}");

  4. Esaminare il metodo EnumerateContainersAsync, che ora dovrebbe includere:

    private static async Task EnumerateContainersAsync(BlobServiceClient client)
{        
    await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
    {
        await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
    }
}

  5. Nel metodo Main immettere il codice seguente alla fine del metodo per richiamare il metodo EnumerateContainersAsync, passando la variabile serviceClient come parametro:

    await EnumerateContainersAsync(serviceClient);
  6. Osservare il file Program.cs, che ora dovrebbe includere: 
    using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System;
using System.Threading.Tasks;
    
public class Program
{
    private const string blobServiceEndpoint = "your blobServiceEndpoint";
    private const string storageAccountName = "your storageAccountName";
    private const string storageAccountKey = "your storageAccountKey";    
    public static async Task Main(string[] args)
    {
        StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
        BlobServiceClient serviceClient = new     BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
        AccountInfo info = await serviceClient.GetAccountInfoAsync();
        await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
        await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
        await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
        await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
        await EnumerateContainersAsync(serviceClient);
    }        
    private static async Task EnumerateContainersAsync(BlobServiceClient client)
    {        
        await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
        {
            await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
        }
}
}

  7. Salvare il file Program.cs .

  8. Nella finestra di Visual Studio Code, nella barra dei menu, selezionare Terminale e quindi Nuovo terminale.

  9. Nel terminale eseguire il comando seguente per eseguire l’applicazione Web .NET:

    dotnet run

    Nota: se si verificano errori di compilazione, esaminare il file Program.cs nella cartella Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  10. Osservare l’output dell’applicazione console attualmente in esecuzione. L’output aggiornato include un elenco di tutti i contenitori esistenti nell’account.

  11. Selezionare Termina il terminale o l’icona del Cestino per chiudere il terminale aperto e tutti i processi associati.

Verifica

In questo esercizio è stato eseguito l’accesso ai contenitori esistenti usando Azure Storage SDK.

Esercizio 4: Recuperare gli URI (Uniform Resource Identifier) dei BLOB con .NET SDK

Attività 1: Enumerare i BLOB in un contenitore esistente usando l’SDK

  1. Nella classe Program immettere il codice seguente per creare un nuovo metodo statico privato denominato EnumerateBlobsAsync, asincrono e con due tipi di parametro, ovvero BlobServiceClient e string:

    private static async Task EnumerateBlobsAsync(BlobServiceClient client, string containerName)
{      
}

  2. Nel metodo EnumerateBlobsAsync immettere il codice seguente per ottenere una nuova istanza della classe BlobContainerClient usando il metodo GetBlobContainerClient della classe BlobServiceClient, passando il parametro containerName:

    BlobContainerClient container = client.GetBlobContainerClient(containerName);

  3. Nel metodo EnumerateBlobsAsync immettere il codice seguente per eseguire il rendering del nome del contenitore che verrà enumerato:

    await Console.Out.WriteLineAsync($"Searching:\t{container.Name}");

  4. Nel metodo EnumerateBlobsAsync immettere il codice seguente per creare un ciclo foreach asincrono che esegue l’iterazione sui risultati di una chiamata del metodo GetBlobsAsync della classe BlobContainerClient:

    await foreach (BlobItem blob in container.GetBlobsAsync())
{        
}

  5. All’interno del ciclo foreach immettere il codice seguente per stampare il nome di ogni BLOB:

     await Console.Out.WriteLineAsync($"Existing Blob:\t{blob.Name}");

  6. Esaminare il metodo EnumerateBlobsAsync, che ora dovrebbe includere:

    private static async Task EnumerateBlobsAsync(BlobServiceClient client, string containerName)
{      
    BlobContainerClient container = client.GetBlobContainerClient(containerName);
    await Console.Out.WriteLineAsync($"Searching:\t{container.Name}");
    await foreach (BlobItem blob in container.GetBlobsAsync())
    {        
         await Console.Out.WriteLineAsync($"Existing Blob:\t{blob.Name}");
    }
}

  7. Nel metodo Main immettere il codice seguente alla fine del metodo per creare una variabile denominata existingContainerName con un valore raster-graphics:

    string existingContainerName = "raster-graphics";

  8. Nel metodo Main immettere il codice seguente alla fine del metodo per richiamare il metodo EnumerateBlobsAsync, passando le variabili serviceClient ed existingContainerName come parametri:

    await EnumerateBlobsAsync(serviceClient, existingContainerName);
  9. Osservare il file Program.cs, che ora dovrebbe includere: 
    using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System;
using System.Threading.Tasks;    
public class Program
{
    private const string blobServiceEndpoint = "your blobServiceEndpoint";
    private const string storageAccountName = "your storageAccountName";
    private const string storageAccountKey = "your storageAccountKey";    
    public static async Task Main(string[] args)
    {
        StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
        BlobServiceClient serviceClient = new   BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
        AccountInfo info = await serviceClient.GetAccountInfoAsync();
        await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
        await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
        await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
        await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
        await EnumerateContainersAsync(serviceClient);
        string existingContainerName = "raster-graphics";
        await EnumerateBlobsAsync(serviceClient, existingContainerName);
    }        
    private static async Task EnumerateContainersAsync(BlobServiceClient client)
    {        
        await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
        {
            await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
        }
    }        
    private static async Task EnumerateBlobsAsync(BlobServiceClient client, string containerName)
    {      
        BlobContainerClient container = client.GetBlobContainerClient(containerName);await Console.Out.WriteLineAsync($"Searching:\t{container.Name}");
        await foreach (BlobItem blob in container.GetBlobsAsync())
        {        
            await Console.Out.WriteLineAsync($"Existing Blob:\t{blob.Name}");
        }
    }
}

  10. Salvare il file Program.cs .

  11. Nella finestra di Visual Studio Code, nella barra dei menu, selezionare Terminale e quindi Nuovo terminale.

  12. Nel terminale eseguire il comando seguente per eseguire l’applicazione Web .NET:

    dotnet run

    Nota: se si verificano errori di compilazione, esaminare il file Program.cs nella cartella Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  13. Osservare l’output dell’applicazione console attualmente in esecuzione. L’output aggiornato include i metadati relativi al contenitore e ai BLOB esistenti.

  14. Selezionare Termina il terminale o l’icona del Cestino per chiudere il terminale aperto e tutti i processi associati.

Attività 2: Creare un nuovo contenitore usando l’SDK

  1. Nella classe Program immettere il codice seguente per creare un nuovo metodo statico privato denominato GetContainerAsync, asincrono e con due tipi di parametro, ovvero BlobServiceClient e string:

    private static async Task<BlobContainerClient> GetContainerAsync(BlobServiceClient client, string containerName)
{      
}

  2. Nel metodo GetContainerAsync immettere il codice seguente per ottenere una nuova istanza della classe BlobContainerClient usando il metodo GetBlobContainerClient della classe BlobServiceClient, passando il parametro containerName:

    BlobContainerClient container = client.GetBlobContainerClient(containerName);

  3. Nel metodo GetContainerAsync immettere il codice seguente per richiamare il metodo CreateIfNotExistsAsync della classe BlobContainerClient:

    await container.CreateIfNotExistsAsync(PublicAccessType.Blob);

  4. Nel metodo GetContainerAsync immettere il codice seguente per eseguire il rendering del nome del contenitore che verrà potenzialmente creato:

    await Console.Out.WriteLineAsync($"New Container:\t{container.Name}");

  5. Nel metodo GetContainerAsync immettere il codice seguente per restituire l’istanza della classe BlobContainerClient denominata container come risultato del metodo GetContainerAsync:

    return container;

  6. Esaminare il metodo GetContainerAsync, che ora dovrebbe includere:

    private static async Task<BlobContainerClient> GetContainerAsync(BlobServiceClient client, string containerName)
{      
    BlobContainerClient container = client.GetBlobContainerClient(containerName);
    await container.CreateIfNotExistsAsync(PublicAccessType.Blob);
    await Console.Out.WriteLineAsync($"New Container:\t{container.Name}");        
    return container;
}

  7. Nel metodo Main immettere il codice seguente alla fine del metodo per creare una variabile denominata newContainerName con un valore vector-graphics:

    string newContainerName = "vector-graphics";

  8. Nel metodo Main immettere il codice seguente alla fine del metodo per richiamare il metodo GetContainerAsync, per passare le variabili serviceClient e newContainerName come parametri e per archiviare il risultato in una variabile denominata containerClient di tipo BlobContainerClient:

    BlobContainerClient containerClient = await GetContainerAsync(serviceClient, newContainerName);
  9. Esaminare il file Program.cs, che ora dovrebbe includere: 
    using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System;
using System.Threading.Tasks;    
public class Program
{
    private const string blobServiceEndpoint = "your blobServiceEndpoint";
    private const string storageAccountName = "your storageAccountName";
    private const string storageAccountKey = "your storageAccountKey";
    public static async Task Main(string[] args)
    {
        StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
        BlobServiceClient serviceClient = new BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
        AccountInfo info = await serviceClient.GetAccountInfoAsync();
        await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
        await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
        await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
        await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
        await EnumerateContainersAsync(serviceClient);
        string existingContainerName = "raster-graphics";
        await EnumerateBlobsAsync(serviceClient, existingContainerName);
        string newContainerName = "vector-graphics";
        BlobContainerClient containerClient = await GetContainerAsync(serviceClient, newContainerName);
    }        
    private static async Task EnumerateContainersAsync(BlobServiceClient client)
    {        
        await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
        {
            await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
        }
    }        
    private static async Task EnumerateBlobsAsync(BlobServiceClient client, string containerName)
    {      
        BlobContainerClient container = client.GetBlobContainerClient(containerName);await Console.Out.WriteLineAsync($"Searching:\t{container.Name}");
        await foreach (BlobItem blob in container.GetBlobsAsync())
        {        
            await Console.Out.WriteLineAsync($"Existing Blob:\t{blob.Name}");
        }
    }        
    private static async Task<BlobContainerClient> GetContainerAsync(BlobServiceClient client, string containerName)
    {      
        BlobContainerClient container = client.GetBlobContainerClient(containerName);
        await container.CreateIfNotExistsAsync(PublicAccessType.Blob);
        await Console.Out.WriteLineAsync($"New Container:\t{container.Name}");
        return container;
    }
}

  10. Salvare il file Program.cs .

  11. Nella finestra di Visual Studio Code, nella barra dei menu, selezionare Terminale e quindi Nuovo terminale.

  12. Nel terminale eseguire il comando seguente per eseguire l’applicazione Web .NET:

    dotnet run

    Nota: se si verificano errori di compilazione, esaminare il file Program.cs nella cartella Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  13. Osservare l’output dell’applicazione console attualmente in esecuzione. L’output aggiornato include i metadati relativi al contenitore e ai BLOB esistenti.

  14. Selezionare Termina il terminale o l’icona del Cestino per chiudere il terminale aperto e tutti i processi associati.

Attività 3: Caricare un nuovo BLOB tramite il portale

  1. Nel riquadro di spostamento del portale di Azure selezionare il collegamento Gruppi di risorse.

  2. Nel pannello Gruppi di risorse selezionare il gruppo di risorse StorageMedia creato in precedenza in questo lab.

  3. Nel pannello StorageMedia selezionare l’account di archiviazione mediastor [nomeutente] creato in precedenza in questo lab.

  4. Nel pannello Account di archiviazione selezionare il collegamento Contenitori nella sezione Archiviazione dati.

  5. Nella sezione Contenitori selezionare il contenitore vector-graphics appena creato. Potrebbe essere necessario aggiornare la pagina per osservare il nuovo contenitore.

  6. Nel pannello Contenitore selezionare Carica.

  7. Nella finestra Carica BLOB eseguire le azioni seguenti e quindi selezionare Carica:

    Impostazione Azione
    Nella sezione File selezionare l’icona Cartella  
    Finestra Esplora file Allfiles (F):\Allfiles\Labs\03\Starter\Images, selezionare il file graph.svg e quindi Apri
    Casella di controllo Sovrascrivi se i file esistono già Assicurarsi che la casella di controllo sia selezionata

    Nota: prima di procedere con questo lab, attendere il completamento del caricamento del BLOB.

Attività 4: Accedere all’URI del BLOB usando l’SDK

  1. Tornare alla finestra di Visual Studio Code.

  2. Nella classe Program immettere il codice seguente per creare un nuovo metodo statico privato denominato GetBlobAsync, asincrono e con due tipi di parametro, ovvero BlobContainerClient e string:

    private static async Task<BlobClient> GetBlobAsync(BlobContainerClient client, string blobName)
{      
}

  3. Nel metodo GetBlobAsync immettere il codice seguente per ottenere una nuova istanza della classe BlobClient usando il metodo GetBlobClient della classe BlobContainerClient, passando il parametro blobName:

    BlobClient blob = client.GetBlobClient(blobName);

  4. Nel metodo GetBlobAsync immettere il codice seguente per eseguire il rendering del nome del BLOB a cui è stato fatto riferimento:

    await Console.Out.WriteLineAsync($"Blob Found:\t{blob.Name}");

  5. Nel metodo GetBlobAsync immettere il codice seguente per restituire l’istanza della classe BlobClient denominata blob come risultato del metodo GetBlobAsync:

    return blob;

  6. Esaminare il metodo GetBlobAsync, che ora dovrebbe includere:

    private static async Task<BlobClient> GetBlobAsync(BlobContainerClient client, string blobName)
{      
    BlobClient blob = client.GetBlobClient(blobName);
    await Console.Out.WriteLineAsync($"Blob Found:\t{blob.Name}");
    return blob;
}

  7. Nel metodo Main immettere il codice seguente alla fine del metodo per creare una variabile denominata uploadedBlobName con un valore graph.svg:

    string uploadedBlobName = "graph.svg";

  8. Nel metodo Main immettere il codice seguente alla fine del metodo per richiamare il metodo GetBlobAsync, passando le variabili containerClient e uploadedBlobName come parametri e per archiviare il risultato in una variabile denominata blobClient di tipo BlobClient:

    BlobClient blobClient = await GetBlobAsync(containerClient, uploadedBlobName);

  9. Nel metodo Main immettere il codice seguente alla fine del metodo per eseguire il rendering della proprietà Uri della variabile blobClient:

    await Console.Out.WriteLineAsync($"Blob Url:\t{blobClient.Uri}");
  10. Osservare il file Program.cs, che ora dovrebbe includere: 
    using Azure.Storage;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using System;
using System.Threading.Tasks;    
public class Program
{
    private const string blobServiceEndpoint = "your blobServiceEndpoint";
    private const string storageAccountName = "your storageAccountName";
    private const string storageAccountKey = "your storageAccountKey";    
    public static async Task Main(string[] args)
    {
        StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
        BlobServiceClient serviceClient = new BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
        AccountInfo info = await serviceClient.GetAccountInfoAsync();
        await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
        await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
        await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
        await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
        await EnumerateContainersAsync(serviceClient);
        string existingContainerName = "raster-graphics";
        await EnumerateBlobsAsync(serviceClient, existingContainerName);
        string newContainerName = "vector-graphics";
        BlobContainerClient containerClient = await GetContainerAsync(serviceClient, newContainerName);
        string uploadedBlobName = "graph.svg";
        BlobClient blobClient = await GetBlobAsync(containerClient, uploadedBlobName);
        await Console.Out.WriteLineAsync($"Blob Url:\t{blobClient.Uri}");
    }        
    private static async Task EnumerateContainersAsync(BlobServiceClient client)
    {        
        await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
        {
            await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
        }
    }        
    private static async Task EnumerateBlobsAsync(BlobServiceClient client, string containerName)
    {      
        BlobContainerClient container = client.GetBlobContainerClient(containerName);
        await Console.Out.WriteLineAsync($"Searching:\t{container.Name}");
        await foreach (BlobItem blob in container.GetBlobsAsync())
        {        
            await Console.Out.WriteLineAsync($"Existing Blob:\t{blob.Name}");
        }
    }        
    private static async Task<BlobContainerClient> GetContainerAsync(BlobServiceClient client, string containerName)
    {      
        BlobContainerClient container = client.GetBlobContainerClient(containerName);

        await container.CreateIfNotExistsAsync(PublicAccessType.Blob);
        await Console.Out.WriteLineAsync($"New Container:\t{container.Name}");
        return container;
    }        
    private static async Task<BlobClient> GetBlobAsync(BlobContainerClient client, string blobName)
    {      
        BlobClient blob = client.GetBlobClient(blobName);
        await Console.Out.WriteLineAsync($"Blob Found:\t{blob.Name}");
        return blob;
    }
}

  11. Salvare il file Program.cs .

  12. Nella finestra di Visual Studio Code attivare il menu di scelta rapida per il riquadro Esplora risorse e quindi selezionare Apri nel terminale integrato.

  13. Dal prompt dei comandi aperto usare il comando seguente per eseguire l’applicazione Web .NET:

    dotnet run

    Nota: se si verificano errori di compilazione, esaminare il file Program.cs nella cartella Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  14. Osservare l’output dell’applicazione console attualmente in esecuzione. L’output aggiornato include l’URL finale per accedere al BLOB online. Registrare il valore di questo URL da usare in un secondo momento nel lab.

    Nota: l’URL sarà probabilmente simile alla stringa seguente: https://mediastor*[yourname]*.blob.core.windows.net/vector-graphics/graph.svg

  15. Selezionare Termina il terminale o l’icona del Cestino per chiudere il terminale aperto e tutti i processi associati.

Attività 5: Testare l’URI usando un browser

  1. Sulla barra delle applicazioni attivare il menu di scelta rapida per l’icona di Microsoft Edge e quindi selezionare Nuova finestra.

  2. Nella nuova finestra del browser fare riferimento all’URL copiato in precedenza in questo lab per il BLOB.

  3. Si noterà ora il file SVG (Scalable Vector Graphics) nella finestra del browser.

Verifica

In questo esercizio sono stati creati contenitori e sono stati gestiti BLOB usando Storage SDK.

Esercizio 5: Pulire la sottoscrizione

Attività 1: Aprire Azure Cloud Shell

  1. Nel portale di Azure selezionare l’icona di Cloud Shell Icona di Cloud Shell per aprire una nuova sessione di Bash. Se in Cloud Shell viene aperta per impostazione predefinita una sessione di PowerShell, selezionare PowerShell e nel menu a discesa selezionare Bash.

    Nota: se è la prima volta che si avvia Cloud Shell, quando viene richiesto di selezionare Bash oppure PowerShell selezionare PowerShell. Quando viene visualizzato il messaggio Non sono state montate risorse di archiviazione, selezionare la sottoscrizione usata in questo lab e quindi selezionare Crea risorsa di archiviazione.

Attività 2: Eliminare un gruppo di risorse

  1. Nel riquadro Cloud Shell eseguire il comando seguente per eliminare il gruppo di risorse StorageMedia:

    az group delete --name StorageMedia --no-wait --yes

    Nota: il comando viene eseguito in modo asincrono, in base a quanto determinato dal parametro –no-wait, quindi, sebbene sia possibile eseguire un altro comando dell’interfaccia della riga di comando di Azure immediatamente dopo nella stessa sessione Bash, il gruppo di risorse verrà effettivamente rimosso dopo alcuni minuti.

  2. Chiudere il riquadro Cloud Shell nel portale.

  3. Chiudere Visual Studio Code.

Attività 3: Chiudere l’applicazione attiva

  • Chiudere l’applicazione Microsoft Edge in esecuzione.

Verifica

In questo esercizio è stata pulita la sottoscrizione mediante la rimozione del gruppo di risorse usato in questo lab.