Azure Blob Storage codevoorbeelden met behulp van .NET versie 11.x-clientbibliotheken
Dit artikel bevat codevoorbeelden die gebruikmaken van versie 11.x van de Azure Blob Storage-clientbibliotheek voor .NET.
Op 31 maart 2023 is de ondersteuning voor Azure SDK-bibliotheken die niet voldoen aan de huidige Azure SDK-richtlijnen, buiten gebruik gesteld. De nieuwe Azure SDK-bibliotheken worden regelmatig bijgewerkt om consistente ervaringen te stimuleren en uw beveiligingspostuur te verbeteren. U wordt aangeraden over te stappen op de nieuwe Azure SDK-bibliotheken om te profiteren van de nieuwe mogelijkheden en essentiële beveiligingsupdates.
Hoewel de oudere bibliotheken na 31 maart 2023 nog steeds kunnen worden gebruikt, ontvangen ze geen officiële ondersteuning en updates meer van Microsoft. Zie de aankondiging van de buitengebruikstelling van ondersteuning voor meer informatie.
Een momentopname maken
Als u een momentopname van een blok-blob wilt maken met versie 11.x van de Azure Storage-clientbibliotheek voor .NET, gebruikt u een van de volgende methoden:
In het volgende codevoorbeeld ziet u hoe u een momentopname maakt met versie 11.x. In dit voorbeeld worden aanvullende metagegevens voor de momentopname opgegeven wanneer deze wordt gemaakt.
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;
}
}
Momentopnamen verwijderen
Als u een blob en de bijbehorende momentopnamen wilt verwijderen met versie 11.x van de Azure Storage-clientbibliotheek voor .NET, gebruikt u een van de volgende blobverwijderingsmethoden en neemt u de opsomming DeleteSnapshotsOption op :
In het volgende codevoorbeeld ziet u hoe u een blob en de bijbehorende momentopnamen verwijdert in .NET, waarbij blockBlob een object van het type [CloudBlockBlob][dotnet_CloudBlockBlob] is:
await blockBlob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, null, null);
een opgeslagen toegangsbeleid Creatie
Als u een opgeslagen toegangsbeleid wilt maken voor een container met versie 11.x van de .NET-clientbibliotheek voor Azure Storage, roept u een van de volgende methoden aan:
In het volgende voorbeeld wordt een opgeslagen toegangsbeleid gemaakt dat één dag van kracht is en dat lees-, schrijf- en lijstmachtigingen verleent:
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);
}
een service-SAS Creatie voor een blobcontainer
Als u een service-SAS voor een container wilt maken, roept u de methode CloudBlobContainer.GetSharedAccessSignature aan .
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;
}
een service-SAS voor een blob Creatie
Als u een service-SAS voor een blob wilt maken, roept u de methode CloudBlob.GetSharedAccessSignature aan .
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;
}
Een account-SAS maken
Als u een account-SAS voor een container wilt maken, roept u de methode CloudStorageAccount.GetSharedAccessSignature aan .
In het volgende codevoorbeeld wordt een account-SAS gemaakt die geldig is voor de blob- en bestandsservices, en die de client machtigingen geeft voor lezen, schrijven en lijstmachtigingen voor toegang tot API's op serviceniveau. De account-SAS beperkt het protocol tot HTTPS, dus de aanvraag moet worden gedaan met HTTPS. Vergeet niet om de waarden van de tijdelijke aanduidingen tussen de punthaken te vervangen door uw eigen waarden:
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);
}
Een account-SAS van een client gebruiken
Vervang in dit fragment de <storage-account> tijdelijke aanduiding door de naam van uw opslagaccount.
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 gelijktijdigheid voor blobs
Codevoorbeeld:
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 gelijktijdigheid voor blobs
Codevoorbeeld:
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();
}
Een maximaal beschikbare app bouwen met Blob Storage
Download het voorbeeldproject, pak het storage-dotnet-circuit-breaker-pattern-ha-apps-using-ra-grs.zip-bestand uit en navigeer vervolgens naar de map v11 om de projectbestanden te zoeken.
U kunt ook git gebruiken om een kopie van de toepassing te downloaden naar uw ontwikkelomgeving. Het voorbeeldproject in de map v11 bevat een consoletoepassing.
git clone https://github.com/Azure-Samples/storage-dotnet-circuit-breaker-pattern-ha-apps-using-ra-grs.git
Voorbeeld configureren
In de toepassing moet u de verbindingsreeks voor uw opslagaccount opgeven. U kunt deze verbindingsreeks opslaan in een omgevingsvariabele op de lokale computer waarop de toepassing wordt uitgevoerd. Volg een van de onderstaande voorbeelden afhankelijk van uw besturingssysteem voor het maken van de omgevingsvariabele.
Ga in Azure Portal naar uw opslagaccount. Selecteer bij Instellingen in uw opslagaccount de optie Toegangssleutels. Kopieer de verbindingsreeks uit de primaire of secundaire sleutel. Voer een van de volgende opdrachten uit op basis van uw besturingssysteem, waarbij <u uwconnectionstring> vervangt door uw werkelijke verbindingsreeks. Met deze opdracht slaat u een omgevingsvariabele naar de lokale machine op. In Windows is de omgevingsvariabele pas beschikbaar als u de opdrachtprompt of shell die u gebruikt, opnieuw laadt.
De consoletoepassing uitvoeren
Druk in Visual Studio op F5 of selecteer Start om foutopsporing van de toepassing te starten. Visual Studio herstelt automatisch ontbrekende NuGet-pakketten als pakketherstel is geconfigureerd. Ga naar Pakketten installeren en opnieuw installeren met pakketherstel voor meer informatie.
Er wordt een consolevenster geopend en de toepassing wordt gestart. De toepassing uploadt de afbeelding HelloWorld.png vanuit de oplossing naar het opslagaccount. De toepassing controleert of de afbeelding is gerepliceerd naar het secundaire RA-GZRS-eindpunt. Daarna wordt de afbeelding maximaal 999 keer gedownload. Elke leesbewerking wordt voorgesteld door een P of een S. P staat voor het primaire eindpunt en S voor het secundaire eindpunt.
In de voorbeeldcode wordt de taak RunCircuitBreakerAsync in het bestand Program.cs gebruikt om een afbeelding met behulp van de DownloadToFileAsync-methode te downloaden vanuit het opslagaccount. Voorafgaand aan de download is een OperationContext gedefinieerd. De bewerkingscontext definieert gebeurtenis-handlers die worden geactiveerd wanneer een download is voltooid of als een download mislukt en het opnieuw probeert.
De voorbeeldcode begrijpen
Gebeurtenis-handler opnieuw proberen
De gebeurtenis-handler OperationContextRetrying wordt aangeroepen wanneer het downloaden van de afbeelding is mislukt en is ingesteld op Opnieuw proberen. Als het maximale aantal nieuwe pogingen dat in de toepassing is gedefinieerd, is bereikt, verandert de LocationMode van de aanvraag in SecondaryOnly. Deze instelling zorgt ervoor dat de toepassing de afbeelding probeert te downloaden van het secundaire eindpunt. Deze configuratie verkort de tijd die nodig is om de installatiekopieën aan te vragen, omdat het primaire eindpunt niet voor onbepaalde tijd opnieuw wordt geprobeerd.
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. ");
}
}
}
Gebeurtenis-handler Aanvraag voltooid
De gebeurtenis-handler OperationContextRequestCompleted wordt aangeroepen wanneer het downloaden van de afbeelding is geslaagd. Als de toepassing het secundaire eindpunt gebruikt, blijft de toepassing dit eindpunt maximaal 20 keer gebruiken. Na 20 keer stelt de toepassing de LocationMode weer in op PrimaryThenSecondary en wordt het primaire eindpunt weer geprobeerd. Als een aanvraag is geslaagd, blijft de toepassing van het primaire eindpunt lezen.
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;
}
}
}
Grote hoeveelheden willekeurige gegevens uploaden naar Azure Storage
Het minimum- en maximum aantal threads is ingesteld op 100 om ervoor te zorgen dat een groot aantal gelijktijdige verbindingen is toegestaan.
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);
}
}
Naast het instellen van de limietinstellingen voor threads en verbindingen zijn de BlobRequestOptions voor de methode UploadFromStreamAsync geconfigureerd om gebruik te maken van parallelle uitvoering en om validatie van de MD5-hash uit te schakelen. De bestanden worden geüpload in blokken van 100 MB. Deze configuratie biedt betere prestaties maar kan duur zijn als er een slecht presterend netwerk wordt gebruikt, omdat, wanneer er zich een storing voordoet, het gehele blok van 100 MB opnieuw wordt geüpload.
| Eigenschap | Waarde | Beschrijving |
|---|---|---|
| ParallelOperationThreadCount | 8 | Met deze instelling wordt de blob in blokken opgesplitst bij het uploaden. Voor de beste prestaties moet deze waarde acht keer het aantal kerngeheugens zijn. |
| DisableContentMD5Validation | true | Met deze eigenschap wordt de controle uitgeschakeld van de MD5-hash van de inhoud die wordt geüpload. MD5-validatie zorgt voor een snellere overdracht. Maar hiermee wordt de geldigheid of de integriteit van de bestanden die worden overgebracht, niet bevestigd. |
| StoreBlobContentMD5 | false | Deze eigenschap bepaalt of een MD5-hash wordt berekend en samen met het bestand opgeslagen. |
| RetryPolicy | Twee seconden uitstel bij maximaal tien nieuwe pogingen | Hiermee bepaalt u het beleid voor het opnieuw proberen van aanvragen. Bij verbindingsfouten wordt opnieuw geprobeerd. In dit voorbeeld is een ExponentialRetry-beleid geconfigureerd met een uitstel van twee seconden en een maximumaantal nieuwe pogingen van 10. Deze instelling is belangrijk als de toepassing de schaalbaarheidsdoelen voor blob-opslag bijna heeft bereikt. Zie Schaalbaarheids- en prestatiedoelen voor blob-opslag voor meer informatie. |
Grote hoeveelheden willekeurige gegevens downloaden uit Azure Storage
De toepassing leest de containers die zich in het opslagaccount bevinden en die zijn opgegeven in de storageconnectionstring. Het doorloopt de blobs 10 tegelijk met behulp van de methode ListBlobsSegmentedAsync in de containers en downloadt deze naar de lokale computer met behulp van de methode DownloadToFileAsync .
In de volgende tabel ziet u de BlobRequestOptions die voor elke blob zijn gedefinieerd terwijl deze wordt gedownload.
| Eigenschap | Waarde | Beschrijving |
|---|---|---|
| DisableContentMD5Validation | true | Met deze eigenschap wordt de controle uitgeschakeld van de MD5-hash van de inhoud die wordt geüpload. MD5-validatie zorgt voor een snellere overdracht. Maar hiermee wordt de geldigheid of de integriteit van de bestanden die worden overgebracht, niet bevestigd. |
| StoreBlobContentMD5 | false | Deze eigenschap bepaalt of een MD5-hash wordt berekend en opgeslagen. |
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 Opslaganalyse-logboeken inschakelen (klassiek)
Codevoorbeeld:
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);
Retentieperiode voor logboekgegevens wijzigen
In het volgende voorbeeld wordt de retentieperiode voor blob- en wachtrijopslagservices naar de console afgedrukt.
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());
In het volgende voorbeeld wordt de bewaarperiode voor logboeken voor de blob- en wachtrijopslagservices gewijzigd in 4 dagen.
blobserviceProperties.Logging.RetentionDays = 4;
queueserviceProperties.Logging.RetentionDays = 4;
blobClient.SetServiceProperties(blobserviceProperties);
queueClient.SetServiceProperties(queueserviceProperties);
Metrische gegevens van Azure Opslaganalyse inschakelen (klassiek)
Codevoorbeeld:
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);
Transport Layer Security (TLS) configureren voor een clienttoepassing
In het volgende voorbeeld ziet u hoe u TLS 1.2 inschakelt in een .NET-client met behulp van versie 11.x van de Azure Storage-clientbibliotheek:
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();
}
Bewaken, vaststellen en problemen met Microsoft Azure Storage oplossen (klassiek)
Als de Storage-clientbibliotheek een StorageException in de client genereert, bevat de eigenschap RequestInformation een RequestResult-object dat de eigenschap ServiceRequestID bevat. U kunt ook toegang krijgen tot een RequestResult-object vanuit een OperationContext-exemplaar .
In het onderstaande codevoorbeeld ziet u hoe u een aangepaste ClientRequestId-waarde instelt door een OperationContext-object te koppelen aan de opslagservice. U ziet ook hoe u de waarde ServerRequestId ophaalt uit het antwoordbericht.
//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);
}
}
Prestatieproblemen van de client onderzoeken : het Nagle-algoritme uitschakelen
Codevoorbeeld:
var storageAccount = CloudStorageAccount.Parse(connStr);
ServicePoint queueServicePoint = ServicePointManager.FindServicePoint(storageAccount.QueueEndpoint);
queueServicePoint.UseNagleAlgorithm = false;
Problemen met netwerklatentie onderzoeken - CORS (Cross Origin Resource Sharing) configureren
Codevoorbeeld:
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);
Een lege pagina-blob van een opgegeven grootte maken
Als u een pagina-blob wilt maken, maakt u eerst een CloudBlobClient-object , met de basis-URI voor toegang tot de blobopslag voor uw opslagaccount (pbaccount in afbeelding 1), samen met het object StorageCredentialsAccountAndKey , zoals wordt weergegeven in het volgende voorbeeld. In het voorbeeld ziet u vervolgens het maken van een verwijzing naar een CloudBlobContainer-object en vervolgens het maken van de container (testvhds) als deze nog niet bestaat. Maak vervolgens met behulp van het object CloudBlobContainer een verwijzing naar een CloudPageBlob-object door de pagina-blobnaam (os4.vhd) op te geven die toegankelijk is. Als u de pagina-blob wilt maken, roept u CloudPageBlob.Creatie aan en geeft u de maximale grootte door voor de blob die moet worden gemaakt. De blobSize moet een veelvoud van 512 bytes zijn.
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);
Het formaat van een pagina-blob wijzigen
Als u het formaat van een pagina-blob wilt wijzigen na het maken, gebruikt u de methode Formaat wijzigen . De aangevraagde grootte moet een veelvoud van 512 bytes zijn.
pageBlob.Resize(32 * OneGigabyteAsBytes);
Pagina's naar een pagina-blob schrijven
Als u pagina's wilt schrijven, gebruikt u de methode CloudPageBlob.WritePages .
pageBlob.WritePages(dataStream, startingOffset);
Pagina's lezen van een pagina-blob
Als u pagina's wilt lezen, gebruikt u de methode CloudPageBlob.DownloadRangeToByteArray om een bereik van bytes uit de pagina-blob te lezen.
byte[] buffer = new byte[rangeSize];
pageBlob.DownloadRangeToByteArray(buffer, bufferOffset, pageBlobOffset, rangeSize);
Gebruik CloudPageBlob.GetPageRanges om te bepalen welke pagina's door gegevens worden ondersteund. Vervolgens kunt u de geretourneerde bereiken opsommen en de gegevens in elk bereik downloaden.
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
}