Lister les objets blob avec Python

  • Article

Cet article explique comment lister les objets blob à l’aide de la bibliothèque de client Stockage Azure pour Python.

Pour en savoir plus sur la liste des objets blob à l’aide d’API asynchrones, consultez Répertorier les objets blob de manière asynchrone.

Prérequis

  • Cet article suppose que vous disposez déjà d'un projet configuré pour fonctionner avec la bibliothèque client Azure Blob Storage pour Python. Pour en savoir plus sur la configuration de votre projet, y compris l'installation du package, l'ajout d'instructions import et la création d'un objet client autorisé, consultez Bien démarrer avec Azure Blob Storage et Python.
  • Pour utiliser des API asynchrones dans votre code, consultez les conditions requises dans la section programmation asynchrone.
  • Le mécanisme d’autorisation doit disposer des autorisations nécessaires pour répertorier les objets blob. Pour en savoir plus, consultez les conseils d’autorisation pour l’opération d’API REST suivante :

À propos des options de liste d’objets blob

Quand vous listez les blobs dans votre code, vous pouvez spécifier de nombreuses options pour gérer la façon dont les résultats sont retournés par le Stockage Azure. Vous pouvez spécifier le nombre de résultats à retourner dans chaque ensemble de résultats, puis récupérer les ensembles suivants. Vous pouvez spécifier un préfixe pour retourner les blobs dont le nom commence par ce caractère ou cette chaîne. Vous pouvez également répertorier les blobs dans une structure de liste plate, ou hiérarchiquement. Une liste hiérarchique retourne les blobs comme s’ils étaient organisés en dossiers.

Pour lister les objets blob dans un conteneur à l’aide d’une liste plate, appelez l’une des méthodes suivantes :

Pour répertorier les objets blob dans un conteneur à l’aide d’une liste hiérarchique, appelez la méthode suivante :

  • ContainerClient.walk_blobs (avec le nom, vous pouvez éventuellement inclure des métadonnées, des balises et d’autres informations associées à chaque objet blob)

Filtrez les résultats avec un préfixe

Pour filtrer la liste d’objets blob, spécifiez une chaîne pour l’argument de mot clé name_starts_with. La chaîne de préfixe peut inclure un ou plusieurs caractères. Le stockage Azure retourne alors uniquement les objets blob dont les noms commencent par ce préfixe.

Création d’une liste plate ou d’une liste hiérarchique

Les objets blob dans le stockage Azure sont organisés en paradigme plat, plutôt qu’en paradigme hiérarchique (comme un système de fichiers standard). Toutefois, vous pouvez organiser les blobs en répertoires virtuels afin de simuler une structure de dossiers. Un répertoire virtuel fait partie du nom du blob et est indiqué par le caractère délimiteur.

Pour organiser les objets blob en répertoires virtuels, utilisez un caractère délimiteur dans les noms des objets blob. Le caractère délimiteur par défaut est une barre oblique (/), mais vous pouvez spécifier n’importe quel caractère comme délimiteur.

Si vous nommez vos objets blob en utilisant un délimiteur, vous pouvez choisir de lister les objets blob hiérarchiquement. Pour une opération de création de liste hiérarchique, le stockage Azure retourne tous les répertoires virtuels et les objets blob figurant sous l’objet parent. Vous pouvez appeler l’opération de création de liste de manière récursive pour parcourir la hiérarchie, de la même façon que vous parcourez un système de fichiers standard par programmation.

Utiliser une liste plate

Par défaut, une opération de création de liste retourne les objets blob dans une liste plate. Dans une liste plate, les blobs ne sont pas organisés par répertoire virtuel.

L’exemple suivant liste les blobs dans le conteneur spécifié en utilisant une liste plate :

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

Exemple de sortie :

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

Vous pouvez également spécifier des options pour filtrer les résultats de liste ou afficher des informations supplémentaires. L’exemple suivant répertorie les objets blob et les étiquettes correspondantes :

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

Exemple de sortie :

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

Remarque

L’exemple de sortie affiché suppose que vous disposez d’un compte de stockage avec un espace de noms plat. Si vous avez activé la fonctionnalité d’espace de noms hiérarchique pour votre compte de stockage, les répertoires ne sont pas virtuels. Au lieu de cela, ce sont des objets concrets et indépendants. Par conséquent, les répertoires apparaissent dans la liste sous forme d’objets blob de longueur nulle.

Pour obtenir une autre option de référencement lors de l’utilisation d’un espace de noms hiérarchique, consultez Répertorier le contenu du répertoire (Azure Data Lake Storage Gen2).

Utiliser une liste hiérarchique

Lorsque vous appelez une opération de création de liste hiérarchique, le stockage Azure retourne les répertoires virtuels et les objets blob figurant au premier niveau de la hiérarchie.

Pour lister les blobs de manière hiérarchique, utilisez la méthode suivante :

L’exemple suivant liste les blobs dans le conteneur spécifié en utilisant une liste hiérarchique :

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

Exemple de sortie :

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

Notes

Les instantanés d’objets blob ne peuvent pas être listés dans une opération de création de liste hiérarchique.

Répertorie des objets blob de manière asynchrone

La bibliothèque cliente Stockage Blob Azure pour Python prend en charge le répertoriage asynchrone d’objets blob. Pour en savoir plus sur les exigences de configuration de projet, consultez programmation asynchrone.

Procédez comme suit pour répertorier les objets blob à l’aide d’API asynchrones :

  1. Ajoutez les instructions d’importation suivantes :

    import asyncio

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

  2. Ajoutez du code pour exécuter le programme à l’aide de asyncio.run. Cette fonction exécute la coroutine passée, main() dans notre exemple et gère la boucle d’événement asyncio. Les coroutines sont déclarées avec la syntaxe asynchrone/await. Dans cet exemple, la main()coroutine crée d’abord le niveau supérieur BlobServiceClient à l’aide de async with, puis appelle la méthode qui répertorie l’objet blob. Notez que seul le client de niveau supérieur doit utiliser async with, car d’autres clients créés à partir de celui-ci partagent le même pool de connexions.

    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. Ajoutez du code pour répertorier les objets blob. L’exemple de code suivant répertorie les objets blob à l’aide d’une liste plate. Le code est identique à celui de l’exemple synchrone, sauf que la méthode est déclarée avec le mot clé async et que async for est utilisé lors de l’appel de la méthode list_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}")

Avec cette configuration de base en place, vous pouvez implémenter d’autres exemples dans cet article en tant que coroutines à l’aide de la syntaxe asynchrone/await.

Ressources

Pour en savoir comment lister les objets blob à l’aide de la bibliothèque de client Stockage Blob Azure pour Python, consultez les ressources suivantes.

Opérations de l'API REST

Le kit de développement logiciel (SDK) Azure pour Python contient des bibliothèques qui s’appuient sur l’API REST Azure, vous permettant d’interagir avec les opérations de l’API REST par le biais de paradigmes Python familiers. Les méthodes de bibliothèque de client pour lister les objets blob utilisent l’opération d’API REST suivante :

Exemples de code

Ressources de bibliothèque cliente

Voir aussi