Lab 03 : Récupérer des ressources et métadonnées de Stockage Azure à l’aide du Kit de développement logiciel (SDK) Stockage Azure pour .NET

Interface utilisateur Microsoft Azure

Étant donné la nature dynamique des outils cloud Microsoft, il se peut que vous constatiez des modifications de l’interface utilisateur Azure après le développement du contenu de cette formation. Il se peut donc que certaines instructions et étapes du labo ne s’alignent pas correctement.

Microsoft met ce cours à jour quand la communauté l’alerte sur la nécessité d’y apporter des modifications. Toutefois, compte tenu de la fréquence des mises à jour cloud, il se peut que vous rencontriez des modifications de l’interface utilisateur avant les mises à jour du contenu de cette formation. Si cela se produit, adaptez-vous aux changements, puis appliquez-les dans les laboratoires si nécessaire.

Instructions

Avant de commencer

Se connecter à l’environnement de labo

Connectez-vous à votre machine virtuelle (VM) Windows 11 en utilisant les informations d’identification suivantes :

  • Nom d’utilisateur : Admin
  • Mot de passe : Pa55w.rd

Remarque : Votre instructeur vous fournira des instructions pour la connexion à l’environnement de laboratoire virtuel.

Passer en revue les applications installées

Recherchez la barre des tâches sur votre bureau Windows 11. La barre des tâches contient les icônes des applications que vous allez utiliser dans ce labo, à savoir :

  • Microsoft Edge
  • Explorateur de fichiers

Scénario de laboratoire

Dans ce labo, vous allez apprendre à utiliser le Kit de développement logiciel (SDK) Stockage Azure pour accéder aux conteneurs Stockage Azure au sein d’une application C#. Vous apprendrez aussi à accéder aux métadonnées et à exposer les informations d’URI pour accéder au contenu des conteneurs dans le compte de stockage.

Visionnez cette vidéo en cliquant avec le bouton droit sur ce lien de vidéo , puis sélectionnez « Ouvrir le lien dans un nouvel onglet / une nouvelle fenêtre ».

Décoratif

Diagramme de l’architecture

Diagramme d’architecture montrant un utilisateur en train de récupérer des ressources et métadonnées de Stockage Azure à l’aide du Kit de développement logiciel (SDK) Stockage Azure pour .NET.

Exercice 1 : Créer des ressources Azure

Tâche 1 : Ouvrir le portail Azure

  1. Dans la barre des tâches, sélectionnez l’icône Microsoft Edge.

  2. Dans la fenêtre du navigateur, accédez au portail Azure à l’adresse https://portal.azure.com, puis connectez-vous avec le compte que vous allez utiliser pour ce labo.

    Remarque : Si vous vous connectez au portail Azure la première fois, une visite guidée du portail vous sera proposée. Sélectionnez Prise en main pour faire l’impasse sur la visite guidée et commencer à utiliser le portail.

Tâche 2 : Créer un compte de stockage

  1. Dans le portail Azure, utilisez la zone de texte Rechercher des ressources, des services et des documents pour rechercher Comptes de stockage, puis, dans la liste des résultats, sélectionnez Comptes de stockage.

  2. Dans le volet Comptes de stockage, sélectionnez + Créer.

  3. Dans le volet Créer un compte de stockage, sous l’onglet Informations de base, effectuez les actions suivantes, puis sélectionnez Suivant : Avancé :

    Setting Action
    Liste déroulante  Abonnement Conservez les valeurs par défaut.
    Section Groupe de ressources Sélectionnez Créer, entrez StorageMedia, puis sélectionnez OK
    Zone de texte Nom de compte de stockage Entrez mediastor [votrenom]
    Liste déroulante Région Sélectionnez (États-Unis) USA Est
    Service principal Pas de changements
    Section Performance Sélectionnez l’option Standard.
    Liste déroulante Redondance Sélectionnez Stockage localement redondant (LRS) .

    La capture d’écran suivante affiche les paramètres configurés dans le volet Créer un compte de stockage.

    Volet Créer un compte de stockage.

  4. Sous l’onglet Avancé, vérifiez que l’option Autoriser l’activation de l’accès anonyme sur des conteneurs individuels est cochée. Vérifiez que le paramètre n’est pas activé, puis sélectionnez Révision.

  5. Sous l’onglet Vérifier, passez en revue les options que vous avez sélectionnées dans les étapes précédentes.

  6. Sélectionnez Créer pour créer le compte de stockage à l’aide de votre configuration spécifiée.

    Remarque : Attendez que la tâche de création soit terminée avant de poursuivre ce labo.

  7. Sélectionnez Accéder à la ressource.

  8. Dans le volet Compte de stockage, dans la section Paramètres, sélectionnez le lien Points de terminaison.

  9. Dans la section Points de terminaison, copiez la valeur de la zone de texte service BLOB dans le Presse-papiers.

    Remarque : vous allez utiliser cette valeur de point de terminaison plus tard dans ce labo.

  10. Ouvrez Bloc-notes, puis collez-y la valeur de service BLOB copiée.

  11. Dans le volet Compte de stockage, dans la section Sécurité et réseau, sélectionnez Clés d’accès.

  12. Copiez la valeur Nom du compte stockage dans le Presse-papiers, puis collez-la dans Bloc-notes.

  13. Dans le panneau Clés d’accès, sélectionnez Afficher pour l’une des zones de texte Clé. Peu importe celle que vous utilisez, elles sont interchangeables.

  14. Examinez chacune des clés, puis copiez la valeur de l’une des zones Clé dans le Presse-papiers, enfin collez-la dans le Bloc-notes.

    Remarque : vous allez utiliser ces valeurs plus tard dans ce labo.

Révision

Dans cet exercice, vous avez créé un compte de stockage à utiliser jusqu’à la fin de ce labo.

Exercice 2 : Charger un objet blob dans un conteneur

Tâche 1 : Créer des conteneurs de compte de stockage

  1. Dans le volet Compte de stockage, dans la section Stockage des données, sélectionnez le lien Conteneurs.

  2. Dans la section Conteneurs, sélectionnez + Conteneur.

  3. Dans la fenêtre contextuelle Nouveau conteneur, effectuez les actions suivantes, puis sélectionnez Créer:

    Paramètre Action
    Zone de texte Nom Entrez raster-graphics
    Liste déroulante Niveau d’accès public Sélectionnez Privé (aucun accès anonyme)
  4. Dans la section Conteneurs, sélectionnez + Conteneur.

  5. Dans la fenêtre contextuelle Nouveau conteneur, effectuez les actions suivantes, puis sélectionnez Créer:

    Paramètre Action
    Zone de texte Nom Entrez compressed-audio
    Liste déroulante Niveau d’accès public Sélectionnez Privé (aucun accès anonyme)
  6. Dans la section Conteneurs, observez la liste des conteneurs mise à jour.

    La capture d’écran suivante affiche les paramètres configurés dans le volet Créer un compte de stockage.

    Volet Créer un compte de stockage.

Tâche 2 : Charger un blob de compte de stockage

  1. Dans la section Conteneurs, sélectionnez le conteneur raster-graphics nouvellement créé.

  2. Dans le volet Conteneur, sélectionnez Charger.

  3. Dans la fenêtre Charger l’objet blob, effectuez les actions suivantes, puis sélectionnez Charger :

Paramètre Action
Section Fichiers Sélectionnez Parcourir les fichiers ou utilisez la fonctionnalité glisser-déplacer.
Fenêtre Explorateur de fichiers Accédez à Allfiles (F):\Allfiles\Labs\03\Starter\Images, sélectionnez le fichier graph.jpg, puis Ouvrir
Case à cocher Remplacer si les fichiers existent déjà Vérifiez que la case est cochée

Remarque : attendez que le chargement du blob soit terminé avant de poursuivre ce labo.

Révision

Dans cet exercice, vous avez créé des conteneurs d’espaces réservés dans le compte Stockage, puis rempli l’un d’eux avec un blob.

Exercice 3 : Accéder aux conteneurs à l’aide du Kit de développement logiciel (SDK) .NET

Tâche 1 : Créer un projet .NET

  1. Dans l’écran Démarrage, sélectionnez la vignette Visual Studio Code.

  2. Dans le menu Fichier, sélectionnez Ouvrir un dossier, accédez à Allfiles (F):\Allfiles\Labs\03\Starter\BlobManager, puis choisissez Sélectionner un dossier.

  3. Dans la fenêtre Visual Studio Code, dans la barre de menus, sélectionnez Terminal, puis Nouveau terminal.

  4. Dans le terminal, exécutez la commande suivante pour créer un projet .NET nommé BlobManager dans le dossier actif :

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

    Remarque : La commande dotnet new crée un projet de console dans un dossier du même nom que le projet.

  5. Dans le terminal, exécutez la commande suivante pour importer la version 12.18.0 d’Azure.Storage.Blobs à partir de NuGet :

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

    Remarque : la commande dotnet add package ajoute le package Azure.Storage.Blobs à partir de NuGet. Pour plus d’informations, consultez Azure.Storage.Blobs.

  6. Dans le terminal, exécutez la commande suivante pour générer l’application web .NET :

     dotnet build
    
  7. Sélectionnez Tuer le terminal ou l’icône Corbeille pour fermer le terminal actuellement ouvert et tous les processus associés.

Tâche 2 : Modifier la classe Program pour accéder au Stockage

  1. Dans le volet Explorateur de la fenêtre Visual Studio Code, ouvrez le fichier Program.cs.

  2. Sous l’onglet de l’éditeur de code du fichier Program.cs, supprimez tout le code du fichier existant.

  3. Ajoutez le code suivant :

     using Azure.Storage;
     using Azure.Storage.Blobs;
     using Azure.Storage.Blobs.Models;
     using System;
     using System.Threading.Tasks;    
     public class Program
     {
         //Update the blobServiceEndpoint value that you recorded previously in this lab.        
         private const string blobServiceEndpoint = "<primary-blob-service-endpoint>";
    
         //Update the storageAccountName value that you recorded previously in this lab.
         private const string storageAccountName = "<storage-account-name>";
    
         //Update the storageAccountKey value that you recorded previously in this lab.
         private const string storageAccountKey = "<key>";    
    
    
         //The following code to create a new asynchronous Main method
         public static async Task Main(string[] args)
         { 
         }
     }
    
  4. Mettez à jour la constante de chaîne blobServiceEndpoint en définissant sa valeur sur le Point de terminaison de service Blob principal du compte de stockage que vous avez enregistré précédemment dans ce labo.

  5. Mettez à jour la constante de chaîne storageAccountName en définissant sa valeur sur le Nom de compte de stockage que vous avez enregistré précédemment dans ce labo.

  6. Mettez à jour la constante de chaîne storageAccountKey en définissant sa valeur sur la Clé du compte de stockage que vous avez enregistrée précédemment dans ce labo.

Tâche 3 : Se connecter au point de terminaison du service Azure Storage Blob

  1. Dans la méthode Main, ajoutez le code suivant :

      public static async Task Main(string[] args)
     {
         //The following line of code to create a new instance of the StorageSharedKeyCredential class by using the storageAccountName and storageAccountKey constants as constructor parameters
         StorageSharedKeyCredential accountCredentials = new StorageSharedKeyCredential(storageAccountName, storageAccountKey);
    
         //The following line of code to create a new instance of the BlobServiceClient class by using the blobServiceEndpoint constant and the accountCredentials variable as constructor parameters
         BlobServiceClient serviceClient = new BlobServiceClient(new Uri(blobServiceEndpoint), accountCredentials);
    
         //The following line of code to invoke the GetAccountInfoAsync method of the BlobServiceClient class to retrieve account metadata from the service
         AccountInfo info = await serviceClient.GetAccountInfoAsync();
    
         //Render a welcome message
         await Console.Out.WriteLineAsync($"Connected to Azure Storage Account");
    
         //Render the storage account's name
         await Console.Out.WriteLineAsync($"Account name:\t{storageAccountName}");
    
         //Render the type of storage account
         await Console.Out.WriteLineAsync($"Account kind:\t{info?.AccountKind}");
    
         //Render the currently selected stock keeping unit (SKU) for the storage account
         await Console.Out.WriteLineAsync($"Account sku:\t{info?.SkuName}");
     }
    
  2. Enregistrez le fichier Program.cs.

  3. Dans la fenêtre Visual Studio Code, dans la barre de menus, sélectionnez Terminal, puis Nouveau terminal.

  4. Dans le terminal, exécutez la commande suivante pour démarrer l’application web .NET :

     dotnet run
    

    Remarque : s’il existe des erreurs de build, examinez le fichier Program.cs dans le dossier Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  5. Observez la sortie de l’application console en cours d’exécution. La sortie contient des métadonnées pour le compte de stockage qui ont été récupérées à partir du service.

  6. Sélectionnez Tuer le terminal ou l’icône Corbeille pour fermer le terminal actuellement ouvert et tous les processus associés.

Tâche 4: Énumérer les conteneurs existants

  1. Dans la classe Program, entrez le code suivant pour créer une méthode statique privée nommée EnumerateContainersAsync, qui est asynchrone et dispose d’un seul type de paramètre BlobServiceClient:

     private static async Task EnumerateContainersAsync(BlobServiceClient client)
     {   
         /*Create an asynchronous foreach loop that iterates over the results of 
             an invocation of the GetBlobContainersAsync method of the BlobServiceClient class. */    
         await foreach (BlobContainerItem container in client.GetBlobContainersAsync())
         {   
             //Print the name of each container
             await Console.Out.WriteLineAsync($"Container:\t{container.Name}");
         }
     }
    
  2. Dans la méthode Main , entrez le code suivant à la fin de la méthode pour appeler la méthode EnumerateContainersAsync, en passant la variable serviceClient comme paramètre:

     await EnumerateContainersAsync(serviceClient);
    
  3. Observez le fichier Program.cs qui devrait maintenant inclure :
     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}");
    
             /* To invoke the EnumerateContainersAsync method, 
             passing in the serviceClient variable as a parameter */
             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}");
             }
     }
     }
    
  4. Enregistrez le fichier Program.cs.

  5. Dans la fenêtre Visual Studio Code, dans la barre de menus, sélectionnez Terminal, puis Nouveau terminal.

  6. Dans le terminal, exécutez la commande suivante pour démarrer l’application web .NET :

     dotnet run
    

    Remarque : s’il existe des erreurs de build, examinez le fichier Program.cs dans le dossier Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  7. Observez la sortie de l’application console en cours d’exécution. La sortie mise à jour inclut la liste des conteneurs existants dans le compte.

  8. Sélectionnez Tuer le terminal ou l’icône Corbeille pour fermer le terminal actuellement ouvert et tous les processus associés.

Révision

Dans cet exercice, vous avez accédé à des conteneurs existants à l’aide du Kit de développement logiciel (SDK) Stockage Azure.

Exercice 4 : Récupérer les URI de blob à l’aide du Kit de développement logiciel (SDK) .NET

Tâche 1 : Énumérer les blobs dans un conteneur existant en utilisant le Kit de développement logiciel (SDK)

  1. Dans la classe Program, entrez le code suivant pour créer une méthode statique privée nommée EnumerateBlobsAsync, qui est asynchrone et dispose de deux types de paramètres, BlobServiceClient et string :

     private static async Task EnumerateBlobsAsync(BlobServiceClient client, string containerName)
     {   
         /* Get a new instance of the BlobContainerClient class by using the
            GetBlobContainerClient method of the BlobServiceClient class, 
            passing in the containerName parameter */   
         BlobContainerClient container = client.GetBlobContainerClient(containerName);
    
         /* Render the name of the container that will be enumerated */
         await Console.Out.WriteLineAsync($"Searching:\t{container.Name}");
    
         /* Create an asynchronous foreach loop that iterates over the results of
             an invocation of the GetBlobsAsync method of the BlobContainerClient class */
         await foreach (BlobItem blob in container.GetBlobsAsync())
         {     
             //Print the name of each blob    
             await Console.Out.WriteLineAsync($"Existing Blob:\t{blob.Name}");
         }
     }
    
  2. Dans la méthode Main, entrez le code suivant à la fin de la méthode pour créer une variable nommée existingContainerName avec une valeur de raster-graphics:

     string existingContainerName = "raster-graphics";
    
  3. Dans la méthode Main, entrez le code suivant à la fin de la méthode pour appeler la méthode EnumerateBlobsAsync, en passant les variables serviceClient et existingContainerName comme paramètres:

     await EnumerateBlobsAsync(serviceClient, existingContainerName);
    
  4. Observez le fichier Program.cs qui devrait maintenant inclure :
     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}");
             }
         }
     }
    
  5. Enregistrez le fichier Program.cs.

  6. Dans la fenêtre Visual Studio Code, dans la barre de menus, sélectionnez Terminal, puis Nouveau terminal.

  7. Dans le terminal, exécutez la commande suivante pour démarrer l’application web .NET :

     dotnet run
    

    Remarque : s’il existe des erreurs de build, examinez le fichier Program.cs dans le dossier Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  8. Examinez la sortie de l’application console en cours d’exécution. La sortie mise à jour inclut des métadonnées sur le conteneur et les blob existants.

  9. Sélectionnez Tuer le terminal ou l’icône Corbeille pour fermer le terminal actuellement ouvert et tous les processus associés.

Tâche 2 : Créer un conteneur en utilisant le Kit de développement logiciel (SDK)

  1. Dans la classe Program, entrez le code suivant pour créer une méthode statique privée nommée GetContainerAsync, qui est asynchrone et dispose de deux types de paramètres, BlobServiceClient et string :

     private static async Task<BlobContainerClient> GetContainerAsync(BlobServiceClient client, string containerName)
     {   
         /* Get a new instance of the BlobContainerClient class by using the
             GetBlobContainerClient method of the BlobServiceClient class,
             passing in the containerName parameter */   
         BlobContainerClient container = client.GetBlobContainerClient(containerName);
    
         /* Invoke the CreateIfNotExistsAsync method of the BlobContainerClient class */
         await container.CreateIfNotExistsAsync(PublicAccessType.Blob);
    
         /* Render the name of the container that was potentially created */
         await Console.Out.WriteLineAsync($"New Container:\t{container.Name}");
    
         /* Return the container as the result of the GetContainerAsync */        
         return container;
     }
    
  2. Dans la méthode Main, entrez le code suivant à la fin de la méthode pour créer une variable nommée newContainerName avec une valeur de vector-graphics:

     string newContainerName = "vector-graphics";
    
  3. Dans la méthode Main, entrez le code suivant à la fin de la méthode pour appeler la méthode GetContainerAsync, afin de transmettre les variables serviceClient et newContainerName comme paramètres, et de stocker le résultat dans une variable nommée containerClient de type BlobContainerClient :

     BlobContainerClient containerClient = await GetContainerAsync(serviceClient, newContainerName);
    
  4. Examinez le fichier Program.cs qui devrait désormais inclure :
     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;
         }
     }
    
  5. Enregistrez le fichier Program.cs.

  6. Dans la fenêtre Visual Studio Code, dans la barre de menus, sélectionnez Terminal, puis Nouveau terminal.

  7. Dans le terminal, exécutez la commande suivante pour démarrer l’application web .NET :

     dotnet run
    

    Remarque : s’il existe des erreurs de build, examinez le fichier Program.cs dans le dossier Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  8. Observez la sortie de l’application console en cours d’exécution. La sortie mise à jour inclut des métadonnées sur le conteneur et les blob existants.

  9. Sélectionnez Tuer le terminal ou l’icône Corbeille pour fermer le terminal actuellement ouvert et tous les processus associés.

Tâche 3: Charger un nouveau blob à l’aide du portail

  1. Dans le volet de navigation du portail Azure, sélectionnez le lien Groupes de ressources.

  2. Dans le volet Groupes de ressources, sélectionnez le groupe de ressources StorageMedia que vous avez créé précédemment dans ce labo.

  3. Dans le panneau StorageMedia, sélectionnez le compte de stockage mediastor [votrenom] que vous avez créé précédemment dans ce labo.

  4. Dans le volet Compte de stockage, dans la section Stockage des données, sélectionnez le lien Conteneurs.

  5. Dans la section Conteneurs, sélectionnez le conteneur vector-graphics nouvellement créé. Il se pourrait que vous deviez actualiser la page pour observer le nouveau conteneur.

  6. Dans le volet Conteneur, sélectionnez Charger.

  7. Dans la fenêtre Charger l’objet blob, effectuez les actions suivantes, puis sélectionnez Charger :

    Paramètre Action
    Section Fichiers Sélectionnez Parcourir les fichiers ou utilisez la fonctionnalité glisser-déplacer.
    Fenêtre Explorateur de fichiers Allfiles (F):\Allfiles\Labs\03\Starter\Images, sélectionnez le fichier graph.svg, puis Ouvrir
    Case à cocher Remplacer si les fichiers existent déjà Vérifiez que la case est cochée

    Remarque : attendez que le chargement du blob soit terminé avant de poursuivre ce labo.

Tâche 4: Accéder à une URI de blob à l’aide du Kit de développement logiciel (SDK)

  1. Passez à la fenêtre Visual Studio Code.

  2. Dans la classe Program, entrez le code suivant pour créer une méthode statique privée nommée GetBlobAsync, qui est asynchrone et dispose de deux types de paramètres, BlobContainerClient et string :

     private static async Task<BlobClient> GetBlobAsync(BlobContainerClient client, string blobName)
     {      
         BlobClient blob = client.GetBlobClient(blobName);
         bool exists = await blob.ExistsAsync();
         if (!exists)
         {
             await Console.Out.WriteLineAsync($"Blob {blob.Name} not found!");
                
         }
         else
             await Console.Out.WriteLineAsync($"Blob Found, URI:\t{blob.Uri}");
         return blob;
     }
    
  3. Dans la méthode Main, entrez le code suivant à la fin de la méthode pour créer une variable nommée newContainerName avec une valeur de graph.svg:

     string uploadedBlobName = "graph.svg";
    
  4. Dans la méthode Main, entrez le code suivant à la fin de la méthode pour appeler la méthode GetBlobAsync, en passant les variables containerClient et uploadBlobName en tant que paramètres, et stocker le résultat dans une variable nommée blobClient de type BlobClient:

     BlobClient blobClient = await GetBlobAsync(containerClient, uploadedBlobName);
    
  5. Dans la méthode Main , entrez le code suivant à la fin de la méthode pour afficher la propriété Uri de la variable blobClient:

     await Console.Out.WriteLineAsync($"Blob Url:\t{blobClient.Uri}");
    
  6. Observez le fichier Program.cs qui devrait maintenant inclure :
     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);
             bool exists = await blob.ExistsAsync();
             if (!exists)
             {
                 await Console.Out.WriteLineAsync($"Blob {blob.Name} not found!");
                    
             }
             else
                 await Console.Out.WriteLineAsync($"Blob Found, URI:\t{blob.Uri}");
             return blob;
         }
     }
    
  7. Enregistrez le fichier Program.cs.

  8. Dans la fenêtre Visual Studio Code, dans la barre de menus, sélectionnez Terminal, puis Nouveau terminal.

  9. Dans le terminal, exécutez la commande suivante pour démarrer l’application web .NET :

     dotnet run
    

    Remarque : s’il existe des erreurs de build, examinez le fichier Program.cs dans le dossier Allfiles (F):\Allfiles\Labs\03\Solution\BlobManager.

  10. Observez la sortie de l’application console en cours d’exécution. La sortie mise à jour inclut l’URL finale pour au blob en ligne. Enregistrez la valeur de cette URL, que vous utilisez plus tard dans le laboratoire.

    Remarque : l’URL sera probablement similaire à la chaîne suivante: https://mediastor*[yourname]*.blob.core.windows.net/vector-graphics/graph.svg

  11. Sélectionnez Tuer le terminal ou l’icône Corbeille pour fermer le terminal actuellement ouvert et tous les processus associés.

Tâche 5: Tester l’URI à l’aide d’un navigateur

  1. Dans la barre des tâches, activez le menu contextuel pour l’icône Microsoft Edge, puis sélectionnez Nouvelle fenêtre.

  2. Dans la nouvelle fenêtre du navigateur, reportez-vous à l’URL que vous avez précédemment copiée dans ce labo pour le blob.

  3. Vous devriez maintenant voir le fichier SVG (Scalable Vector Graphics) dans votre fenêtre de navigateur.

Révision

Dans cet exercice, vous avez créé des conteneurs et des blob managés à l’aide du Kit de développement logiciel (SDK) Stockage.