Freigeben über

Azure Blob Storage-Codebeispiele mit .NET Version 11.x-Clientbibliotheken

Dieser Artikel enthält Codebeispiele, die Version 11.x der Azure Blob Storage-Clientbibliothek für .NET verwenden.

Am 31. März 2023 haben wir die Unterstützung für Azure SDK-Bibliotheken eingestellt, die nicht den aktuellen Azure SDK-Richtlinien entsprachen. Die neuen Azure SDK-Bibliotheken werden regelmäßig aktualisiert, um konsistente Erfahrungen zu ermöglichen und Ihren Sicherheitsstatus zu stärken. Es wird empfohlen, auf die neuen Azure SDK-Bibliotheken umzusteigen, um die neuen Funktionen und wichtigen Sicherheitsupdates zu nutzen.

Obwohl die älteren Bibliotheken noch über den 31. März 2023 hinaus verwendet werden können, erhalten sie keinen offiziellen Support und keine Updates mehr von Microsoft. Weitere Informationen finden Sie in der Ankündigung des Support-Rückzugs.

Erstellen einer Momentaufnahme

Verwenden Sie eine der folgenden Methoden, um mit Version 11.x der Azure Storage-Clientbibliothek für .NET eine Momentaufnahme eines Blockblobs zu erstellen:

Das folgende Codebeispiel zeigt, wie Sie eine Momentaufnahme mit Version 11.x erstellen. In diesem Beispiel werden zusätzliche Metadaten für die Momentaufnahme angegeben, wenn sie erstellt wird.

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;
    }
}

Schnappschüsse löschen

Zum Löschen eines Blobs und seiner Momentaufnahmen mit Version 11.x der Azure Storage-Clientbibliothek für .NET verwenden Sie eine der folgenden Blob-Löschmethoden, und schließen Sie die Enumeration "DeleteSnapshotsOption " ein:

Das folgende Codebeispiel zeigt, wie Sie ein Blob und seine Momentaufnahmen in .NET löschen, wobei blockBlob es sich um ein Objekt vom Typ [CloudBlockBlob][dotnet_CloudBlockBlob]handelt:

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

Erstellen einer gespeicherten Zugriffsrichtlinie

Rufen Sie eine der folgenden Methoden auf, um eine gespeicherte Zugriffsrichtlinie für einen Container mit Version 11.x der .NET-Clientbibliothek für Azure Storage zu erstellen:

Im folgenden Beispiel wird eine gespeicherte Zugriffsrichtlinie erstellt, die für einen Tag wirksam ist und Lese-, Schreib- und Listenberechtigungen gewährt:

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);
}

Erstellen einer Dienst-SAS für einen Blobcontainer

Rufen Sie zum Erstellen eines Dienst-SAS für einen Container die Methode CloudBlobContainer.GetSharedAccessSignature auf.

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;
}

Erstellen einer Dienst-SAS für ein Blob

Rufen Sie die CloudBlob.GetSharedAccessSignature-Methode auf, um einen Dienst-SAS für ein Blob zu erstellen.

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;
}

Erstellen eines Kontos SAS

Rufen Sie zum Erstellen eines Kontos SAS für einen Container die CloudStorageAccount.GetSharedAccessSignature-Methode auf.

Im folgenden Codebeispiel wird ein SAS-Konto erstellt, das für die Blob- und Dateidienste gültig ist und dem Client Lese-, Schreib- und Listenberechtigungen gewährt, um auf APIs auf Dienstebene von Diensten zuzugreifen. Das Konto SAS schränkt das Protokoll auf HTTPS ein, sodass die Anforderung mit HTTPS erfolgen muss. Denken Sie daran, die Platzhalterwerte in eckigen Klammern durch Ihre eigenen Werte zu ersetzen:

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);
}

Verwenden Sie eine Konto-SAS von einem Client

Ersetzen Sie in diesem Codeausschnitt den <storage-account> Platzhalter durch den Namen Ihres Speicherkontos.

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);
}

Optimistische Parallelität für Blobs

Codebeispiel:

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();
}

Pessimistische Nebenläufigkeit für Blobs

Codebeispiel:

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();
}

Erstellen einer hoch verfügbaren App mit Blob Storage

Laden Sie das Beispielprojekt herunter, extrahieren (entzippen) Sie die storage-dotnet-circuit-breaker-pattern-ha-apps-using-ra-grs.zip Datei, und navigieren Sie dann zum Ordner v11 , um die Projektdateien zu finden.

Sie können git auch verwenden, um eine Kopie der Anwendung in Ihre Entwicklungsumgebung herunterzuladen. Das Beispielprojekt im Ordner "v11" enthält eine Konsolenanwendung.

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

Das Beispiel konfigurieren

In der Anwendung müssen Sie die Verbindungszeichenfolge für Ihr Speicherkonto angeben. Sie können diese Verbindungszeichenfolge in einer Umgebungsvariable auf dem lokalen Computer speichern, auf dem die Anwendung ausgeführt wird. Folgen Sie einem der folgenden Beispiele, je nach Betriebssystem, um die Umgebungsvariable zu erstellen.

Navigieren Sie im Azure-Portal zu Ihrem Speicherkonto. Wählen Sie in Ihrem Speicherkonto unter Einstellungen die Option Zugriffsschlüssel aus. Kopieren Sie die Verbindungszeichenfolge aus dem primären oder sekundären Schlüssel. Führen Sie einen der folgenden Befehle basierend auf Ihrem Betriebssystem aus, und ersetzen <Sie die Verbindungszeichenfolge> durch die tatsächliche Verbindungszeichenfolge. Mit diesem Befehl wird eine Umgebungsvariable auf dem lokalen Computer gespeichert. In Windows ist die Umgebungsvariable erst verfügbar, wenn Sie die von Ihnen verwendete Eingabeaufforderung oder Shell neu laden.

Ausführen der Konsolenanwendung

Drücken Sie in Visual Studio F5, oder wählen Sie Starten aus, um mit dem Debuggen der Anwendung zu beginnen. Visual Studio stellt automatisch fehlende NuGet-Pakete wieder her, wenn die Paketwiederherstellung konfiguriert ist, besuchen Sie " Installieren und erneutes Installieren von Paketen mit Paketwiederherstellung ", um mehr zu erfahren.

Ein Konsolenfenster wird gestartet, und die Anwendung beginnt mit der Ausführung. Die Anwendung lädt das HelloWorld.png Bild aus der Lösung in das Speicherkonto hoch. Die Anwendung überprüft, ob das Bild auf den sekundären RA-GZRS-Endpunkt repliziert wurde. Das Bild wird dann bis zu 999 Mal heruntergeladen. Jeder Lesevorgang wird durch ein P oder ein S dargestellt. Dabei stellt P den primären Endpunkt und S den sekundären Endpunkt dar.

Im Beispielcode wird die RunCircuitBreakerAsync Aufgabe in der Program.cs Datei verwendet, um ein Bild aus dem Speicherkonto mithilfe der DownloadToFileAsync-Methode herunterzuladen. Vor dem Download wird ein OperationContext definiert. Der Vorgangskontext definiert Ereignishandler, die ausgelöst werden, wenn ein Download erfolgreich abgeschlossen wird oder wenn ein Download fehlschlägt und wiederholt wird.

Den Beispielcode verstehen

Wiederholen des Ereignishandlers

Der OperationContextRetrying Ereignishandler wird aufgerufen, wenn der Download des Bildes fehlschlägt und wird auf einen erneuten Versuch gesetzt. Wenn die maximale Anzahl der in der Anwendung definierten Wiederholungsversuche erreicht ist, wird der LocationMode der Anforderung in SecondaryOnly" geändert. Diese Einstellung erzwingt, dass die Anwendung versucht, das Bild vom sekundären Endpunkt herunterzuladen. Diese Konfiguration reduziert die Zeit, die zum Anfordern des Images erforderlich ist, da der primäre Endpunkt nicht unbegrenzt versucht wird.

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. ");
        }
    }
}

Anforderung abgeschlossener Ereignishandler

Der OperationContextRequestCompleted Ereignishandler wird aufgerufen, wenn der Download des Images erfolgreich ist. Wenn die Anwendung den sekundären Endpunkt verwendet, verwendet die Anwendung diesen Endpunkt bis zu 20 Mal. Nach 20 Versuchen legt die Anwendung den LocationMode wieder fest und versucht es erneut mit dem PrimaryThenSecondary primären Endpunkt. Wenn eine Anforderung erfolgreich ist, liest die Anwendung weiterhin vom primären Endpunkt aus.

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;
        }
    }
}

Hochladen großer Mengen zufälliger Daten in Azure Storage

Die minimale und maximale Anzahl von Threads wird auf 100 festgelegt, um sicherzustellen, dass eine große Anzahl gleichzeitiger Verbindungen zulässig ist.

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);
    }
}

Zusätzlich zum Festlegen der Einstellungen für Threading und Verbindungsbeschränkungen sind die BlobRequestOptions für die UploadFromStreamAsync-Methode für die Verwendung von Parallelität und Deaktivieren der MD5-Hashüberprüfung konfiguriert. Die Dateien werden in 100-MB-Blöcken hochgeladen. Diese Konfiguration bietet eine bessere Leistung, kann aber kostspielig sein, wenn ein Netzwerk mit schlechter Leistung verwendet wird, da bei einem Fehler der gesamte 100-MB-Block erneut hochgeladen wird.

Eigentum Wert BESCHREIBUNG
ParallelOperationThreadCount 8 Durch die Einstellung wird das Blob beim Hochladen in Blöcke unterteilt. Bei der höchsten Leistung sollte dieser Wert achtmal die Anzahl der Kerne sein.
DeaktivierenDerContentMD5Validierung Wahr Diese Eigenschaft deaktiviert die Überprüfung des MD5-Hashs des hochgeladenen Inhalts. Durch das Deaktivieren der MD5-Überprüfung wird eine schnellere Übertragung erzeugt. Bestätigt jedoch nicht die Gültigkeit oder Integrität der übertragenen Dateien.
StoreBlobContentMD5 Falsch Diese Eigenschaft bestimmt, ob ein MD5-Hash berechnet und mit der Datei gespeichert wird.
RetryPolicy 2-Sekunden-Backoff mit maximal 10 Wiederholungen Bestimmt die Wiederholungsstrategie von Anfragen. Verbindungsfehler werden wiederholt, in diesem Beispiel wird eine ExponentialRetry-Richtlinie mit einem 2-Sekunden-Backoff und einer maximalen Wiederholungsanzahl von 10 konfiguriert. Diese Einstellung ist wichtig, wenn Ihre Anwendung nahe kommt, um die Skalierbarkeitsziele für Blob Storage zu erreichen. Weitere Informationen finden Sie unter Skalierbarkeits- und Leistungsziele für Blob Storage.

Herunterladen großer Mengen von Zufallsdaten von Azure Storage

Die Anwendung liest die Container, die sich in dem speicherkonto befinden, das in der storageconnectionstring angegeben ist. Sie durchläuft die Blobs 10 gleichzeitig mithilfe der ListBlobsSegmentedAsync-Methode in den Containern und lädt sie mithilfe der DownloadToFileAsync-Methode auf den lokalen Computer herunter.

In der folgenden Tabelle sind die BlobRequestOptions aufgeführt, die für jedes Blob definiert sind, während es heruntergeladen wird.

Eigentum Wert BESCHREIBUNG
DeaktiviereInhaltsMD5Validierung Wahr Diese Eigenschaft deaktiviert die Überprüfung des MD5-Hashs des hochgeladenen Inhalts. Durch das Deaktivieren der MD5-Überprüfung wird eine schnellere Übertragung erzeugt. Bestätigt jedoch nicht die Gültigkeit oder Integrität der übertragenen Dateien.
StoreBlobContentMD5 Falsch Diese Eigenschaft bestimmt, ob ein MD5-Hash berechnet und gespeichert wird. 
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();
}

Aktivieren von Azure Storage Analytics-Protokollen (klassisch)

Codebeispiel:

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);

Ändern der Aufbewahrungsdauer für Protokolldaten

Im folgenden Beispiel wird der Aufbewahrungszeitraum für Blob- und Warteschlangenspeicherdienste in der Konsole ausgegeben.

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());

Im folgenden Beispiel wird der Aufbewahrungszeitraum für Protokolle für die Blob- und Warteschlangenspeicherdienste auf 4 Tage geändert.


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

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

Aktivieren von Azure Storage Analytics-Metriken (klassisch)

Codebeispiel:

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);

Konfigurieren von Transport Layer Security (TLS) für eine Clientanwendung

Das folgende Beispiel zeigt, wie TLS 1.2 in einem .NET-Client mit Version 11.x der Azure Storage-Clientbibliothek aktiviert wird:

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();
}

Überwachen, Diagnostizieren und Problembehandlung von Microsoft Azure Storage (klassisch)

Wenn die Speicherclientbibliothek eine StorageException im Client auslöst, enthält die RequestInformation-Eigenschaft ein RequestResult-Objekt , das eine ServiceRequestID-Eigenschaft enthält. Sie können auch über eine OperationContext-Instanz auf ein RequestResult-Objekt zugreifen.

Im folgenden Codebeispiel wird veranschaulicht, wie sie einen benutzerdefinierten ClientRequestId-Wert festlegen, indem ein OperationContext-Objekt der Anforderung an den Speicherdienst angefügt wird. Außerdem wird gezeigt, wie der ServerRequestId-Wert aus der Antwortnachricht abgerufen wird.

//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);
    }
}

Untersuchen von Clientleistungsproblemen – Deaktivieren des Nagle-Algorithmus

Codebeispiel:

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

Untersuchung von Netzwerklatenzproblemen – Konfigurieren von Cross-Origin Resource Sharing (CORS)

Codebeispiel:

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);

Erstellen eines leeren Seitenblobs mit einer bestimmten Größe

Zum Erstellen eines Seiten-Blobs erstellen wir zunächst ein CloudBlobClient-Objekt mit dem Basis-URI für den Zugriff auf den BLOB-Speicher für Ihr Speicherkonto (Pbaccount in Abbildung 1) zusammen mit dem StorageCredentialsAccountAndKey-Objekt , wie im folgenden Beispiel gezeigt. Das Beispiel zeigt dann das Erstellen eines Verweises auf ein CloudBlobContainer -Objekt und dann das Erstellen des Containers (testvhds), falls er noch nicht vorhanden ist. Erstellen Sie dann mithilfe des CloudBlobContainer-Objekts einen Verweis auf ein CloudPageBlob-Objekt , indem Sie den Seiten-BLOB-Namen (os4.vhd) für den Zugriff angeben. Rufen Sie zum Erstellen des Seiten-BLOB CloudPageBlob.Create auf, und übergeben Sie die maximale Größe für das zu erstellende Blob. BlobSize muss ein Vielfaches von 512 Byte sein.

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);

Ändern der Größe eines Seitenblobs

Verwenden Sie zum Ändern der Größe eines Seitenblobs nach der Erstellung die Resize-Methode. Die angeforderte Größe sollte ein Vielfaches von 512 Bytes sein.

pageBlob.Resize(32 * OneGigabyteAsBytes);

Seiten in ein Seitenblob schreiben

Verwenden Sie zum Schreiben von Seiten die CloudPageBlob.WritePages-Methode .

pageBlob.WritePages(dataStream, startingOffset);

Lesen von Seiten aus einem Seitenblob

Verwenden Sie zum Lesen von Seiten die CloudPageBlob.DownloadRangeToByteArray-Methode , um einen Bytebereich aus dem Seiten-BLOB zu lesen.

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

Verwenden Sie "CloudPageBlob.GetPageRanges", um zu bestimmen, welche Seiten durch Daten gesichert werden. Sie können dann die zurückgegebenen Bereiche aufzählen und die Daten in jedem Bereich herunterladen.

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
}
  • Last updated on