Partilhar via

Carregar um blob com .NET

  • Artigo

Este artigo mostra como carregar um blob usando a biblioteca de cliente do Armazenamento do Azure para .NET. Você pode carregar dados para um blob de bloco a partir 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 blob e gravar nele, ou carregar 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 pacotes, adicionar using diretivas e criar um objeto de cliente autorizado, consulte Introdução ao Armazenamento de Blobs do Azure e ao .NET.
  • O mecanismo de autorização deve ter permissões para executar uma operação de carregamento. Para saber mais, consulte as diretrizes de autorização para as seguintes operações de API REST:

Carregar dados para um blob de bloco

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

Ao usar esses métodos de upload, a biblioteca de cliente pode chamar Put Blob ou uma série de chamadas Put Block seguidas por Put Block List. Esse comportamento depende do tamanho geral do objeto e 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 bloco a partir de um caminho de arquivo local

O exemplo a seguir carrega um blob de bloco 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 bloco a partir de um fluxo

O exemplo a seguir carrega um blob de bloco criando um objeto Stream e carregando o fluxo.

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

Carregar um blob de bloco de um objeto BinaryData

O exemplo a seguir carrega um blob de bloco 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();
}

Carregar um blob de bloco a partir de uma cadeia de caracteres

O exemplo a seguir carrega um blob de bloco 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);
}

Carregar para 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 Blob Storage e grava arquivos nele. Em vez de construir um arquivo zip na memória local, apenas um arquivo de cada vez está 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 bloco com opções de configuração

Você pode definir opções de configuração da biblioteca do cliente ao carregar um blob. Essas opções podem ser ajustadas para melhorar o desempenho, aumentar 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 carregamento.

Especificar opções de transferência de dados ao carregar

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 incluir as opções como parte de uma BlobUploadOptions instância. Os valores fornecidos neste exemplo não pretendem ser uma recomendação. Para ajustar corretamente 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, consulte Ajuste de desempenho para uploads e downloads com o .NET.

Especificar opções de validação de transferência ao carregar

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 a partir de uma instância 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 BlobUploadOptions objeto e especificar um algoritmo para gerar uma soma de verificação. A soma de verificação é entã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 Description
Automático 0 Recomendado. Permite que a biblioteca escolha um algoritmo. Diferentes versões de bibliotecas podem escolher algoritmos diferentes.
Nenhuma 1 Nenhum algoritmo selecionado. Não calcule nem solicite somas de verificação.
MD5 2 Algoritmo de hash MD5 padrão.
ArmazenamentoCrc64 3 CRC personalizado de 64 bits do Armazenamento do Azure.

Nota

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 carregamento falhará. A operação não é repetida ao usar uma política de repetição padrão. No .NET, um RequestFailedException é lançado com o código de status 400 e código Md5Mismatch de erro ou Crc64Mismatch, dependendo de qual algoritmo é usado.

Carregar com tags de índice

As tags de índice de Blob categorizam os dados em sua conta de armazenamento usando atributos de tag chave-valor. Essas tags são automaticamente indexadas e expostas como um índice multidimensional pesquisável para encontrar dados facilmente. Você pode adicionar tags a uma instância de BlobUploadOptions e passar essa instância para o UploadAsync método.

O exemplo a seguir carrega um blob de bloco com tags 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 ao carregar

Você pode definir a camada de acesso de um blob ao carregar 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 definição da camada de acesso só é permitida para blobs de bloco. Você pode definir a camada de acesso para um blob de bloco como Hot, Cool, Coldou Archive. Para definir a camada de acesso como Cold, você deve usar uma versão mínima da biblioteca de cliente 12.15.0.

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

Carregue um blob de bloco preparando blocos e confirmando

Você pode ter maior controle sobre como dividir os uploads em blocos preparando manualmente blocos individuais de dados. Quando todos os blocos que compõem um blob são preparados, você pode confirmá-los no Armazenamento de Blobs. Você pode usar essa abordagem para melhorar o desempenho carregando 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 cliente 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 se baseiam na API REST do Azure, permitindo que você interaja com operações da API REST por meio de paradigmas .NET familiares. Os métodos da biblioteca de cliente para carregar blobs usam as seguintes operações de API REST:

Amostras de código

Consulte também