Listar blobs com Python

Este artigo mostra como listar blobs usando a biblioteca cliente Armazenamento do Azure para Python.

Para aprender como listar blobs usando APIs assíncronas, consulte Listar blobs de forma assíncrona.

Pré-requisitos

• Assinatura do Azure - criar uma gratuitamente
• Conta de armazenamento do Azure – criar uma conta de armazenamento
• Python 3.8+

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 Python. Para obter mais detalhes, confira Introdução ao Armazenamento de Blobs do Azure e ao Python.

Para trabalhar com os exemplos de código neste artigo, siga estas etapas para configurar seu projeto.

Instalar Pacotes

Instale os seguintes pacotes por meio de pip install:

pip install azure-storage-blob azure-identity

Adicionar instruções de importação

Adicione as seguintes import instruções:

from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient, ContainerClient, BlobPrefix

Autorização

O mecanismo de autorização deve ter as permissões necessárias para listar um blob. Para se autorizar com o Microsoft Entra ID (recomendado), você precisa da função interna do Azure RBAC Storage Blob Data Reader ou superior. Para saber mais, consulte as diretrizes de autorização para Listar Blobs (REST API).

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:

# TODO: Replace <storage-account-name> with your actual storage account name
account_url = "https://<storage-account-name>.blob.core.windows.net"
credential = DefaultAzureCredential()

# Create the BlobServiceClient object
blob_service_client = BlobServiceClient(account_url, credential=credential)

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

Sobre as opções de listagem de blobs

Quando você lista blobs do seu código, pode especificar várias opções para gerenciar como os resultados retornam 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. Você pode listar 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 um contêiner usando uma listagem plana, chame um destes métodos:

• ContainerClient.list_blobs (junto com o nome, opcionalmente inclui metadados, tags e outras informações associadas a cada blob)
• ContainerClient.list_blob_names (retorna apenas o nome do blob)

Para listar os blobs em um contêiner usando uma listagem hierárquica, chame o seguinte método:

• ContainerClient.walk_blobs (junto com o nome, opcionalmente inclui metadados, tags e outras informações associadas a cada blob)

Filtrar resultados com um prefixo

Para filtrar a lista de blobs, especifique uma cadeia de caracteres para o argumento da palavra-chave name_starts_with. A cadeia de caracteres de prefixo pode incluir um ou mais caracteres. Armazenamento do Azure retorna apenas os blobs cujos nomes começam com esse prefixo.

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 a estrutura de uma pasta. 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ê nomeia seus blobs usando um delimitador, pode escolher 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:

def list_blobs_flat(self, blob_service_client: BlobServiceClient, container_name):
    container_client = blob_service_client.get_container_client(container=container_name)

    blob_list = container_client.list_blobs()

    for blob in blob_list:
        print(f"Name: {blob.name}")

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

List blobs flat:
Name: file4.txt
Name: folderA/file1.txt
Name: folderA/file2.txt
Name: folderA/folderB/file3.txt

Você também pode especificar opções para filtrar resultados da lista ou mostrar mais informações. O exemplo seguinte lista blobs e tags de blob:

def list_blobs_flat_options(self, blob_service_client: BlobServiceClient, container_name):
    container_client = blob_service_client.get_container_client(container=container_name)

    blob_list = container_client.list_blobs(include=['tags'])

    for blob in blob_list:
        print(f"Name: {blob['name']}, Tags: {blob['tags']}")

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

List blobs flat:
Name: file4.txt, Tags: None
Name: folderA/file1.txt, Tags: None
Name: folderA/file2.txt, Tags: None
Name: folderA/folderB/file3.txt, Tags: {'tag1': 'value1', 'tag2': 'value2'}

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 blobs hierarquicamente, use o seguinte método:

• ContainerClient.walk_blobs

O seguinte exemplo lista os blobs no contêiner especificado usando uma listagem hierárquica:

depth = 0
indent = "  "
def list_blobs_hierarchical(self, container_client: ContainerClient, prefix):
    for blob in container_client.walk_blobs(name_starts_with=prefix, delimiter='/'):
        if isinstance(blob, BlobPrefix):
            # Indentation is only added to show nesting in the output
            print(f"{self.indent * self.depth}{blob.name}")
            self.depth += 1
            self.list_blobs_hierarchical(container_client, prefix=blob.name)
            self.depth -= 1
        else:
            print(f"{self.indent * self.depth}{blob.name}")

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

folderA/
  folderA/folderB/
    folderA/folderB/file3.txt
  folderA/file1.txt
  folderA/file2.txt
file4.txt

Listar blobs de forma assíncrona

A biblioteca cliente do Armazenamento de Blobs do Azure para Python é compatível com a listagem de blobs de forma assíncrona. Para saber mais sobre os requisitos de instalação do projeto, confira Programação assíncrona.

Siga estes passos para listar blobs usando APIs assíncronas:

1. Adicione as seguintes instruções de importação:

   import asyncio
   
   from azure.identity.aio import DefaultAzureCredential
   from azure.storage.blob.aio import BlobServiceClient, ContainerClient, BlobPrefix
   

2. Adicione código para rodar o programa usando asyncio.run. Essa função executa a corrotina passada, main(), neste exemplo, e gerencia o ciclo de eventos asyncio. Corrotinas são declaradas usando a sintaxe async/await. Neste exemplo, a corrotina main() primeiro cria o BlobServiceClient de nível superior usando async with e depois chama o método que lista os blobs. Somente o cliente de nível superior precisa usar async with, pois os outros clientes criados a partir dele compartilham o mesmo pool de conexões.

   async def main():
       sample = BlobSamples()
   
       # TODO: Replace <storage-account-name> with your actual storage account name
       account_url = "https://<storage-account-name>.blob.core.windows.net"
       credential = DefaultAzureCredential()
   
       async with BlobServiceClient(account_url, credential=credential) as blob_service_client:
           await sample.list_blobs_flat(blob_service_client, "sample-container")
   
   if __name__ == '__main__':
       asyncio.run(main())
   

3. Adicione código para listar os blobs. O exemplo de código a seguir lista blobs usando uma listagem plana. O código é o mesmo do exemplo síncrono, exceto que o método é declarado usando a async palavra-chave e async for é usado ao chamar o list_blobs método.

   async def list_blobs_flat(self, blob_service_client: BlobServiceClient, container_name):
       container_client = blob_service_client.get_container_client(container=container_name)
   
       async for blob in container_client.list_blobs():
           print(f"Name: {blob.name}")
   

Com essa configuração básica definida, você pode implementar outros exemplos deste artigo na forma de corrotinas usando a sintaxe async/await.

Listar blobs no formato Apache Arrow (versão prévia)

Essa funcionalidade é construída sobre a API existente List Blobs . Em vez de usar o XML padrão, usa o formato compacto e colunar Apache Arrow como formato de resposta na transmissão. Você habilita isso definindo uma única opção na chamada de listagem de contêineres. O SDK do Python decodifica o Apache Arrow em segundo plano e ainda retorna os mesmos objetos BlobProperties. Essa abordagem melhora a taxa de transferência da listagem e reduz o uso de CPU no cliente ao enumerar contêineres grandes. Ela preserva o contrato de resposta do qual as aplicações dependem.

Para solicitar resultados no formato Apache Arrow, defina o response_format argumento da palavra-chave para "arrow" quando você chama ContainerClient.list_blobs ou ContainerClient.list_blob_names. Ao usar a saída do Apache Arrow, você também pode definir os argumentos nomeados start_from e end_before para controlar o intervalo de caminhos retornados.

O exemplo a seguir lista os blobs em um contêiner e solicita os resultados no formato Apache Arrow:

# response_format="arrow" requires the nanoarrow package to be installed
blob_list = container_client.list_blobs(
    name_starts_with="folderA/",
    response_format="arrow",
)

for blob in blob_list:
    print("Name: " + blob.name)

Recursos

Para saber mais sobre como listar blobs usando a biblioteca cliente Armazenamento de Blobs do Azure para Python, veja os seguintes recursos.

Exemplos de código

• Veja exemplos de código síncrono ou assíncrono deste artigo (GitHub).

Operações da API REST

O SDK do Azure para Python contém bibliotecas que se baseiam na API REST do Azure. Ao usar essas bibliotecas, você pode interagir com operações da API REST por meio de paradigmas Python familiares. Os métodos da biblioteca de clientes para listar blobs usam a seguinte operação de API REST:

• Listar Blobs (REST API)

Recursos da biblioteca de clientes

• Documentação de referência da biblioteca cliente
• Código-fonte da biblioteca de clientes
• Pacote (PyPi)

Confira também

• Listando recursos de Blob
• Controle de versão de blobs

Conteúdo relacionado

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