Enumeración de blobs con Python

  • Artículo

En este artículo se muestra cómo enumerar blobs con la biblioteca cliente de Azure Storage para .NET.

Para obtener más información sobre cómo enumerar blobs mediante las API asincrónicas, consulte Enumerar blobs de forma asincrónica.

Requisitos previos

  • En este artículo se supone que ya tiene un proyecto configurado para trabajar con la biblioteca cliente de Azure Blob Storage para Python. Para obtener información sobre cómo configurar el proyecto, incluida la instalación de paquetes, la adición de directivas de import y la autorización de un objeto de cliente, consulte Introducción a Azure Storage y Java.
  • Para usar API asincrónicas en el código, consulte los requisitos de la sección Programación asincrónica.
  • El mecanismo de autorización debe tener permisos para enumerar blobs. Para obtener más información, consulte la guía de autorización para la siguiente operación de la API de REST:

Acerca de las opciones de listado de blobs

Al enumerar blobs desde el código, puede especificar varias opciones para administrar cómo se devuelven los resultados de Azure Storage. Puede especificar el número de resultados que se van a devolver en cada conjunto de resultados y luego recuperar los conjuntos subsiguientes. Puede especificar un prefijo para devolver los blobs cuyos nombres comienzan por ese carácter o cadena. También puede enumerar los blobs en una estructura de lista plana o de forma jerárquica. Una lista jerárquica devuelve los blobs como si estuvieran organizados en carpetas.

Para enumerar los blobs de un contenedor en una lista plana, llame a uno de estos métodos:

Para enumerar los blobs de un contenedor usando una lista jerárquica, llame al siguiente método:

Filtrado de los resultados con un prefijo

Para filtrar la lista de blobs, especifique una cadena para el argumento de palabra clavename_starts_with. La cadena de prefijo puede incluir uno o varios caracteres. Después, Azure Storage solo devuelve los blobs cuyos nombres empiecen por ese prefijo.

Lista plana frente a lista jerárquica

Los blobs de Azure Storage están organizados en un paradigma plano, en lugar de un paradigma jerárquico (como un sistema de archivos clásico). Sin embargo, los blobs se pueden organizar en directorios virtuales para imitar una estructura de carpetas. Un directorio virtual forma parte del nombre del blob y se indica mediante el carácter delimitador.

Para organizar los blobs en directorios virtuales, use un carácter delimitador en el nombre del blob. El carácter delimitador predeterminado es una barra diagonal (/), pero puede especificar cualquier carácter como delimitador.

Si usa un delimitador para asignar nombres a los blobs, puede optar por enumerar los blobs de forma jerárquica. En el caso de una operación de enumeración jerárquica, Azure Storage devuelve los directorios virtuales y los blobs que hay debajo del objeto primario. Puede llamar a la operación de enumeración de forma recursiva para recorrer la jerarquía, de manera similar a como se haría con un sistema de archivos clásico mediante programación.

Uso de una lista plana

De forma predeterminada, una operación de enumeración devuelve los blobs en una lista plana. En una lista plana, los blobs no se organizan por directorio virtual.

En el ejemplo siguiente se enumeran los blobs del contenedor especificado mediante una lista 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}")

La salida es parecida a esta:

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

También puede especificar opciones para filtrar los resultados de la lista o mostrar información adicional. En el ejemplo siguiente se listan blobs y etiquetas de blobs:

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']}")

La salida es parecida a esta:

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'}

Nota:

La salida de ejemplo que se muestra supone que ya tiene una cuenta de almacenamiento con un espacio de nombres plano. Si ha habilitado la característica de espacio de nombres jerárquico en su cuenta de almacenamiento, los directorios no son virtuales. En su lugar, son objetos independientes y concretos. Como resultado, los directorios aparecen en la lista como blobs de longitud cero.

Para obtener una opción de lista alternativa al trabajar con un espacio de nombres jerárquico, consulte Enumerar el contenido del directorio (Azure Data Lake Storage Gen2).

Uso de una lista jerárquica

Cuando se llama a una operación de enumeración jerárquicamente, Azure Storage devuelve los directorios virtuales y los blobs en el primer nivel de la jerarquía.

Para enumerar los blobs jerárquicamente, use el método siguiente:

En el ejemplo siguiente se enumeran los blobs del contenedor especificado mediante una lista jerá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}")

La salida es parecida a esta:

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

Nota:

Las instantáneas de blob no se pueden enumerar en una operación de enumeración jerárquica.

Enumerar blobs de forma asincrónica

La biblioteca cliente de Azure Blob Storage para Python admite la enumeración de blobs de forma asincrónica. Para obtener más información sobre los requisitos de configuración del proyecto, consulte Programación asincrónica.

Siga estos pasos para enumerar blobs mediante API asincrónicas:

  1. Agregue las siguientes instrucciones import:

    import asyncio

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

  2. Agregue código para ejecutar el programa mediante asyncio.run. Esta función ejecuta la corrutina pasada, main() en nuestro ejemplo, y administra el bucle de eventos asyncio. Las corrutinas se declaran con la sintaxis async/await. En este ejemplo, la corrutina main() crea primero el nivel superior BlobServiceClient mediante async with y, a continuación, llama al método que enumera los blobs. Tenga en cuenta que solo el cliente de nivel superior debe usar async with, ya que otros clientes creados a partir de él comparten el mismo grupo de conexiones.

    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. Agregue código para enumerar los blobs. En el ejemplo de código siguiente se enumeran los blobs mediante una lista plana. El código es el mismo que en el ejemplo síncrono, excepto que el método se declara con la palabra clave async y se usa async foral llamar al métodolist_blobs.

    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}")

Con esta configuración básica, puede implementar otros ejemplos de este artículo como corrutinas mediante la sintaxis async/await.

Recursos

Para obtener más información sobre cómo enumerar blobs con la biblioteca cliente de Azure Blob Storage para Python, consulte los siguientes recursos.

Operaciones de API REST

Azure SDK para Python contiene bibliotecas que se basan en la API REST de Azure, lo que le permite interactuar con las operaciones de API REST por medio de paradigmas de Python que ya conoce. Los métodos de la biblioteca cliente para enumerar blobs usan la siguiente operación de API REST:

Ejemplos de código

Recursos de la biblioteca cliente

Consulte también