Exemples de code Stockage Blob Azure utilisant les bibliothèques clientes .NET version 11.x

2023-04-03

Cet article présente des exemples de code qui utilisent la version 11.x de la bibliothèque cliente Stockage Blob Azure pour .NET.

Le 31 mars 2023, nous avons mis fin à la prise en charge des bibliothèques de Kit de développement logiciel (SDK) Azure qui ne respectent pas les instructions actuelles concernant le SDK Azure. Les nouvelles bibliothèques du Kit de développement logiciel (SDK) Azure sont mises à jour régulièrement pour générer des expériences cohérentes et renforcer votre posture de sécurité. Nous vous recommandons une transition vers les nouvelles bibliothèques du Kit de développement logiciel Azure pour profiter des nouvelles fonctionnalités et des correctifs de sécurité.

Bien que les anciennes bibliothèques puissent toujours être utilisées au-delà du 31 mars 2023, elles ne recevront plus de support et de mises à jour officielles de Microsoft. Pour plus d’informations, consultez l’annonce concernant l’arrêt de la prise en charge.

Créer un instantané

Pour créer un instantané d’un objet blob de blocs à l’aide de la version 11.x de la bibliothèque cliente stockage Azure pour .NET, utilisez l’une des méthodes suivantes :

L’exemple de code suivant montre comment créer un instantané avec la version 11.x. Cet exemple spécifie des métadonnées supplémentaires pour l’instantané lors de sa création.

private static async Task CreateBlockBlobSnapshot(CloudBlobContainer container)
{
    // Create a new block blob in the container.
    CloudBlockBlob baseBlob = container.GetBlockBlobReference("sample-base-blob.txt");

    // Add blob metadata.
    baseBlob.Metadata.Add("ApproxBlobCreatedDate", DateTime.UtcNow.ToString());

    try
    {
        // Upload the blob to create it, with its metadata.
        await baseBlob.UploadTextAsync(string.Format("Base blob: {0}", baseBlob.Uri.ToString()));

        // Sleep 5 seconds.
        System.Threading.Thread.Sleep(5000);

        // Create a snapshot of the base blob.
        // You can specify metadata at the time that the snapshot is created.
        // If no metadata is specified, then the blob's metadata is copied to the snapshot.
        Dictionary<string, string> metadata = new Dictionary<string, string>();
        metadata.Add("ApproxSnapshotCreatedDate", DateTime.UtcNow.ToString());
        await baseBlob.CreateSnapshotAsync(metadata, null, null, null);
        Console.WriteLine(snapshot.SnapshotQualifiedStorageUri.PrimaryUri);
    }
    catch (StorageException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Supprimez les instantanés

Pour supprimer un objet blob et ses instantanés à l’aide de la version 11.x de la bibliothèque cliente stockage Azure pour .NET, utilisez l’une des méthodes de suppression d’objets blob suivantes et incluez l’énumération DeleteSnapshotsOption :

L’exemple de code suivant montre comment supprimer un objet blob et ses instantanés dans .NET, où blockBlob est un objet de type [CloudBlockBlob][dotnet_CloudBlockBlob] :

await blockBlob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, null, null);

Créer une stratégie d’accès enregistrée

Pour créer une stratégie d’accès stockée sur un conteneur avec la version 11.x de la bibliothèque cliente .NET pour stockage Azure, appelez l’une des méthodes suivantes :

L’exemple suivant crée une stratégie d’accès stockée qui est en vigueur pendant un jour et qui accorde des autorisations de lecture, d’écriture et de liste :

private static async Task CreateStoredAccessPolicyAsync(CloudBlobContainer container, string policyName)
{
    // Create a new stored access policy and define its constraints.
    // The access policy provides create, write, read, list, and delete permissions.
    SharedAccessBlobPolicy sharedPolicy = new SharedAccessBlobPolicy()
    {
        // When the start time for the SAS is omitted, the start time is assumed to be the time when Azure Storage receives the request.
        SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24),
        Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.List |
            SharedAccessBlobPermissions.Write
    };

    // Get the container's existing permissions.
    BlobContainerPermissions permissions = await container.GetPermissionsAsync();

    // Add the new policy to the container's permissions, and set the container's permissions.
    permissions.SharedAccessPolicies.Add(policyName, sharedPolicy);
    await container.SetPermissionsAsync(permissions);
}

Créer une SAS de service pour un conteneur blob

Pour créer un SAS de service pour un conteneur, appelez la méthode CloudBlobContainer.GetSharedAccessSignature.

private static string GetContainerSasUri(CloudBlobContainer container,
                                         string storedPolicyName = null)
{
    string sasContainerToken;

    // If no stored policy is specified, create a new access policy and define its constraints.
    if (storedPolicyName == null)
    {
        // Note that the SharedAccessBlobPolicy class is used both to define
        // the parameters of an ad hoc SAS, and to construct a shared access policy
        // that is saved to the container's shared access policies.
        SharedAccessBlobPolicy adHocPolicy = new SharedAccessBlobPolicy()
        {
            // When the start time for the SAS is omitted, the start time is assumed
            // to be the time when the storage service receives the request. Omitting
            // the start time for a SAS that is effective immediately helps to avoid clock skew.
            SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24),
            Permissions = SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.List
        };

        // Generate the shared access signature on the container,
        // setting the constraints directly on the signature.
        sasContainerToken = container.GetSharedAccessSignature(adHocPolicy, null);

        Console.WriteLine("SAS for blob container (ad hoc): {0}", sasContainerToken);
        Console.WriteLine();
    }
    else
    {
        // Generate the shared access signature on the container. In this case,
        // all of the constraints for the shared access signature are specified
        // on the stored access policy, which is provided by name. It is also possible
        // to specify some constraints on an ad hoc SAS and others on the stored access policy.
        sasContainerToken = container.GetSharedAccessSignature(null, storedPolicyName);

        Console.WriteLine("SAS for container (stored access policy): {0}", sasContainerToken);
        Console.WriteLine();
    }

    // Return the URI string for the container, including the SAS token.
    return container.Uri + sasContainerToken;
}

Créer une SAP de service pour un objet blob

Pour créer une SAS de service pour un objet blob, appelez la méthode CloudBlob.GetSharedAccessSignature .

private static string GetBlobSasUri(CloudBlobContainer container,
                                    string blobName,
                                    string policyName = null)
{
    string sasBlobToken;

    // Get a reference to a blob within the container.
    // Note that the blob may not exist yet, but a SAS can still be created for it.
    CloudBlockBlob blob = container.GetBlockBlobReference(blobName);

    if (policyName == null)
    {
        // Create a new access policy and define its constraints.
        // Note that the SharedAccessBlobPolicy class is used both to define the parameters
        // of an ad hoc SAS, and to construct a shared access policy that is saved to
        // the container's shared access policies.
        SharedAccessBlobPolicy adHocSAS = new SharedAccessBlobPolicy()
        {
            // When the start time for the SAS is omitted, the start time is assumed to be
            // the time when the storage service receives the request. Omitting the start time
            // for a SAS that is effective immediately helps to avoid clock skew.
            SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24),
            Permissions = SharedAccessBlobPermissions.Read |
                          SharedAccessBlobPermissions.Write |
                          SharedAccessBlobPermissions.Create
        };

        // Generate the shared access signature on the blob,
        // setting the constraints directly on the signature.
        sasBlobToken = blob.GetSharedAccessSignature(adHocSAS);

        Console.WriteLine("SAS for blob (ad hoc): {0}", sasBlobToken);
        Console.WriteLine();
    }
    else
    {
        // Generate the shared access signature on the blob. In this case, all of the constraints
        // for the SAS are specified on the container's stored access policy.
        sasBlobToken = blob.GetSharedAccessSignature(null, policyName);

        Console.WriteLine("SAS for blob (stored access policy): {0}", sasBlobToken);
        Console.WriteLine();
    }

    // Return the URI string for the container, including the SAS token.
    return blob.Uri + sasBlobToken;
}

Créer une SAP de compte

Pour créer une SAP de compte pour un conteneur, appelez la méthode CloudStorageAccount.GetSharedAccessSignature .

L'exemple de code suivant crée une Stratégie d'Accès Partagé (SAP) de compte qui est valide pour les services Blob et Fichier, et qui accorde au client des autorisations de lecture, d'écriture et de liste pour accéder aux API au niveau du service. Le compte SAS limite le protocole à HTTPS, donc la requête doit être faite avec HTTPS. N’oubliez pas de remplacer les valeurs d’espace réservé entre crochets pointus par vos propres valeurs :

static string GetAccountSASToken()
{
    // To create the account SAS, you need to use Shared Key credentials. Modify for your account.
    const string ConnectionString = "DefaultEndpointsProtocol=https;AccountName=<storage-account>;AccountKey=<account-key>";
    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConnectionString);

    // Create a new access policy for the account.
    SharedAccessAccountPolicy policy = new SharedAccessAccountPolicy()
        {
            Permissions = SharedAccessAccountPermissions.Read | 
                          SharedAccessAccountPermissions.Write | 
                          SharedAccessAccountPermissions.List,
            Services = SharedAccessAccountServices.Blob | SharedAccessAccountServices.File,
            ResourceTypes = SharedAccessAccountResourceTypes.Service,
            SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24),
            Protocols = SharedAccessProtocol.HttpsOnly
        };

    // Return the SAS token.
    return storageAccount.GetSharedAccessSignature(policy);
}

Utiliser un SAS de compte à partir d’un client

Dans cet extrait de code, remplacez l’espace <storage-account> réservé par le nom de votre compte de stockage.

static void UseAccountSAS(string sasToken)
{
    // Create new storage credentials using the SAS token.
    StorageCredentials accountSAS = new StorageCredentials(sasToken);
    // Use these credentials and the account name to create a Blob service client.
    CloudStorageAccount accountWithSAS = new CloudStorageAccount(accountSAS, "<storage-account>", endpointSuffix: null, useHttps: true);
    CloudBlobClient blobClientWithSAS = accountWithSAS.CreateCloudBlobClient();

    // Now set the service properties for the Blob client created with the SAS.
    blobClientWithSAS.SetServiceProperties(new ServiceProperties()
    {
        HourMetrics = new MetricsProperties()
        {
            MetricsLevel = MetricsLevel.ServiceAndApi,
            RetentionDays = 7,
            Version = "1.0"
        },
        MinuteMetrics = new MetricsProperties()
        {
            MetricsLevel = MetricsLevel.ServiceAndApi,
            RetentionDays = 7,
            Version = "1.0"
        },
        Logging = new LoggingProperties()
        {
            LoggingOperations = LoggingOperations.All,
            RetentionDays = 14,
            Version = "1.0"
        }
    });

    // The permissions granted by the account SAS also permit you to retrieve service properties.
    ServiceProperties serviceProperties = blobClientWithSAS.GetServiceProperties();
    Console.WriteLine(serviceProperties.HourMetrics.MetricsLevel);
    Console.WriteLine(serviceProperties.HourMetrics.RetentionDays);
    Console.WriteLine(serviceProperties.HourMetrics.Version);
}

Concurrence optimiste pour les blobs

Exemple de code :

public void DemonstrateOptimisticConcurrencyBlob(string containerName, string blobName)
{
    Console.WriteLine("Demonstrate optimistic concurrency");

    // Parse connection string and create container.
    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConnectionString);
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
    CloudBlobContainer container = blobClient.GetContainerReference(containerName);
    container.CreateIfNotExists();

    // Create test blob. The default strategy is last writer wins, so
    // write operation will overwrite existing blob if present.
    CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobName);
    blockBlob.UploadText("Hello World!");

    // Retrieve the ETag from the newly created blob.
    string originalETag = blockBlob.Properties.ETag;
    Console.WriteLine("Blob added. Original ETag = {0}", originalETag);

    /// This code simulates an update by another client.
    string helloText = "Blob updated by another client.";
    // No ETag was provided, so original blob is overwritten and ETag updated.
    blockBlob.UploadText(helloText);
    Console.WriteLine("Blob updated. Updated ETag = {0}", blockBlob.Properties.ETag);

    // Now try to update the blob using the original ETag value.
    try
    {
        Console.WriteLine(@"Attempt to update blob using original ETag
                            to generate if-match access condition");
        blockBlob.UploadText(helloText, accessCondition: AccessCondition.GenerateIfMatchCondition(originalETag));
    }
    catch (StorageException ex)
    {
        if (ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.PreconditionFailed)
        {
            Console.WriteLine(@"Precondition failure as expected.
                                Blob's ETag does not match.");
        }
        else
        {
            throw;
        }
    }
    Console.WriteLine();
}

Concurrence pessimiste pour les blobs

Exemple de code :

public void DemonstratePessimisticConcurrencyBlob(string containerName, string blobName)
{
    Console.WriteLine("Demonstrate pessimistic concurrency");

    // Parse connection string and create container.
    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConnectionString);
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
    CloudBlobContainer container = blobClient.GetContainerReference(containerName);
    container.CreateIfNotExists();

    CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobName);
    blockBlob.UploadText("Hello World!");
    Console.WriteLine("Blob added.");

    // Acquire lease for 15 seconds.
    string lease = blockBlob.AcquireLease(TimeSpan.FromSeconds(15), null);
    Console.WriteLine("Blob lease acquired. Lease = {0}", lease);

    // Update blob using lease. This operation should succeed.
    const string helloText = "Blob updated";
    var accessCondition = AccessCondition.GenerateLeaseCondition(lease);
    blockBlob.UploadText(helloText, accessCondition: accessCondition);
    Console.WriteLine("Blob updated using an exclusive lease");

    // Simulate another client attempting to update to blob without providing lease.
    try
    {
        // Operation will fail as no valid lease was provided.
        Console.WriteLine("Now try to update blob without valid lease.");
        blockBlob.UploadText("Update operation will fail without lease.");
    }
    catch (StorageException ex)
    {
        if (ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.PreconditionFailed)
        {
            Console.WriteLine(@"Precondition failure error as expected.
                                Blob lease not provided.");
        }
        else
        {
            throw;
        }
    }

    // Release lease proactively.
    blockBlob.ReleaseLease(accessCondition);
    Console.WriteLine();
}

Créez une application hautement disponible avec Azure Blob Storage

Téléchargez l’exemple de projet, extrayez (décompressez) le fichier storage-dotnet-circuit-breaker-pattern-ha-apps-using-ra-grs.zip, puis accédez au dossier v11 pour rechercher les fichiers projet.

Vous pouvez également utiliser git pour télécharger une copie de l’application dans votre environnement de développement. L’exemple de projet dans le dossier v11 contient une application console.

git clone https://github.com/Azure-Samples/storage-dotnet-circuit-breaker-pattern-ha-apps-using-ra-grs.git

Configurer l'exemple

Dans l’application, vous devez fournir la chaîne de connexion de votre compte de stockage. Vous pouvez stocker cette chaîne de connexion dans une variable d’environnement sur l’ordinateur local exécutant l’application. Suivez l’un des exemples ci-dessous en fonction de votre système d’exploitation pour créer la variable d’environnement.

Dans le portail Azure, accédez à votre compte de stockage. Sélectionnez Clés d’accès sous Paramètres dans votre compte de stockage. Copiez la chaîne de connexion de la clé primaire ou secondaire. Exécutez l’une des commandes suivantes en fonction de votre système d’exploitation, en <remplaçant votre chaîne> de connexion par votre chaîne de connexion réelle. Cette commande enregistre une variable d’environnement sur l’ordinateur local. Dans Windows, la variable d’environnement n’est pas disponible tant que vous n’avez pas rechargé l’invite de commandes ou l’interpréteur de commandes que vous utilisez.

Exécuter l’application console

Dans Visual Studio, appuyez sur F5 ou sélectionnez Démarrer pour commencer le débogage de l’application. Visual Studio restaure automatiquement les packages NuGet manquants si la restauration de package est configurée, visitez Installation et réinstallation de packages avec restauration de package pour en savoir plus.

Une fenêtre de console démarre et l’application commence à s’exécuter. L’application charge l’image HelloWorld.png de la solution vers le compte de stockage. L’application vérifie afin de garantir que l’image a été répliquée sur le point de terminaison RA-GZRS secondaire. Il commence ensuite à télécharger l’image jusqu’à 999 fois. Chaque lecture est représentée par un P ou un S. Où P représente le point de terminaison principal et S représente le point de terminaison secondaire.

Dans l’exemple de code, la RunCircuitBreakerAsync tâche du Program.cs fichier est utilisée pour télécharger une image à partir du compte de stockage à l’aide de la méthode DownloadToFileAsync . Avant le téléchargement, un OperationContext est défini. Le contexte d’opération définit les gestionnaires d’événements qui se déclenchent lorsqu’un téléchargement est terminé avec succès, ou lorsqu’un téléchargement échoue et qu’une nouvelle tentative est en cours.

Comprendre l’exemple de code

Gestionnaire d'événements de réessai

Le OperationContextRetrying gestionnaire d’événements est appelé lorsque le téléchargement de l’image échoue et est défini pour réessayer. Si le nombre maximal de nouvelles tentatives définies dans l’application est atteint, le LocationMode de la requête est remplacé SecondaryOnlypar . Ce paramètre force l’application à tenter de télécharger l’image à partir du point de terminaison secondaire. Cette configuration réduit le temps nécessaire pour demander l’image, car le point de terminaison principal n’est pas retenté indéfiniment.

private static void OperationContextRetrying(object sender, RequestEventArgs e)
{
    retryCount++;
    Console.WriteLine("Retrying event because of failure reading the primary. RetryCount = " + retryCount);

    // Check if we have had more than n retries in which case switch to secondary.
    if (retryCount >= retryThreshold)
    {

        // Check to see if we can fail over to secondary.
        if (blobClient.DefaultRequestOptions.LocationMode != LocationMode.SecondaryOnly)
        {
            blobClient.DefaultRequestOptions.LocationMode = LocationMode.SecondaryOnly;
            retryCount = 0;
        }
        else
        {
            throw new ApplicationException("Both primary and secondary are unreachable. Check your application's network connection. ");
        }
    }
}

Gestionnaire d'événement de fin de demande

Le OperationContextRequestCompleted gestionnaire d’événements est appelé lorsque le téléchargement de l’image réussit. Si l’application utilise le point de terminaison secondaire, l’application continue d’utiliser ce point de terminaison jusqu’à 20 fois. Après 20 fois, l’application définit locationMode de nouveau sur PrimaryThenSecondary et réessaye le point de terminaison principal. Si une demande réussit, l’application continue de lire à partir du point de terminaison principal.

private static void OperationContextRequestCompleted(object sender, RequestEventArgs e)
{
    if (blobClient.DefaultRequestOptions.LocationMode == LocationMode.SecondaryOnly)
    {
        // You're reading the secondary. Let it read the secondary [secondaryThreshold] times,
        //    then switch back to the primary and see if it's available now.
        secondaryReadCount++;
        if (secondaryReadCount >= secondaryThreshold)
        {
            blobClient.DefaultRequestOptions.LocationMode = LocationMode.PrimaryThenSecondary;
            secondaryReadCount = 0;
        }
    }
}

Charger de grandes quantités de données aléatoires dans le stockage Azure

Le nombre minimal et maximal de threads est défini sur 100 pour s’assurer qu’un grand nombre de connexions simultanées sont autorisées.

private static async Task UploadFilesAsync()
{
    // Create five randomly named containers to store the uploaded files.
    CloudBlobContainer[] containers = await GetRandomContainersAsync();

    var currentdir = System.IO.Directory.GetCurrentDirectory();

    // Path to the directory to upload
    string uploadPath = currentdir + "\\upload";

    // Start a timer to measure how long it takes to upload all the files.
    Stopwatch time = Stopwatch.StartNew();

    try
    {
        Console.WriteLine("Iterating in directory: {0}", uploadPath);

        int count = 0;
        int max_outstanding = 100;
        int completed_count = 0;

        // Define the BlobRequestOptions on the upload.
        // This includes defining an exponential retry policy to ensure that failed connections
        // are retried with a back off policy. As multiple large files are being uploaded using
        // large block sizes, this can cause an issue if an exponential retry policy is not defined.
        // Additionally, parallel operations are enabled with a thread count of 8.
        // This should be a multiple of the number of processor cores in the machine.
        // Lastly, MD5 hash validation is disabled for this example, improving the upload speed.
        BlobRequestOptions options = new BlobRequestOptions
        {
            ParallelOperationThreadCount = 8,
            DisableContentMD5Validation = true,
            StoreBlobContentMD5 = false
        };

        // Create a new instance of the SemaphoreSlim class to 
        // define the number of threads to use in the application.
        SemaphoreSlim sem = new SemaphoreSlim(max_outstanding, max_outstanding);

        List<Task> tasks = new List<Task>();
        Console.WriteLine("Found {0} file(s)", Directory.GetFiles(uploadPath).Count());

        // Iterate through the files
        foreach (string path in Directory.GetFiles(uploadPath))
        {
            var container = containers[count % 5];
            string fileName = Path.GetFileName(path);
            Console.WriteLine("Uploading {0} to container {1}", path, container.Name);
            CloudBlockBlob blockBlob = container.GetBlockBlobReference(fileName);

            // Set the block size to 100MB.
            blockBlob.StreamWriteSizeInBytes = 100 * 1024 * 1024;

            await sem.WaitAsync();

            // Create a task for each file to upload. The tasks are
            // added to a collection and all run asynchronously.
            tasks.Add(blockBlob.UploadFromFileAsync(path, null, options, null).ContinueWith((t) =>
            {
                sem.Release();
                Interlocked.Increment(ref completed_count);
            }));

            count++;
        }

        // Run all the tasks asynchronously.
        await Task.WhenAll(tasks);

        time.Stop();

        Console.WriteLine("Upload has been completed in {0} seconds. Press any key to continue", time.Elapsed.TotalSeconds.ToString());

        Console.ReadLine();
    }
    catch (DirectoryNotFoundException ex)
    {
        Console.WriteLine("Error parsing files in the directory: {0}", ex.Message);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

En plus de définir les paramètres de limite de thread et de connexion, les blobRequestOptions pour la méthode UploadFromStreamAsync sont configurées pour utiliser le parallélisme et désactiver la validation de hachage MD5. Les fichiers sont téléchargés en blocs de 100 Mo. Cette configuration offre de meilleures performances, mais peut être coûteuse en cas d'utilisation d'un réseau peu performant, car en cas de défaillance, l'ensemble du bloc de 100 Mo doit être retenté.

Propriété	Valeur	Description
NombreDeThreadsD'OpérationParallèle	8	Le paramètre décompose le blob en blocs lors du téléversement. Pour les performances les plus élevées, cette valeur doit être huit fois supérieure au nombre de cœurs.
Désactiver la validation MD5 du contenu	vrai	Cette propriété désactive la vérification du hachage MD5 du contenu chargé. La désactivation de la validation MD5 génère un transfert plus rapide. Mais ne confirme pas la validité ou l’intégrité des fichiers transférés.
StoreBlobContentMD5	faux	Cette propriété détermine si un hachage MD5 est calculé et stocké avec le fichier.
RetryPolicy	2 secondes d’interruption avec 10 nouvelles tentatives maximales	Détermine la politique de réessai des requêtes. Les échecs de connexion sont retentés, dans cet exemple, une stratégie ExponentielRetry est configurée avec un backoff de 2 secondes et un nombre maximal de nouvelles tentatives de 10. Ce paramètre est important lorsque votre application se rapproche des cibles d’extensibilité pour le stockage Blob. Pour plus d’informations, consultez Objectifs de performance et de scalabilité pour le stockage d’objets blob.

Télécharger de grandes quantités de données aléatoires depuis le stockage Azure

L’application lit les conteneurs situés dans le compte de stockage spécifié dans la chaîne de connexion de stockage. Il parcourt les objets blob 10 à la fois à l’aide de la méthode ListBlobsSegmentedAsync dans les conteneurs et les télécharge sur l’ordinateur local à l’aide de la méthode DownloadToFileAsync.

Le tableau suivant montre les blobRequestOptions définis pour chaque objet blob tel qu’il est téléchargé.

Propriété	Valeur	Description
Désactiver la validation MD5 du contenu	vrai	Cette propriété désactive la vérification du hachage MD5 du contenu chargé. La désactivation de la validation MD5 génère un transfert plus rapide. Mais ne confirme pas la validité ou l’intégrité des fichiers transférés.
StoreBlobContentMD5	faux	Cette propriété détermine si un hachage MD5 est calculé et stocké.

private static async Task DownloadFilesAsync()
{
    CloudBlobClient blobClient = GetCloudBlobClient();

    // Define the BlobRequestOptions on the download, including disabling MD5 
    // hash validation for this example, this improves the download speed.
    BlobRequestOptions options = new BlobRequestOptions
    {
        DisableContentMD5Validation = true,
        StoreBlobContentMD5 = false
    };

    // Retrieve the list of containers in the storage account.
    // Create a directory and configure variables for use later.
    BlobContinuationToken continuationToken = null;
    List<CloudBlobContainer> containers = new List<CloudBlobContainer>();
    do
    {
        var listingResult = await blobClient.ListContainersSegmentedAsync(continuationToken);
        continuationToken = listingResult.ContinuationToken;
        containers.AddRange(listingResult.Results);
    }
    while (continuationToken != null);

    var directory = Directory.CreateDirectory("download");
    BlobResultSegment resultSegment = null;
    Stopwatch time = Stopwatch.StartNew();

    // Download the blobs
    try
    {
        List<Task> tasks = new List<Task>();
        int max_outstanding = 100;
        int completed_count = 0;

        // Create a new instance of the SemaphoreSlim class to
        // define the number of threads to use in the application.
        SemaphoreSlim sem = new SemaphoreSlim(max_outstanding, max_outstanding);

        // Iterate through the containers
        foreach (CloudBlobContainer container in containers)
        {
            do
            {
                // Return the blobs from the container, 10 at a time.
                resultSegment = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, 10, continuationToken, null, null);
                continuationToken = resultSegment.ContinuationToken;
                {
                    foreach (var blobItem in resultSegment.Results)
                    {

                        if (((CloudBlob)blobItem).Properties.BlobType == BlobType.BlockBlob)
                        {
                            // Get the blob and add a task to download the blob asynchronously from the storage account.
                            CloudBlockBlob blockBlob = container.GetBlockBlobReference(((CloudBlockBlob)blobItem).Name);
                            Console.WriteLine("Downloading {0} from container {1}", blockBlob.Name, container.Name);
                            await sem.WaitAsync();
                            tasks.Add(blockBlob.DownloadToFileAsync(directory.FullName + "\\" + blockBlob.Name, FileMode.Create, null, options, null).ContinueWith((t) =>
                            {
                                sem.Release();
                                Interlocked.Increment(ref completed_count);
                            }));

                        }
                    }
                }
            }
            while (continuationToken != null);
        }

        // Creates an asynchronous task that completes when all the downloads complete.
        await Task.WhenAll(tasks);
    }
    catch (Exception e)
    {
        Console.WriteLine("\nError encountered during transfer: {0}", e.Message);
    }

    time.Stop();
    Console.WriteLine("Download has been completed in {0} seconds. Press any key to continue", time.Elapsed.TotalSeconds.ToString());
    Console.ReadLine();
}

Activer les journaux Azure Storage Analytics (classique)

Exemple de code :

var storageAccount = CloudStorageAccount.Parse(connStr);  
var queueClient = storageAccount.CreateCloudQueueClient();  
var serviceProperties = queueClient.GetServiceProperties();

serviceProperties.Logging.LoggingOperations = LoggingOperations.All;  
serviceProperties.Logging.RetentionDays = 2;

queueClient.SetServiceProperties(serviceProperties);

Modification de la période de rétention des données de journal

L’exemple suivant imprime sur la console la période de rétention des services de stockage Blob et File d’attente.

var storageAccount = CloudStorageAccount.Parse(connectionString);

var blobClient = storageAccount.CreateCloudBlobClient();
var queueClient = storageAccount.CreateCloudQueueClient();

var blobserviceProperties = blobClient.GetServiceProperties();
var queueserviceProperties = queueClient.GetServiceProperties();

Console.WriteLine("Retention period for logs from the blob service is: " +
   blobserviceProperties.Logging.RetentionDays.ToString());

Console.WriteLine("Retention period for logs from the queue service is: " +
   queueserviceProperties.Logging.RetentionDays.ToString());

L’exemple suivant modifie la période de rétention des journaux pour les services de stockage BLOB et la file de stockage à 4 jours.


blobserviceProperties.Logging.RetentionDays = 4;
queueserviceProperties.Logging.RetentionDays = 4;

blobClient.SetServiceProperties(blobserviceProperties);
queueClient.SetServiceProperties(queueserviceProperties);

Activer les métriques Azure Storage Analytics (classique)

Exemple de code :

var storageAccount = CloudStorageAccount.Parse(connStr);  
var queueClient = storageAccount.CreateCloudQueueClient();  
var serviceProperties = queueClient.GetServiceProperties();

serviceProperties.HourMetrics.MetricsLevel = MetricsLevel.Service;  
serviceProperties.HourMetrics.RetentionDays = 10;

queueClient.SetServiceProperties(serviceProperties);

Configurer TLS (Transport Layer Security) pour une application cliente

L’exemple suivant montre comment activer TLS 1.2 dans un client .NET à l’aide de la version 11.x de la bibliothèque cliente stockage Azure :

static void EnableTls12()
{
    // Enable TLS 1.2 before connecting to Azure Storage
    System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;

    // Add your connection string here.
    string connectionString = "";

    // Connect to Azure Storage and create a new container.
    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

    CloudBlobContainer container = blobClient.GetContainerReference("sample-container");
    container.CreateIfNotExists();
}

Surveiller, diagnostiquer et résoudre les problèmes liés au stockage Microsoft Azure (classique)

Si la bibliothèque cliente de stockage lève une StorageException, la propriété RequestInformation contient un objet RequestResult qui inclut une propriété ServiceRequestID. Vous pouvez également accéder à un objet RequestResult à partir d’une instance OperationContext .

L’exemple de code ci-dessous montre comment définir une valeur ClientRequestId personnalisée en attachant un objet OperationContext à la requête au service de stockage. Il montre également comment récupérer la valeur ServerRequestId à partir du message de réponse.

//Parse the connection string for the storage account.
const string ConnectionString = "DefaultEndpointsProtocol=https;AccountName=account-name;AccountKey=account-key";
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConnectionString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

// Create an Operation Context that includes custom ClientRequestId string based on constants defined within the application along with a Guid.
OperationContext oc = new OperationContext();
oc.ClientRequestID = String.Format("{0} {1} {2} {3}", HOSTNAME, APPNAME, USERID, Guid.NewGuid().ToString());

try
{
    CloudBlobContainer container = blobClient.GetContainerReference("democontainer");
    ICloudBlob blob = container.GetBlobReferenceFromServer("testImage.jpg", null, null, oc);  
    var downloadToPath = string.Format("./{0}", blob.Name);
    using (var fs = File.OpenWrite(downloadToPath))
    {
        blob.DownloadToStream(fs, null, null, oc);
        Console.WriteLine("\t Blob downloaded to file: {0}", downloadToPath);
    }
}
catch (StorageException storageException)
{
    Console.WriteLine("Storage exception {0} occurred", storageException.Message);
    // Multiple results may exist due to client side retry logic - each retried operation will have a unique ServiceRequestId
    foreach (var result in oc.RequestResults)
    {
            Console.WriteLine("HttpStatus: {0}, ServiceRequestId {1}", result.HttpStatusCode, result.ServiceRequestID);
    }
}

Examen des problèmes de performances du client - désactiver l’algorithme Nagle

Exemple de code :

var storageAccount = CloudStorageAccount.Parse(connStr);
ServicePoint queueServicePoint = ServicePointManager.FindServicePoint(storageAccount.QueueEndpoint);
queueServicePoint.UseNagleAlgorithm = false;

Exemple de code :

CloudBlobClient client = new CloudBlobClient(blobEndpoint, new StorageCredentials(accountName, accountKey));
// Set the service properties.
ServiceProperties sp = client.GetServiceProperties();
sp.DefaultServiceVersion = "2013-08-15";
CorsRule cr = new CorsRule();
cr.AllowedHeaders.Add("*");
cr.AllowedMethods = CorsHttpMethods.Get | CorsHttpMethods.Put;
cr.AllowedOrigins.Add("http://www.contoso.com");
cr.ExposedHeaders.Add("x-ms-*");
cr.MaxAgeInSeconds = 5;
sp.Cors.CorsRules.Clear();
sp.Cors.CorsRules.Add(cr);
client.SetServiceProperties(sp);

Création d’un objet blob de pages vide d’une taille spécifique

Pour créer un objet blob de pages, nous créons d’abord un objet CloudBlobClient , avec l’URI de base pour accéder au stockage d’objets blob pour votre compte de stockage (pbaccount dans la figure 1) ainsi que l’objet StorageCredentialsAccountAndKey , comme illustré dans l’exemple suivant. L’exemple montre ensuite la création d’une référence à un objet CloudBlobContainer , puis la création du conteneur (testvhds) s’il n’existe pas déjà. Ensuite, à l’aide de l’objet CloudBlobContainer , créez une référence à un objet CloudPageBlob en spécifiant le nom de l’objet blob de pages (os4.vhd) à accéder. Pour créer l’objet blob de pages, appelez CloudPageBlob.Create, en passant la taille maximale de l’objet blob à créer. L’objet blobSize doit être un multiple de 512 octets.

using Microsoft.Azure;
using Microsoft.Azure.Storage;
using Microsoft.Azure.Storage.Blob;

long OneGigabyteAsBytes = 1024 * 1024 * 1024;
// Retrieve storage account from connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
    CloudConfigurationManager.GetSetting("StorageConnectionString"));

// Create the blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

// Retrieve a reference to a container.
CloudBlobContainer container = blobClient.GetContainerReference("testvhds");

// Create the container if it doesn't already exist.
container.CreateIfNotExists();

CloudPageBlob pageBlob = container.GetPageBlobReference("os4.vhd");
pageBlob.Create(16 * OneGigabyteAsBytes);

Redimensionnement d’un objet blob de pages

Pour redimensionner un objet blob de pages après sa création, utilisez la méthode Redimensionner. La taille demandée doit être un multiple de 512 octets.

pageBlob.Resize(32 * OneGigabyteAsBytes);

Écriture des pages dans un blob de page

Pour écrire des pages, utilisez la méthode CloudPageBlob.WritePages .

pageBlob.WritePages(dataStream, startingOffset);

Lecture de pages à partir d'un blob de pages

Pour lire des pages, utilisez la méthode CloudPageBlob.DownloadRangeToByteArray pour lire une plage d’octets à partir de l’objet blob de pages.

byte[] buffer = new byte[rangeSize];
pageBlob.DownloadRangeToByteArray(buffer, bufferOffset, pageBlobOffset, rangeSize);

Pour déterminer les pages qui sont sauvegardées par des données, utilisez CloudPageBlob.GetPageRanges. Vous pouvez alors énumérer les plages retournées et télécharger les données dans chaque plage.

IEnumerable<PageRange> pageRanges = pageBlob.GetPageRanges();

foreach (PageRange range in pageRanges)
{
    // Calculate the range size
    int rangeSize = (int)(range.EndOffset + 1 - range.StartOffset);

    byte[] buffer = new byte[rangeSize];

    // Read from the correct starting offset in the page blob and
    // place the data in the bufferOffset of the buffer byte array
    pageBlob.DownloadRangeToByteArray(buffer, bufferOffset, range.StartOffset, rangeSize);

    // Then use the buffer for the page range just read
}

Partager via

Exemples de code Stockage Blob Azure utilisant les bibliothèques clientes .NET version 11.x

Créer un instantané

Supprimez les instantanés

Créer une stratégie d’accès enregistrée

Créer une SAS de service pour un conteneur blob

Créer une SAP de service pour un objet blob

Créer une SAP de compte

Utiliser un SAS de compte à partir d’un client

Concurrence optimiste pour les blobs

Concurrence pessimiste pour les blobs

Créez une application hautement disponible avec Azure Blob Storage

Configurer l'exemple

Exécuter l’application console

Comprendre l’exemple de code

Gestionnaire d'événements de réessai

Gestionnaire d'événement de fin de demande

Charger de grandes quantités de données aléatoires dans le stockage Azure

Télécharger de grandes quantités de données aléatoires depuis le stockage Azure

Activer les journaux Azure Storage Analytics (classique)

Modification de la période de rétention des données de journal

Activer les métriques Azure Storage Analytics (classique)

Configurer TLS (Transport Layer Security) pour une application cliente

Surveiller, diagnostiquer et résoudre les problèmes liés au stockage Microsoft Azure (classique)

Examen des problèmes de performances du client - désactiver l’algorithme Nagle

Examen des problèmes de latence réseau - configurer le partage de ressources cross origin (CORS)

Création d’un objet blob de pages vide d’une taille spécifique

Redimensionnement d’un objet blob de pages

Écriture des pages dans un blob de page

Lecture de pages à partir d'un blob de pages

Ressources supplémentaires