Compartilhar via

Listar blobs com .NET

  • Artigo

Esse artigo mostra como listar blobs usando a biblioteca de clientes do Armazenamento do Azure para .NET.

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 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 adicionais using.

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ê também pode registrar um cliente de serviço para injeção de dependência em um aplicativo .NET. 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 deve ter as permissões necessárias para listar blobs. Para autorização com o Microsoft Entra ID (recomendado), você precisa da função interna do RBAC do Azure Leitor de Dados de Blob de Armazenamento ou superior. Para saber mais, consulte as diretrizes de autorização para Listar Blobs (REST API).

Sobre as opções de listagem de blobs

Ao listar blobs do seu código, você pode especificar várias opções para gerenciar o modo como os resultados são retornados do Armazenamento do Azure. Você pode especificar o número de resultados a serem retornados em cada conjunto de resultados e, em seguida, recuperar os conjuntos subsequentes. Você pode especificar um prefixo para retornar os blobs cujos nomes começam com esse caractere ou cadeia de caracteres. Além disso, você pode listar os blobs em uma estrutura de listagem plana ou hierarquicamente. Uma listagem hierárquica retorna blobs como se eles estivessem organizados em pastas.

Para listar os blobs em uma conta de armazenamento, chame um destes métodos:

Gerenciar quantos resultados são retornados

Por padrão, uma operação de listagem retorna até 5.000 resultados por vez, mas você pode especificar o número de resultados que deseja que cada operação de listagem retorne. Os exemplos apresentados neste artigo mostram como retornar resultados em páginas. Para saber mais sobre os conceitos de paginação, confira Paginação com o SDK do Azure para NET.

Filtrar resultados com um prefixo

Para filtrar a lista de blobs, especifique uma cadeia de caracteres para o parâmetro prefix. A cadeia de caracteres de prefixo pode incluir um ou mais caracteres. O Armazenamento do Azure então retorna somente os blobs cujos nomes começam com esse prefixo.

Retornar metadados

Você pode retornar os metadados de blob com os resultados especificando o valor de Metadados para a enumeração BlobTraits.

Listagem plana versus listagem hierárquica

Os blobs no Armazenamento do Azure são organizados em um paradigma simples em vez de um paradigma hierárquico (como um sistema de arquivos clássico). No entanto, você pode organizar blobs em diretórios virtuais para imitar uma estrutura de pastas. Um diretório virtual faz parte do nome do blob e é indicado pelo caractere delimitador.

Para organizar blobs em diretórios virtuais, use um caractere delimitador no nome do blob. O caractere delimitador padrão é uma barra (/), mas você pode especificar qualquer caractere como o delimitador.

Se você nomear seus blobs usando um delimitador, poderá optar por listar os blobs hierarquicamente. Para uma operação de listagem hierárquica, o Armazenamento do Azure retornará os diretórios virtuais e blobs que estiverem abaixo do objeto pai. Você pode chamar a operação de listagem recursivamente para percorrer a hierarquia, semelhante ao modo como você percorreria um sistema de arquivos clássico programaticamente.

Usar uma listagem plana

Por padrão, uma operação de listagem retorna blobs em uma listagem plana. Em uma listagem plana, os blobs não são organizados por diretório virtual.

O exemplo a seguir lista os blobs no contêiner especificado usando uma listagem plana, com um tamanho de segmento opcional especificado, e grava o nome do blob em uma janela de console.

private static async Task ListBlobsFlatListing(BlobContainerClient blobContainerClient, 
                                               int? segmentSize)
{
    try
    {
        // Call the listing operation and return pages of the specified size.
        var resultSegment = blobContainerClient.GetBlobsAsync()
            .AsPages(default, segmentSize);

        // Enumerate the blobs returned for each page.
        await foreach (Page<BlobItem> blobPage in resultSegment)
        {
            foreach (BlobItem blobItem in blobPage.Values)
            {
                Console.WriteLine("Blob name: {0}", blobItem.Name);
            }

            Console.WriteLine();
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

A saída de exemplo deverá ser semelhante a:

Blob name: FolderA/blob1.txt
Blob name: FolderA/blob2.txt
Blob name: FolderA/blob3.txt
Blob name: FolderA/FolderB/blob1.txt
Blob name: FolderA/FolderB/blob2.txt
Blob name: FolderA/FolderB/blob3.txt
Blob name: FolderA/FolderB/FolderC/blob1.txt
Blob name: FolderA/FolderB/FolderC/blob2.txt
Blob name: FolderA/FolderB/FolderC/blob3.txt

Observação

A saída de exemplo mostrada pressupõe que você tenha uma conta de armazenamento com um namespace simples. Se você habilitou o recurso de namespace hierárquico em sua conta de armazenamento, os diretórios não são virtuais. Em vez disso, eles são objetos concretos e independentes. Como resultado, os diretórios aparecem na lista como blobs de comprimento zero.

Para obter uma opção de listagem alternativa ao trabalhar com um namespace hierárquico, confira Listar conteúdo de diretório (Azure Data Lake Storage Gen2).

Usar uma listagem hierárquica

Quando você chama uma operação de listagem hierarquicamente, o Armazenamento do Azure retorna os diretórios virtuais e os blobs no primeiro nível da hierarquia.

Para listar os blobs hierarquicamente, chame o método BlobContainerClient.GetBlobsByHierarchy ou BlobContainerClient.GetBlobsByHierarchyAsync.

O exemplo a seguir lista os blobs no contêiner especificado usando uma listagem hierárquica, com um tamanho de segmento opcional especificado, e grava o nome do blob na janela do console.

private static async Task ListBlobsHierarchicalListing(BlobContainerClient container, 
                                                       string prefix, 
                                                       int? segmentSize)
{
    try
    {
        // Call the listing operation and return pages of the specified size.
        var resultSegment = container.GetBlobsByHierarchyAsync(prefix:prefix, delimiter:"/")
            .AsPages(default, segmentSize);

        // Enumerate the blobs returned for each page.
        await foreach (Page<BlobHierarchyItem> blobPage in resultSegment)
        {
            // A hierarchical listing may return both virtual directories and blobs.
            foreach (BlobHierarchyItem blobhierarchyItem in blobPage.Values)
            {
                if (blobhierarchyItem.IsPrefix)
                {
                    // Write out the prefix of the virtual directory.
                    Console.WriteLine("Virtual directory prefix: {0}", blobhierarchyItem.Prefix);

                    // Call recursively with the prefix to traverse the virtual directory.
                    await ListBlobsHierarchicalListing(container, blobhierarchyItem.Prefix, null);
                }
                else
                {
                    // Write out the name of the blob.
                    Console.WriteLine("Blob name: {0}", blobhierarchyItem.Blob.Name);
                }
            }

            Console.WriteLine();
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

A saída de exemplo deverá ser semelhante a:

Virtual directory prefix: FolderA/
Blob name: FolderA/blob1.txt
Blob name: FolderA/blob2.txt
Blob name: FolderA/blob3.txt

Virtual directory prefix: FolderA/FolderB/
Blob name: FolderA/FolderB/blob1.txt
Blob name: FolderA/FolderB/blob2.txt
Blob name: FolderA/FolderB/blob3.txt

Virtual directory prefix: FolderA/FolderB/FolderC/
Blob name: FolderA/FolderB/FolderC/blob1.txt
Blob name: FolderA/FolderB/FolderC/blob2.txt
Blob name: FolderA/FolderB/FolderC/blob3.txt

Observação

Os instantâneos de blob não podem ser listados em uma operação de listagem hierárquica.

Listar versões ou instantâneos de blob

Para listar versões ou instantâneos de blob, especifique o parâmetro BlobStates com o campo Versão ou Instantâneo. Versões e instantâneos são listados do mais antigo para o mais recente.

O exemplo de código a seguir mostra como listar versões de blob.

private static void ListBlobVersions(BlobContainerClient blobContainerClient, 
                                           string blobName)
{
    try
    {
        // Call the listing operation, specifying that blob versions are returned.
        // Use the blob name as the prefix. 
        var blobVersions = blobContainerClient.GetBlobs
            (BlobTraits.None, BlobStates.Version, prefix: blobName)
            .OrderByDescending(version => version.VersionId).Where(blob => blob.Name == blobName);

        // Construct the URI for each blob version.
        foreach (var version in blobVersions)
        {
            BlobUriBuilder blobUriBuilder = new BlobUriBuilder(blobContainerClient.Uri)
            {
                BlobName = version.Name,
                VersionId = version.VersionId
            };

            if ((bool)version.IsLatestVersion.GetValueOrDefault())
            {
                Console.WriteLine("Current version: {0}", blobUriBuilder);
            }
            else
            {
                Console.WriteLine("Previous version: {0}", blobUriBuilder);
            }
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Recursos

Para saber mais sobre como listar 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 se baseiam na 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 listar blobs usam a seguinte operação de API REST:

Recursos da biblioteca de clientes

Confira também