Share via

Elencare i BLOB con Python

  • Articolo

Questo articolo illustra come elencare i BLOB usando la libreria client Archiviazione di Azure per Python.

Per informazioni sull'elenco di BLOB tramite API asincrone, vedere Elencare i BLOB in modo asincrono.

Prerequisiti

  • Questo articolo presuppone che sia già stato configurato un progetto per lavorare con la libreria client Archiviazione BLOB di Azure per Python. Per informazioni sulla configurazione del progetto, tra cui l'installazione del pacchetto, l'aggiunta import di istruzioni e la creazione di un oggetto client autorizzato, vedere Introduzione a Archiviazione BLOB di Azure e Python.
  • Per usare le API asincrone nel codice, vedere i requisiti nella sezione Programmazione asincrona.
  • Il meccanismo di autorizzazione deve disporre delle autorizzazioni per elencare i BLOB. Per altre informazioni, vedere le linee guida per l'autorizzazione per l'operazione API REST seguente:

Informazioni sulle opzioni per l'elenco di BLOB

Quando si elencano i BLOB dal codice, è possibile specificare molte opzioni per gestire la modalità di restituzione dei risultati da Archiviazione di Azure. È possibile specificare il numero di risultati da restituire in ogni set di risultati e quindi recuperare i set successivi. È possibile specificare un prefisso per restituire i BLOB i cui nomi iniziano con tale carattere o stringa. Ed è possibile elencare i BLOB in una struttura elenco semplice o gerarchica. Un elenco gerarchico restituisce i BLOB come se fossero organizzati in cartelle.

Per elencare i BLOB in un contenitore usando un elenco semplice, chiamare uno di questi metodi:

  • ContainerClient.list_blobs (insieme al nome, è possibile includere facoltativamente metadati, tag e altre informazioni associate a ogni BLOB)
  • ContainerClient.list_blob_names (restituisce solo il nome del BLOB)

Per elencare i BLOB in un contenitore usando un elenco gerarchico, chiamare il metodo seguente:

  • ContainerClient.walk_blobs (insieme al nome, è possibile includere facoltativamente metadati, tag e altre informazioni associate a ogni BLOB)

Filtrare i risultati con un prefisso

Per filtrare l'elenco dei BLOB, specificare una stringa per l'argomento name_starts_with parola chiave. La stringa di prefisso può includere uno o più caratteri. Archiviazione di Azure restituisce solo i BLOB i cui nomi iniziano con tale prefisso.

Confronto tra elenco semplice e gerarchico

I BLOB in Archiviazione di Azure sono organizzati secondo un paradigma semplice, anziché gerarchico (come un file system classico). Tuttavia, è possibile organizzare i BLOB in directory virtuali per simulare una struttura di cartelle. Una directory virtuale costituisce parte del nome del BLOB ed è indicata dal carattere di delimitazione.

Per organizzare i BLOB in directory virtuali, usare un carattere di delimitazione nel nome del BLOB. Il delimitatore predefinito è la barra (/), ma è possibile specificare qualsiasi carattere.

Se i BLOB vengono denominati usando un delimitatore, è possibile scegliere un elenco gerarchico. In un'operazione di elenco gerarchico, Archiviazione di Azure restituisce le directory virtuali e i BLOB sotto l'oggetto padre. È possibile chiamare l'operazione di elenco in modo ricorsivo per attraversare la gerarchia in modo analogo a come si attraverserebbe un file system classico a livello di codice.

Usare un elenco semplice

Per impostazione predefinita, un'operazione di elenco restituisce i BLOB in un elenco semplice. In un elenco flat i BLOB non sono organizzati in base alla directory virtuale.

L'esempio seguente elenca i BLOB nel contenitore specificato usando un elenco flat:

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

L'output di esempio è simile al seguente:

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

È anche possibile specificare opzioni per filtrare i risultati dell'elenco o visualizzare informazioni aggiuntive. L'esempio seguente elenca i BLOB e i tag 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']}")

L'output di esempio è simile al seguente:

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

L'output di esempio illustrato presuppone che si disponga di un account di archiviazione con uno spazio dei nomi flat. Se è stata abilitata la funzionalità dello spazio dei nomi gerarchico per l'account di archiviazione, le directory non sono virtuali. Sono invece oggetti concreti e indipendenti. Di conseguenza, le directory vengono visualizzate nell'elenco come BLOB di lunghezza zero.

Per un'opzione di elenco alternativo quando si usa uno spazio dei nomi gerarchico, vedere Elencare il contenuto della directory (Azure Data Lake Archiviazione Gen2).

Usare un elenco gerarchico

Quando si chiama un'operazione di elenco gerarchico, Archiviazione di Azure restituisce le directory virtuali e i BLOB del primo livello della gerarchia.

Per elencare i BLOB in modo gerarchico, usare il metodo seguente:

L'esempio seguente elenca i BLOB nel contenitore specificato usando un elenco gerarchico:

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

L'output di esempio è simile al seguente:

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

Nota

In un'operazione di elenco gerarchico non è possibile elencare gli snapshot BLOB.

Elencare i BLOB in modo asincrono

La libreria client Archiviazione BLOB di Azure per Python supporta l'elenco asincrono dei BLOB. Per altre informazioni sui requisiti di configurazione del progetto, vedere Programmazione asincrona.

Seguire questa procedura per elencare i BLOB usando le API asincrone:

  1. Aggiungere le seguenti istruzioni Import:

    import asyncio

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

  2. Aggiungere il codice per eseguire il programma usando asyncio.run. Questa funzione esegue la coroutine passata, main() nell'esempio, e gestisce il asyncio ciclo di eventi. Le coroutine vengono dichiarate con la sintassi async/await. In questo esempio la main() coroutine crea prima il primo livello BlobServiceClient usando async with, quindi chiama il metodo che elenca i BLOB. Si noti che solo il client di primo livello deve usare async with, come altri client creati da esso condividono lo stesso pool di connessioni.

    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. Aggiungere codice per elencare i BLOB. L'esempio di codice seguente elenca i BLOB usando un elenco flat. Il codice è uguale all'esempio sincrono, ad eccezione del fatto che il metodo viene dichiarato con la async parola chiave e async for viene usato quando si chiama il list_blobs metodo .

    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 questa configurazione di base, è possibile implementare altri esempi in questo articolo come coroutine usando la sintassi async/await.

Risorse

Per altre informazioni su come elencare i BLOB usando la libreria client Archiviazione BLOB di Azure per Python, vedere le risorse seguenti.

Operazioni dell'API REST

Azure SDK per Python contiene librerie basate sull'API REST di Azure, che consentono di interagire con le operazioni dell'API REST tramite paradigmi Python noti. I metodi della libreria client per elencare i BLOB usano l'operazione API REST seguente:

Esempi di codice

Risorse della libreria client

Vedi anche