Share via

Carregar um blob com .NET

  • Artigo

Este artigo mostra como carregar um blob usando a biblioteca do cliente do Armazenamento do Microsoft Azure para .NET. Você pode carregar dados em um blob de blocos de um caminho de arquivo, um fluxo, um objeto binário ou uma cadeia de caracteres de texto. Você também pode abrir um fluxo de blobs e gravar nele ou fazer upload de blobs grandes em blocos.

Pré-requisitos

  • Este artigo pressupõe que você já tenha um projeto configurado para trabalhar com a biblioteca de cliente do Armazenamento de Blobs do Azure para .NET. Para saber mais sobre como configurar seu projeto, incluindo a instalação de pacote, a adição de diretivas using e a criação de um objeto do cliente autorizado, consulte Introdução ao Armazenamento de Blobs do Azure e .NET.
  • O mecanismo de autorização deve ter permissões para executar uma operação de upload. Para saber mais, confira as diretrizes de autorização para as seguintes operações de API REST:

Carregar dados em um blob de blocos

Você pode usar um dos seguintes métodos para carregar dados em um blob de blocos:

Ao usar esses métodos de upload, a biblioteca de clientes pode chamar o Put Blob ou uma série de chamadas Put Block seguidas pela Put Block List. Esse comportamento depende do tamanho geral do objeto e de como as opções de transferência de dados são definidas.

Para abrir um fluxo no Armazenamento de Blobs e gravar nesse fluxo, use um dos seguintes métodos:

Carregar um blob de blocos de um caminho de arquivo local

O exemplo a seguir carrega um blob de blocos de um caminho de arquivo local:

public static async Task UploadFromFileAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    await blobClient.UploadAsync(localFilePath, true);
}

Carregar um blob de blocos de um fluxo

O exemplo a seguir carrega um blob de blocos criando um objeto Stream e carregando o stream.

public static async Task UploadFromStreamAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, true);
    fileStream.Close();
}

Fazer o upload de um blob de blocos a partir de um objeto BinaryData

O exemplo a seguir carrega um blob de blocos de um objeto BinaryData .

public static async Task UploadFromBinaryDataAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    BinaryReader reader = new BinaryReader(fileStream);

    byte[] buffer = new byte[fileStream.Length];
    reader.Read(buffer, 0, buffer.Length);
    BinaryData binaryData = new BinaryData(buffer);

    await blobClient.UploadAsync(binaryData, true);

    fileStream.Close();
}

Fazer upload um blob de blocos a partir de uma cadeia de caracteres

O seguinte exemplo carrega um blob de blocos de uma cadeia de caracteres:

public static async Task UploadFromStringAsync(
    BlobContainerClient containerClient,
    string blobName)
{
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    string blobContents = "Sample blob data";

    await blobClient.UploadAsync(BinaryData.FromString(blobContents), overwrite: true);
}

Upload em um fluxo no Armazenamento de Blobs

Você pode abrir um fluxo no Armazenamento de Blobs e gravar nele. O exemplo a seguir cria um arquivo zip no Armazenamento de Blobs do Azure e grava arquivos nele. Em vez de criar um arquivo zip na memória local, apenas um arquivo de cada vez fica na memória.

public static async Task UploadToStreamAsync(
    BlobContainerClient containerClient,
    string localDirectoryPath)
{
    string zipFileName = Path.GetFileName(
        Path.GetDirectoryName(localDirectoryPath)) + ".zip";

    BlockBlobClient blockBlobClient = containerClient.GetBlockBlobClient(zipFileName);

    using (Stream stream = await blockBlobClient.OpenWriteAsync(true))
    {
        using (ZipArchive zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: false))
        {
            foreach (var fileName in Directory.EnumerateFiles(localDirectoryPath))
            {
                using (var fileStream = File.OpenRead(fileName))
                {
                    var entry = zip.CreateEntry(
                        Path.GetFileName(fileName), CompressionLevel.Optimal);
                    using (var innerFile = entry.Open())
                    {
                        await fileStream.CopyToAsync(innerFile);
                    }
                }
            }
        }
    }
}

Carregar um blob de blocos com opções de configuração

Você pode definir opções de configuração da biblioteca de clientes ao carregar um blob. Essas opções podem ser ajustadas para melhorar o desempenho, melhorar a confiabilidade e otimizar os custos. Os exemplos de código a seguir mostram como usar BlobUploadOptions para definir opções de configuração ao chamar um método de upload.

Especificar opções de transferência de dados durante o upload

Você pode configurar os valores em StorageTransferOptions para melhorar o desempenho das operações de transferência de dados. O exemplo de código a seguir mostra como definir valores para StorageTransferOptions e inclui as opções como parte de uma instância BlobUploadOptions. Os valores fornecidos neste exemplo não se destinam a ser uma recomendação. Para ajustar adequadamente esses valores, você precisa considerar as necessidades específicas do seu aplicativo.

public static async Task UploadWithTransferOptionsAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    var transferOptions = new StorageTransferOptions
    {
        // Set the maximum number of parallel transfer workers
        MaximumConcurrency = 2,

        // Set the initial transfer length to 8 MiB
        InitialTransferSize = 8 * 1024 * 1024,

        // Set the maximum length of a transfer to 4 MiB
        MaximumTransferSize = 4 * 1024 * 1024
    };

    var uploadOptions = new BlobUploadOptions()
    {
        TransferOptions = transferOptions
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

Para saber mais sobre como ajustar as opções de transferência de dados, confira Ajuste de desempenho para uploads e downloads com o .NET.

Especificar opções de validação de transferência durante o upload

Você pode especificar opções de validação de transferência para ajudar a garantir que os dados sejam carregados corretamente e não tenham sido adulterados durante o trânsito. As opções de validação de transferência podem ser definidas no nível do cliente usando BlobClientOptions, que aplica opções de validação a todos os métodos chamados de uma instância de BlobClient.

Você também pode substituir as opções de validação de transferência no nível do método usando BlobUploadOptions. O exemplo de código a seguir mostra como criar um objeto BlobUploadOptions e especificar um algoritmo para gerar uma soma de verificação. Em seguida, a soma de verificação é usada pelo serviço para verificar a integridade dos dados do conteúdo carregado.

public static async Task UploadWithChecksumAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    var validationOptions = new UploadTransferValidationOptions
    {
        ChecksumAlgorithm = StorageChecksumAlgorithm.Auto
    };

    var uploadOptions = new BlobUploadOptions()
    {
        TransferValidation = validationOptions
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

A tabela a seguir mostra as opções disponíveis para o algoritmo de soma de verificação, conforme definido por StorageChecksumAlgorithm:

Nome Valor Descrição
Auto 0 Recomendável. Permite que a biblioteca escolha um algoritmo. Versões de biblioteca diferentes podem escolher algoritmos diferentes.
Nenhum 1 Nenhum algoritmo selecionado. Não calcule nem solicite somas de verificação.
MD5 2 Algoritmo de hash MD5 padrão.
StorageCrc64 3 CRC de 64 bits personalizado do Armazenamento do Microsoft Azure.

Observação

Se a soma de verificação especificada na solicitação não corresponder à soma de verificação calculada pelo serviço, a operação de upload falhará. A operação não é repetida quando se usa uma política de repetição padrão. No .NET, um RequestFailedException é lançado com o código de status 400 e código de erro Md5Mismatch ou Crc64Mismatch, dependendo do algoritmo usado.

Carregar com marcas de índice

As marcas de índice de blob categorizam os dados na sua conta de armazenamento usando atributos de marca de chave-valor. Essas marcas são indexadas automaticamente e expostas como um índice multidimensional pesquisável para localizar dados com facilidade. Você pode adicionar marcas a uma instância de BlobUploadOptions, e passar essa instância para o método UploadAsync.

O seguinte exemplo carrega um blob de blocos com marcas de índice:

public static async Task UploadBlobWithTagsAsync(
    BlobContainerClient containerClient,
    string blobName)
{
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    string blobContents = "Sample blob data";

    BlobUploadOptions options = new BlobUploadOptions();
    options.Tags = new Dictionary<string, string>
    {
        { "Sealed", "false" },
        { "Content", "image" },
        { "Date", "2020-04-20" }
    };

    await blobClient.UploadAsync(BinaryData.FromString(blobContents), options);
}

Definir a camada de acesso de um blob durante o upload

Você pode definir a camada de acesso de um blob durante o upload usando a classe BlobUploadOptions. O exemplo de código a seguir mostra como definir a camada de acesso ao carregar um blob:

public static async Task UploadWithAccessTierAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlockBlobClient blockBlobClient = containerClient.GetBlockBlobClient(fileName);

    var uploadOptions = new BlobUploadOptions()
    {
        AccessTier = AccessTier.Cool
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blockBlobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

A configuração da camada de acesso somente é permitida para blobs de blocos. Você pode definir a camada de acesso para um blob de blocos como Hot, Cool, Cold ou Archive. Para definir a camada de acesso como Cold, você deve usar no mínimo a versão 12.15.0 da biblioteca de clientes.

Para saber mais sobre as camadas de acesso, confira Visão geral das camadas de acesso.

Faça upload de um blob de blocos preparando os blocos e confirmando

Você pode ter maior controle sobre como dividir os uploads em blocos organizando manualmente os blocos individuais de dados. Quando todos os blocos que formam um blob estiverem preparados, você poderá fazer commit deles no Armazenamento de Blobs. Você pode usar essa abordagem para melhorar o desempenho fazendo upload de blocos em paralelo.

public static async Task UploadBlocksAsync(
    BlobContainerClient blobContainerClient,
    string localFilePath,
    int blockSize)
{
    string fileName = Path.GetFileName(localFilePath);
    BlockBlobClient blobClient = blobContainerClient.GetBlockBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    ArrayList blockIDArrayList = new ArrayList();
    byte[] buffer;

    var bytesLeft = (fileStream.Length - fileStream.Position);

    while (bytesLeft > 0)
    {
        if (bytesLeft >= blockSize)
        {
            buffer = new byte[blockSize];
            await fileStream.ReadAsync(buffer, 0, blockSize);
        }
        else
        {
            buffer = new byte[bytesLeft];
            await fileStream.ReadAsync(buffer, 0, Convert.ToInt32(bytesLeft));
            bytesLeft = (fileStream.Length - fileStream.Position);
        }

        using (var stream = new MemoryStream(buffer))
        {
            string blockID = Convert.ToBase64String(
                Encoding.UTF8.GetBytes(Guid.NewGuid().ToString()));

            blockIDArrayList.Add(blockID);
            await blobClient.StageBlockAsync(blockID, stream);
        }
        bytesLeft = (fileStream.Length - fileStream.Position);
    }

    string[] blockIDArray = (string[])blockIDArrayList.ToArray(typeof(string));

    await blobClient.CommitBlockListAsync(blockIDArray);
}

Recursos

Para saber mais sobre como carregar blobs usando a biblioteca de clientes do Armazenamento de Blobs do Azure para .NET, consulte os recursos a seguir.

Operações da API REST

O SDK do Azure para .NET contém bibliotecas que criam sobre a API REST do Azure, permitindo a interação com as operações de API REST por meio de paradigmas conhecidos do .NET. Os métodos da biblioteca de clientes para carregar blobs usam as seguintes operações da API REST:

Exemplos de código

Confira também