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

Configure seu ambiente

Se você não tiver um projeto existente, esta seção mostrará como configurar um projeto para funcionar com a biblioteca de clientes do Armazenamento de Blobs do Azure para .NET. As etapas incluem a instalação do pacote, a adição de diretivas using e a criação de um objeto de cliente autorizado. Para obter detalhes, consulte Introdução ao Armazenamento de Blobs do Azure e ao .NET.

Instalar Pacotes

No diretório do projeto, instale pacotes para as bibliotecas de cliente do Armazenamento de Blobs do Azure e do Azure Identity usando o comando dotnet add package. O pacote Azure.Identity é necessário para conexões sem senha com os serviços do Azure.

dotnet add package Azure.Storage.Blobs
dotnet add package Azure.Identity

Adicione diretivas using

Adicione essas diretivas using ao topo do seu arquivo de código:

using Azure.Identity;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Blobs.Specialized;

Alguns exemplos de código neste artigo podem exigir diretivas using adicionais.

Criar um objeto cliente

Para conectar um aplicativo ao Armazenamento de Blobs, crie uma instância do BlobServiceClient. O exemplo a seguir mostra como criar um objeto cliente usando DefaultAzureCredential para autorização:

public BlobServiceClient GetBlobServiceClient(string accountName)
{
    BlobServiceClient client = new(
        new Uri($"https://{accountName}.blob.core.windows.net"),
        new DefaultAzureCredential());

    return client;
}

Você pode registrar um cliente de serviço para injeção de dependência em um aplicativo .NET.

Você também pode criar objetos cliente para contêineres ou blobs específicos. Para saber mais sobre como criar e gerenciar objetos clientes, confira Criar e gerenciar objetos clientes que interagem com recursos de dados.

Autorização

O mecanismo de autorização precisa ter as permissões necessárias para carregar um blob. Para autorização com o Microsoft Entra ID (recomendado), você precisa da função interna de Colaborador de Dados de Blob de Armazenamento ou superior do RBAC do Azure. Para saber mais, consulte as diretrizes de autorização para Put Blob (REST API) e Put Block (REST API).

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.

Exemplos de código

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:

Confira também

Conteúdo relacionado

  • Este artigo faz parte do guia para desenvolvedores do Armazenamento de Blobs para .NET. Para saber mais, veja a lista completa de artigos do guia do desenvolvedor em Criar seu aplicativo .NET.