Aracılığıyla paylaş

.NET sürüm 11.x istemci kitaplıklarını kullanan Azure Blob Depolama kod örnekleri

Bu makalede, .NET için Azure Blob Depolama istemci kitaplığının 11.x sürümünü kullanan kod örnekleri gösterilmektedir.

31 Mart 2023'te, geçerli Azure SDK yönergelerine uymayan Azure SDK kitaplıkları desteğini kullanımdan kaldırdık. Yeni Azure SDK kitaplıkları, tutarlı deneyimler sağlamak ve güvenlik duruşunuzu güçlendirmek için düzenli olarak güncelleştirilir. Yeni özelliklerden ve kritik güvenlik güncelleştirmelerinden yararlanmak için yeni Azure SDK kitaplıklarına geçiş yapmanızı öneririz.

Eski kitaplıklar 31 Mart 2023'ten sonra da kullanılabilir olsa da artık Microsoft'tan resmi destek ve güncelleştirmeler almayacaktır. Daha fazla bilgi için destek kullanımdan kaldırma duyurusu kısmına bakınız.

Anlık görüntü oluşturma

.NET için Azure Depolama istemci kitaplığının 11.x sürümünü kullanarak bir blok blobunun anlık görüntüsünü oluşturmak için aşağıdaki yöntemlerden birini kullanın:

Aşağıdaki kod örneğinde 11.x sürümüyle anlık görüntü oluşturma gösterilmektedir. Bu örnek, oluşturulduğunda anlık görüntü için ek meta verileri belirtir.

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

Anlık görüntüleri silme

.NET için Azure Depolama istemci kitaplığının 11.x sürümünü kullanarak bir blobu ve anlık görüntülerini silmek için aşağıdaki blob silme yöntemlerinden birini kullanın ve DeleteSnapshotsOption numaralandırmasını ekleyin:

Aşağıdaki kod örneğinde ,NET'te bir blobun ve anlık görüntülerinin nasıl silineceği gösterilmektedir; burada blockBlob [CloudBlockBlob][dotnet_CloudBlockBlob] türünde bir nesnedir:

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

Depolanan erişim ilkesi oluştur

Azure Depolama için .NET istemci kitaplığının 11.x sürümüne sahip bir kapsayıcıda depolanan erişim ilkesi oluşturmak için aşağıdaki yöntemlerden birini çağırın:

Aşağıdaki örnek, bir gün boyunca geçerli olan ve okuma, yazma ve liste izinleri veren bir saklı erişim ilkesi oluşturur:

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

Blob kapsayıcısı için bir hizmet SAS'i oluşturun

Kapsayıcı için hizmet SAS'ı oluşturmak için cloudblobcontainer.getsharedaccesssignature yöntemini çağırın.

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

Blob için hizmet SAS’ı oluşturma

Blob için bir hizmet SAS'ı oluşturmak amacıyla CloudBlob.GetSharedAccessSignature yöntemini çağırın.

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

SAS hesabı oluştur

Kapsayıcı için bir hesap SAS'ı oluşturmak için CloudStorageAccount.GetSharedAccessSignature yöntemini çağırın.

Aşağıdaki kod örneği, Blob ve Dosya hizmetleri için geçerli olan bir hesap SAS'ı oluşturur ve istemciye hizmet düzeyi API'lere erişmek için okuma, yazma ve liste izinleri verir. Hesap SAS'i protokolü HTTPS ile kısıtlar, bu nedenle isteğin HTTPS ile yapılması gerekir. Köşeli ayraçlardaki yer tutucu değerleri kendi değerlerinizle değiştirmeyi unutmayın:

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

İstemcide hesap SAS kullanma

Bu kod parçacığında, <storage-account> yer tutucusunun yerine depolama hesabınızın adını yazın.

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

Bloblar için iyimser eşzamanlılık

Kod örneği:

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

Bloblar için kötümser eşzamanlılık

Kod örneği:

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

Blob Depolama ile yüksek oranda kullanılabilir bir uygulama oluşturma

örnek projesini indirin, storage-dotnet-circuit-breaker-pattern-ha-apps-using-ra-grs.zip dosyasını ayıklayın (sıkıştırmasını açın), ardından proje dosyalarını bulmak için v11 klasörüne gidin.

Uygulamanın bir kopyasını geliştirme ortamınıza indirmek için git de kullanabilirsiniz. v11 klasöründeki örnek proje bir konsol uygulaması içerir.

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

Örneği yapılandırın.

Uygulamada, depolama hesabınız için bağlantı dizesini sağlamanız gerekir. Bu bağlantı dizesini, uygulamayı çalıştıran yerel makinedeki bir ortam değişkeni içinde depolayabilirsiniz. Ortam değişkenini oluşturmak için İşletim Sisteminize bağlı olarak aşağıdaki örneklerden birini izleyin.

Azure portalda depolama hesabınıza gidin. Depolama hesabınızdaki Ayarlar bölümünde Erişim anahtarları’nı seçin. Birincil veya ikincil anahtardaki bağlantı dizesini kopyalayın. aşağıdaki komutlardan birini işletim sisteminize göre çalıştırın ve <connectionstring> yerine gerçek bağlantı dizenizi yazın. Bu komut bir ortam değişkenini yerel makineye kaydeder. Windows'ta, kullandığınız Komut İstemi veya kabuğu yeniden yükleyene kadar ortam değişkeni etkin olmaz.

Konsol uygulamasını çalıştırma

Visual Studio'da F5 tuşuna basın veya uygulamada hata ayıklamaya başlamak için Başlat'ı seçin. Visual Studio, paket geri yükleme yapılandırılırsa eksik NuGet paketlerini otomatik olarak geri yükler. Daha fazla bilgi edinmek için Paket geri yükleme ile paketleri yükleme ve yeniden yükleme ziyaret edin.

Bir konsol penceresi açılır ve uygulama çalışmaya başlar. Uygulama, HelloWorld.png görüntüsünü çözümden depolama hesabına yükler. Uygulama, görüntünün ikincil RA-GZRS uç noktasına çoğaltılmış olduğundan emin olmak için denetler. Ardından görüntüyü en fazla 999 kez indirmeye başlar. Her okuma bir P veya Sile temsil edilir. Burada P birincil uç noktayı ve S ikincil uç noktayı temsil eder.

Örnek kodda, RunCircuitBreakerAsync dosyasındaki Program.cs görevi, DownloadToFileAsync yöntemi kullanılarak depolama hesabından görüntü indirmek için kullanılır. İndirmeden önce bir OperationContext tanımlanır. İşlem bağlamı, indirme işlemi başarıyla tamamlandığında veya indirme başarısız olduğunda ve yeniden denendiğinde tetiklenebilen olay işleyicilerini tanımlar.

Örnek kodu anlama

Olay işleyicisini yeniden deneyin

OperationContextRetrying olay işleyicisi, görüntünün indirilmesi başarısız olduğunda çağrılır ve yeniden denenecek şekilde ayarlanır. Uygulamada tanımlanan en fazla yeniden deneme sayısına ulaşılırsa, isteğin LocationModeSecondaryOnlyolarak değiştirilir. Bu ayar, uygulamayı görüntüyü ikincil uç noktadan indirmeye zorlar. Bu yapılandırma, birincil uç nokta süresiz olarak yeniden denenmediğinden görüntüyü istemek için geçen süreyi azaltır.

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

İstek tamamlandı olay işleyicisi

görüntünün indirilmesi başarılı olduğunda OperationContextRequestCompleted olay işleyicisi çağrılır. Uygulama ikincil uç noktayı kullanıyorsa, uygulama bu uç noktayı en fazla 20 kez kullanmaya devam eder. 20 kez denedikten sonra, uygulama LocationMode'i tekrar PrimaryThenSecondary olarak ayarlar ve birincil uç noktayı yeniden dener. İstek başarılı olursa, uygulama birincil uç noktadan okumaya devam eder.

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

Azure depolamaya büyük miktarda rastgele veri yükleme

Çok sayıda eşzamanlı bağlantıya izin verildiğinden emin olmak için en az ve en fazla iş parçacığı sayısı 100 olarak ayarlanır.

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

İş parçacığı ve bağlantı sınırı ayarlarının yanı sıra, UploadFromStreamAsync yöntemi için BlobRequestOptions, paralellikten yararlanarak ve MD5 karma doğrulamasını devre dışı bırakarak yapılandırılır. Dosyalar, 100 mb blokları halinde karşıya yüklenir. Bu yapılandırma daha iyi performans sağlar, ancak düşük performanslı bir ağ kullanılıyorsa, bir başarısızlık durumunda yalnızca 100 MB'lik bloğun tamamı yeniden denendiğinden maliyetli olabilir.

Mülkiyet Değer Açıklama
ParalelİşlemİşParçacığıSayısı 8 Bu ayar, yükleme sırasında blobu bloklara ayırır. En yüksek performans için bu değer çekirdek sayısının sekiz katı olmalıdır.
DisableContentMD5Validation doğru Bu özellik, karşıya yüklenen içeriğin MD5 karması denetimini devre dışı bırakır. MD5 doğrulamasını devre dışı bırakmak daha hızlı aktarım sağlar. Ancak aktarılmakta olan dosyaların geçerliliğini veya bütünlüğünü doğrulamaz.
StoreBlobContentMD5 yanlış Bu özellik, bir MD5 karması hesaplanıp hesaplanmadığını ve dosyayla birlikte depolanıp depolanmadığını belirler.
Yeniden Deneme Politikası En fazla 10 yeniden deneme ile 2 saniyelik bekleme süresi İsteklerin yeniden deneme ilkesini belirler. Bağlantı hataları yeniden denendi, bu örnekte bir ExponentialRetry ilkesi 2 saniyelik geri alma ve en fazla 10 yeniden deneme sayısı ile yapılandırılır. Uygulamanız Blob depolama için ölçeklenebilirlik hedeflerine yaklaşmaya yaklaştığında bu ayar önemlidir. Daha fazla bilgi için bkz . Blob depolama için ölçeklenebilirlik ve performans hedefleri.

Azure Depolama’dan büyük miktarda rastgele verileri indirme

Uygulama, storageconnectionstringiçinde belirtilen depolama hesabında bulunan kapsayıcıları okur. Kapsayıcılardaki ListBlobsSegmentedAsync yöntemini kullanarak her seferinde 10 blob üzerinden geçer ve bunları DownloadToFileAsync yöntemini kullanarak yerel makineye indirir.

Aşağıdaki tabloda, indirilen her blob için tanımlanan BlobRequestOptions gösterilmektedir.

Mülkiyet Değer Açıklama
DisableContentMD5Doğrulama doğru Bu özellik, karşıya yüklenen içeriğin MD5 karması denetimini devre dışı bırakır. MD5 doğrulamasını devre dışı bırakmak daha hızlı aktarım sağlar. Ancak aktarılmakta olan dosyaların geçerliliğini veya bütünlüğünü doğrulamaz.
StoreBlobContentMD5 yanlış Bu özellik, bir MD5 karmasının hesaplanıp depolanmadığını belirler. 
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();
}

Azure Depolama Analizi günlüklerini etkinleştirme (klasik)

Kod örneği:

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

Kayıt verilerini saklama süresini değiştir

Aşağıdaki örnek, blob ve kuyruk depolama hizmetlerinin saklama süresini konsola yazdırır.

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

Aşağıdaki örnek, blob ve kuyruk depolama hizmetlerinin günlüklerinin saklama süresini 4 gün olarak değiştirir.


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

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

Azure Depolama Analizi ölçümlerini etkinleştirme (klasik)

Kod örneği:

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

İstemci uygulaması için Aktarım Katmanı Güvenliğini (TLS) yapılandırma

Aşağıdaki örnekte, Azure Depolama istemci kitaplığının 11.x sürümünü kullanarak bir .NET istemcisinde TLS 1.2'nin nasıl etkinleştirileceği gösterilmektedir:

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

Microsoft Azure Depolama'yı izleme, tanılama ve sorunlarını giderme (klasik)

Eğer Depolama İstemci Kitaplığı, istemcide bir StorageException atarsa, RequestInformation özelliği, içinde ServiceRequestID özelliği bulunan bir RequestResult nesnesi içerir. RequestResult nesnesine bir OperationContext örneğinden de erişebilirsiniz.

Aşağıdaki kod örneği, isteği depolama hizmetine bir OperationContext nesnesi ekleyerek özel bir ClientRequestId değeri ayarlamanın nasıl yapılacağını göstermektedir. Ayrıca, yanıt iletisinden ServerRequestId değerinin nasıl alınıp alınamaya ilişkin bilgileri de gösterir.

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

İstemci performansı sorunlarını araştırma - Nagle algoritmasını devre dışı bırakma

Kod örneği:

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

Ağ gecikmesi sorunlarını araştırma - Çıkış Noktaları Arası Kaynak Paylaşımı'nı (CORS) yapılandırma

Kod örneği:

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

Belirtilen boyutta boş sayfa blobu oluşturma

Sayfa blobu oluşturmak için, önce aşağıdaki örnekte gösterildiği gibi depolama hesabınızın blob depolamasına erişmeye yönelik temel URI'ye (şekil 1'de pbaccount) ve StorageCredentialsAccountAndKey nesnesine sahip bir CloudBlobClient nesnesi oluştururuz. Örnekte daha sonra CloudBlobContainer nesnesine başvuru oluşturma ve henüz yoksa kapsayıcıyı (testvhds) oluşturma işlemi gösterilmektedir. Ardından CloudBlobContainer nesnesini kullanarak, erişilmesi gereken sayfa blobu adını (os4.vhd) belirterek CloudPageBlob nesnesine başvuru oluşturun. Sayfa blobunu oluşturmak için, CloudPageBlob.Create çağrısında bulunarak oluşturulacak blob için en büyük boyutu belirtin. blobSize 512 bayt'ın katı olmalıdır.

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

Sayfa blobu yeniden boyutlandırma

Oluşturulduktan sonra sayfa blobunu yeniden boyutlandırmak için Resize yöntemini kullanın. İstenen boyut 512 baytlık bir kat olmalıdır.

pageBlob.Resize(32 * OneGigabyteAsBytes);

Sayfa blobuna sayfa yazma

Sayfa yazmak için CloudPageBlob.WritePages yöntemini kullanın.

pageBlob.WritePages(dataStream, startingOffset);

Sayfa blobundan sayfaları okuma

Sayfaları okumak için CloudPageBlob.DownloadRangeToByteArray yöntemini kullanarak sayfa blobundan bir bayt aralığı okuyun.

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

Hangi sayfaların veri tarafından yedeklendiğini belirlemek için CloudPageBlob.GetPageRanges kullanın. Daha sonra döndürülen aralıkları numaralandırabilir ve her aralıktaki verileri indirebilirsiniz.

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