Sdílet prostřednictvím

Ukázky kódu služby Azure Blob Storage pomocí klientských knihoven .NET verze 11.x

Tento článek ukazuje ukázky kódu, které používají verzi 11.x klientské knihovny služby Azure Blob Storage pro .NET.

31. března 2023 jsme vyřadili podporu knihoven sady Azure SDK, které neodpovídají aktuálních pokynů sady Azure SDK. Nové knihovny sady Azure SDK se pravidelně aktualizují, aby poskytovaly konzistentní zážitky a posílily vaši bezpečnostní pozici. Doporučujeme přejít na nové knihovny sady Azure SDK, abyste mohli využívat nové funkce a důležité aktualizace zabezpečení.

I když starší knihovny je možné používat i po 31. březnu 2023, nebudou už od Microsoftu dostávat oficiální podporu a aktualizace. Další informace najdete v oznámení o vyřazení podpory.

Vytvoření snímku

Pokud chcete vytvořit snímek objektu blob bloku pomocí verze 11.x klientské knihovny Azure Storage pro .NET, použijte jednu z následujících metod:

Následující příklad kódu ukazuje, jak vytvořit snímek s verzí 11.x. Tento příklad určuje další metadata snímku při jeho vytvoření.

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

Odstranění snímků

Pokud chcete odstranit objekt blob a jeho snímky pomocí verze 11.x klientské knihovny Azure Storage pro .NET, použijte jednu z následujících metod odstranění objektů blob a zahrňte výčet DeleteSnapshotsOption.

Následující příklad kódu ukazuje, jak odstranit objekt blob a jeho snímky v .NET, kde blockBlob je objekt typu [CloudBlockBlob][dotnet_CloudBlockBlob]:

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

Vytvoření uložených zásad přístupu

Pokud chcete vytvořit uložené zásady přístupu v kontejneru s verzí 11.x klientské knihovny .NET pro Azure Storage, zavolejte jednu z následujících metod:

Následující příklad vytvoří uloženou zásadu přístupu, která je platná pro jeden den a uděluje oprávnění ke čtení, zápisu a seznamu:

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

Vytvoření služebního SAS pro úložiště blob

Pokud chcete vytvořit SAS služby pro kontejner, zavolejte metodu 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;
}

Vytvořte SAS služby pro objekt blob

Pokud chcete vytvořit SAS služby pro objekt blob, zavolejte metodu 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;
}

Vytvořit účet SAS

Pokud chcete vytvořit SAS účtu pro kontejner, zavolejte metodu CloudStorageAccount.GetSharedAccessSignature.

Následující příklad kódu vytvoří SAS účtu, který je platný pro služby Blob a File a dává klientovi oprávnění ke čtení, zápisu a výpisu pro přístup ke služebním rozhraním API. SAS účtu omezuje protokol na HTTPS, takže požadavek musí být proveden s protokolem HTTPS. Nezapomeňte nahradit zástupné hodnoty v hranatých závorkách vlastními hodnotami:

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

Použijte SAS účtu z klienta

V tomto fragmentu kódu nahraďte zástupný symbol <storage-account> názvem vašeho účtu úložiště.

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

Optimistická souběžnost pro blobové objekty

Příklad kódu:

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

Pesimistický současný přístup k blobovým objektům

Příklad kódu:

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

Vytvoření vysoce dostupné aplikace se službou Blob Storage

Stáhněte si ukázkový projekt, extrahujte (rozbalte) soubor storage-dotnet-circuit-breaker-pattern-ha-apps-using-ra-grs.zip a přejděte do složky v11 a vyhledejte soubory projektu.

Ke stažení kopie aplikace do vývojového prostředí můžete také použít git. Ukázkový projekt ve složce v11 obsahuje konzolovou aplikaci.

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

Konfigurace ukázky

V aplikaci musíte zadat připojovací řetězec pro váš účet úložiště. Tento připojovací řetězec můžete uložit v proměnné prostředí na místním počítači, na kterém běží aplikace. Postupujte podle jednoho z následujících příkladů v závislosti na vašem operačním systému a vytvořte proměnnou prostředí.

Na webu Azure Portal přejděte ke svému účtu úložiště. V části Nastavení v účtu úložiště vyberte Přístupové klíče. Zkopírujte připojovací řetězec z primárního nebo sekundárního klíče. Spusťte jeden z následujících příkazů na základě vašeho operačního systému a nahraďte <vaše_připojovací_řetězec> skutečným připojovacím řetězcem. Tento příkaz uloží proměnnou prostředí do místního počítače. Ve Windows není proměnná prostředí dostupná, dokud znovu nenačtete příkazový řádek nebo shell, který používáte.

Spustit konzolovou aplikaci

V sadě Visual Studio stiskněte klávesu F5 nebo vyberte Spustit a spusťte ladění aplikace. Visual Studio automaticky obnoví chybějící balíčky NuGet, pokud je nakonfigurováno obnovení balíčku, navštivte Instalace a přeinstalace balíčků s obnovením balíčků další informace.

Spustí se okno konzoly a aplikace začne běžet. Aplikace nahraje obrázek HelloWorld.png z řešení do účtu úložiště. Aplikace zkontroluje, jestli se image replikovala do sekundárního koncového bodu RA-GZRS. Pak začne stahovat obrázek až 999krát. Každé čtení je reprezentováno P nebo S. Kde P představuje primární koncový bod a S představuje sekundární koncový bod.

V ukázkovém kódu se úloha RunCircuitBreakerAsync v souboru Program.cs používá ke stažení obrázku z účtu úložiště pomocí metody DownloadToFileAsync. Před stažením se definuje OperationContext. Kontext operace definuje obslužné rutiny událostí, které se aktivují po úspěšném dokončení stahování, nebo pokud stahování selže a znovu se pokouší.

Vysvětlení vzorového kódu

Zpracování události opětovného pokusu

Obslužná rutina události OperationContextRetrying je volána, když stahování obrázku selže a je nastaveno na opakování. Pokud dosáhnete maximálního počtu opakování definovaných v aplikaci, LocationMode požadavku se změní na SecondaryOnly. Toto nastavení vynutí aplikaci, aby se pokusila stáhnout image ze sekundárního koncového bodu. Tato konfigurace zkracuje dobu potřebnou k vyžádání obrazu, protože se primární koncový bod nebude opakovaně zkoušet bez konce.

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

Obslužná rutina pro událost dokončení žádosti

Obslužná rutina události OperationContextRequestCompleted je volána, když dojde k úspěšnému stažení obrázku. Pokud aplikace používá sekundární koncový bod, aplikace bude tento koncový bod dál používat až 20krát. Po 20 časech aplikace nastaví LocationMode zpět na PrimaryThenSecondary a znovu se pokusí o primární koncový bod. Pokud je požadavek úspěšný, aplikace bude dál číst z primárního koncového bodu.

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

Nahrání velkých objemů náhodných dat do úložiště Azure

Minimální a maximální počet vláken je nastaven na 100, aby se zajistilo, že je povolený velký počet souběžných připojení.

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

Kromě nastavení nastavení omezení počtu vláken a připojení jsou BlobRequestOptions pro metodu UploadFromStreamAsync nakonfigurovaná tak, aby používala paralelismus a zakázala ověřování hodnot hash MD5. Soubory se nahrávají v blocích o velikosti 100 MB. Tato konfigurace poskytuje lepší výkon, ale může být nákladná, pokud používáte špatně výkonnou síť, protože v případě selhání se musí celý 100MB blok znovu nahrát.

Vlastnictví Hodnota Popis
Počet vláken paralelní operace 8 Nastavení při nahrávání rozdělí objekt blob na bloky. Pro nejvyšší výkon by tato hodnota měla být osmkrát větší než počet jader.
DisableContentMD5Validation pravda Tato vlastnost zakáže kontrolu hodnoty hash MD5 nahraného obsahu. Zakázání ověřování MD5 způsobí rychlejší přenos. Neověřuje ale platnost ani integritu přenášených souborů.
StoreBlobContentMD5 falešný Tato vlastnost určuje, jestli se vypočítá a uloží hodnota hash MD5 se souborem.
RetryPolicy 2 sekundový odstup s maximálně 10 opakováními Určuje zásadu opakování požadavků. Chyby připojení jsou znovu zkoušeny, v tomto příkladu je nakonfigurována zásada ExponentialRetry s počátečním dvousekundovým zdržením a maximálním počtem opakování 10. Toto nastavení je důležité, když se vaše aplikace blíží dosažení cílů škálovatelnosti úložiště objektů blob. Další informace najdete v tématu Škálovatelnost a cíle výkonu pro úložiště objektů blob.

Stahování velkých objemů náhodných dat z úložiště Azure

Aplikace načte kontejnery umístěné v účtu úložiště zadaném v storageconnectionstring . Iteruje objekty blob 10 najednou pomocí metody ListBlobsSegmentedAsync v kontejnerech a stáhne je do místního počítače pomocí metody DownloadToFileAsync.

Následující tabulka ukazuje BlobRequestOptions definované pro každý objekt blob během jeho stahování.

Vlastnictví Hodnota Popis
DisableContentMD5Validation pravda Tato vlastnost zakáže kontrolu hodnoty hash MD5 nahraného obsahu. Zakázání ověřování MD5 způsobí rychlejší přenos. Neověřuje ale platnost ani integritu přenášených souborů.
StoreBlobContentMD5 falešný Tato vlastnost určuje, jestli se vypočítá a uloží hodnota hash MD5. 
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();
}

Povolte protokoly Analýzy úložiště Azure (Classic)

Příklad kódu:

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

Změna doby uchovávání dat protokolu

Následující příklad vytiskne do konzoly dobu uchovávání pro služby Blob Storage a Queue Storage.

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

Následující příklad změní dobu uchovávání protokolů pro služby Blob Storage a Queue Storage na 4 dny.


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

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

Povolit metriky klasické Azure Storage Analytics

Příklad kódu:

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

Konfigurace protokolu TLS (Transport Layer Security) pro klientskou aplikaci

Následující ukázka ukazuje, jak povolit protokol TLS 1.2 v klientovi .NET pomocí verze 11.x klientské knihovny Azure Storage:

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

Monitorování, diagnostika a řešení potíží se službou Microsoft Azure Storage (Classic)

Pokud klientská knihovna úložiště vyvolá StorageException u klienta, vlastnost RequestInformation obsahuje objekt RequestResult, který zahrnuje vlastnost ServiceRequestID. Můžete také přistupovat k objektu RequestResult z instance OperationContext.

Následující ukázka kódu ukazuje, jak nastavit vlastní hodnotu ClientRequestId připojením objektu OperationContext k požadavku na službu úložiště. Také ukazuje, jak načíst hodnotu ServerRequestId ze zprávy odpovědi.

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

Zkoumání problémů s výkonem klienta – zakázání algoritmu Nagle

Příklad kódu:

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

Zkoumání problémů s latencí sítě – konfigurace sdílení prostředků mezi zdroji (CORS)

Příklad kódu:

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

Vytvoření prázdného blobu stránky o zadané velikosti

Abychom vytvořili objekt blob stránky, nejprve vytvoříme objekt CloudBlobClient s základním identifikátorem URI pro přístup k úložišti objektů blob pro váš účet úložiště (pbaccount na obrázku 1) společně s objektem StorageCredentialsAccountAndKey, jak je znázorněno v následujícím příkladu. Příklad pak ukazuje vytvoření odkazu na objekt CloudBlobContainer a potom vytvoření kontejneru (testvhds), pokud ještě neexistuje. Potom pomocí objektu CloudBlobContainer vytvořte odkaz na objekt CloudPageBlob zadáním názvu objektu blob stránky (os4.vhd) pro přístup. Pokud chcete vytvořit objekt blob stránky, zavolejte CloudPageBlob.Createa předejte maximální velikost objektu blob, která se má vytvořit. blobSize musí být násobkem 512 bajtů.

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

Změna velikosti page blobu

Pokud chcete po vytvoření změnit velikost objektu blob stránky, použijte metodu Změna velikosti . Požadovaná velikost by měla být násobkem 512 bajtů.

pageBlob.Resize(32 * OneGigabyteAsBytes);

Zápis stránek do objektu blob stránky

Chcete-li stránky zapisovat, použijte CloudPageBlob.WritePages metodu.

pageBlob.WritePages(dataStream, startingOffset);

Čtení stránek ze stránkového objektu blob

Ke čtení stránek použijte metodu CloudPageBlob.DownloadRangeToByteArray ke čtení rozsahu bajtů z objektu blob stránky.

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

Chcete-li zjistit, které stránky jsou podporovány daty, použijte CloudPageBlob.GetPageRanges. Pak můžete zobrazit výčet vrácených oblastí a stáhnout data v jednotlivých oblastech.

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