Définir ou modifier le niveau d’accès d’un objet blob de blocs avec Python

Article
12/28/2023

Cet article montre comment utiliser le niveau d’accès des objets blob de blocs avec la Bibliothèque de client Stockage Azure pour Python.

Pour en savoir plus sur la modification du niveau d’accès d’un objet blob à l’aide d’API asynchrones, consultez Modifier le niveau d’accès d’un objet 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 de packages, l’ajout d’instructions import et la création d’un objet client autorisé, consultez Prise en main du Stockage Blob Azure et de Python.
Le mécanisme d’autorisation doit disposer des autorisations nécessaires pour définir le niveau d’accès des objets blob. Pour en savoir plus, consultez les conseils d’autorisation pour l’opération d’API REST suivante :
- Set Blob Tier

Comprendre les niveaux d’accès aux objets blob de blocs

Pour gérer les coûts liés à vos besoins en matière de stockage, il peut être utile d’organiser vos données en fonction de la fréquence à laquelle elles sont accessibles et de la durée pendant laquelle elles devront conservées. Le Stockage Azure offre différents niveaux d’accès afin que vous puissiez stocker vos données d’objet blob de la manière la plus économique en fonction de la façon dont elles sont utilisées.

Niveaux d’accès pour les données d’objets blob

Les niveaux d’accès Stockage Azure comprennent les suivants :

Niveau chaud : niveau en ligne optimisé pour le stockage des données qui sont fréquemment consultées ou modifiées. Le niveau chaud offre les coûts de stockage les plus élevés, mais les coûts d’accès les plus faibles.
Niveau froid : niveau en ligne optimisé pour le stockage des données rarement consultées ou modifiées. Les données dans le niveau d’accès froid doivent être stockées pendant un minimum de 30 jours. Le niveau d’accès froid possède des coûts de stockage plus faibles et des coûts d’accès plus élevés que le niveau chaud.
Niveau froid : niveau en ligne optimisé pour le stockage des données rarement consultées ou modifiées. Les données dans le niveau d’accès froid doivent être stockées pendant un minimum de 90 jours. Le niveau d’accès froid possède des coûts de stockage plus faibles et des coûts d’accès plus élevés que le niveau sporadique.
Niveau Archive : un niveau hors connexion optimisé pour le stockage des données rarement sollicitées, sous des conditions de latence flexibles, de l’ordre de quelques heures. Les données dans le niveau Archive doivent être stockées pendant un minimum de 180 jours.

Pour en savoir plus sur les niveaux d’accès, consultez Niveaux d’accès pour les données blob.

Lorsqu’un objet blob se trouve dans le niveau d’accès Archive, il est considéré comme hors connexion et ne peut être ni lu ni modifié. Pour lire ou modifier les données d'un blob archivé, vous devez d'abord réhydrater le blob à un niveau en ligne. Pour en savoir plus sur la réactivation d’objets blob à partir du niveau archive vers un niveau en ligne, consultez Réhydratation d’objets blob à partir du niveau archive.

Restrictions

La définition du niveau d’accès est autorisée seulement sur les objets blob de blocs. Pour en savoir plus sur les restrictions relatives à la définition du niveau d’accès d’un objet blob de blocs, consultez Définir le niveau d’objet blob (API REST).

Notes

Pour définir le niveau d’accès à Cold en utilisant Python, vous devez utiliser une version minimale 12.15.0 de la bibliothèque de client.

Définir le niveau d’accès d’un objet blob pendant le chargement

Vous pouvez définir le niveau d’accès d’un objet blob lors du chargement en transmettant standard_blob_tier l’argument de mot clé upload_blob ou upload_blob_from_url.

L’exemple de code suivant montre comment définir le niveau d’accès lors du chargement d’un objet blob :

def upload_blob_access_tier(self, blob_service_client: BlobServiceClient, container_name: str, blob_name: str):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob=blob_name)
    
    #Upload blob to the cool tier
    with open(file=os.path.join(r'file_path', blob_name), mode="rb") as data:
        blob_client = blob_client.upload_blob(data=data, overwrite=True, standard_blob_tier=StandardBlobTier.COOL)

Pour en savoir plus sur le chargement d’un objet blob avec Python, consultez Charger un objet blob avec Python.

Modifier le niveau d’accès d’un objet blob de blocs existant

Vous pouvez modifier le niveau d’accès d’un objet blob de blocs existant à l’aide de la fonction suivante :

set_standard_blob_tier

L’exemple de code suivant montre comment modifier le niveau d’accès d’un objet blob existant en Cool :

def change_blob_access_tier(self, blob_client: BlobClient):
    # Change the blob access tier to cool
    blob_client.set_standard_blob_tier(StandardBlobTier.COOL)

Si vous réhydratez un objet blob archivé, vous pouvez alternativement transmettre rehydrate_priority l’argument de mot clé HIGH ou STANDARD.

Copier un objet blob dans un niveau d’accès différent

Vous pouvez modifier le niveau d’accès d’un objet blob de blocs existant en spécifiant un niveau d’accès dans le cadre d’une opération de copie. Pour modifier le niveau d’accès pendant une opération de copie, transmettez l’standard_blob_tier argument de mot clé start_copy_from_url. Si vous réhydratez un objet blob à partir du niveau archive à l’aide d’une opération de copie, vous pouvez éventuellement transmettre rehydrate_priorityl’argument de mot clé HIGH ou STANDARD.

L’exemple de code suivant montre comment réhydrater un objet blob archivé au niveau Hot à l’aide d’une opération de copie :

def rehydrate_blob_using_copy(self, source_archive_blob: BlobClient, destination_rehydrated_blob: BlobClient):
    # Note: the destination blob must have a different name than the source blob

    # Start the copy operation - specify the rehydrate priority and blob access tier
    copy_operation = dict()
    copy_operation = destination_rehydrated_blob.start_copy_from_url(
        source_url=source_archive_blob.url,
        standard_blob_tier=StandardBlobTier.HOT,
        rehydrate_priority=RehydratePriority.STANDARD,
        requires_sync=False)

Pour en savoir plus sur la copie d’un objet blob avec Python, consultez Copier un objet blob avec Python.

Modifier le niveau d’accès d’un objet blob de manière asynchrone

La bibliothèque cliente Stockage Blob Azure pour Python prend en charge la modification asynchrone du niveau d’accès d’un objet blob. Pour en savoir plus sur les exigences de configuration de projet, consultez programmation asynchrone.

Procédez comme suit pour modifier le niveau d’accès d’un objet blob à l’aide d’API asynchrones :

Ajoutez les instructions d’importation suivantes :

import asyncio

from azure.storage.blob import (
StandardBlobTier
)
from azure.identity.aio import DefaultAzureCredential
from azure.storage.blob.aio import (
BlobServiceClient,
BlobClient
)

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 coroutine main() crée d’abord le niveau supérieur BlobServiceClient à l’aide de async with, puis appelle la méthode qui modifie le niveau d’accès de 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 = BlobAccessTierSamples()

    # TODO: Replace <storage-account-name> with an 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:
        # Change the blob access tier to cool
        blob_client = blob_service_client.get_blob_client(container="sample-container", blob="sample-blob.txt")
        await sample.change_blob_access_tier(blob_client=blob_client)

if __name__ == '__main__':
    asyncio.run(main())

Ajoutez le code pour modifier le niveau d’accès de l’objet blob. Le code est identique à l’exemple synchrone, sauf que la méthode est déclarée avec le mot clé async et que le mot clé await est utilisé lors de l’appel de la méthode set_standard_blob_tier.
```
async def change_blob_access_tier(self, blob_client: BlobClient):
    # Change the blob access tier to cool
    await blob_client.set_standard_blob_tier(StandardBlobTier.COOL)
```

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 plus sur la définition des niveaux d’accès à 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 SDK Azure pour Python contient des bibliothèques qui reposent sur l’API REST Azure, ce qui vous permet d’interagir avec les opérations de l’API REST via des paradigmes Python familiers. Les méthodes de bibliothèque de client pour la définition de niveaux d’accès utilisent l’opération d’API REST suivante :

Partager via