Definir ou alterar a camada de acesso de um blob de bloco com Python

Artigo
08/05/2024

Esse artigo mostra como definir ou alterar a camada de acesso para um blob de blocos usando a biblioteca de clientes do Armazenamento do Microsoft Azure para Python.

Para saber mais sobre como alterar a camada de acesso de um blob usando APIs assíncronas, consulte Alterar a camada de acesso de um blob de maneira assíncrona.

Pré-requisitos

Este artigo pressupõe que você já tenha um projeto configurado para trabalhar com a biblioteca de clientes do Armazenamento de Blobs do Azure para Python. Para saber mais sobre como configurar seu projeto, incluindo a instalação de pacote, a adição de instruções de import e a criação de um objeto de cliente autorizado, consulte Introdução ao Armazenamento de Blobs do Azure e Python.
O mecanismo de autorização deve ter permissões para definir a camada de acesso do blob. Para saber mais, consulte as diretrizes de autorização para as seguintes operações de API REST:
- Definir camada do blob

Sobre as camadas de acesso de blob de blocos

Para gerenciar os custos das necessidades de armazenamento, pode ser útil organizar seus dados com base na frequência com que são acessados e por quanto tempo precisam ser retidos. O Armazenamento do Azure oferece diferentes camadas de acesso para que você possa armazenar seus dados de blob da maneira mais econômica com base em como eles estão sendo usados.

Camadas de acesso para dados de blob

As camadas de acesso do Armazenamento do Azure incluem:

Camada quente – uma camada online otimizada para armazenar dados acessados ou modificados com frequência. A camada quente tem os custos de armazenamento mais altos, mas os custos de acesso mais baixos.
Camada fria – uma camada online otimizada para armazenar dados acessados ou modificados com pouca frequência. Os dados na camada fria devem ser armazenados por um mínimo de 30 dias. A camada fria tem custos de armazenamento mais baixos e custos de acesso mais altos em comparação com a camada quente.
Camada de acesso frio: uma camada online otimizada para armazenar dados acessados ou modificados com pouca frequência. Os dados na camada acesso frio devem ser armazenados por um mínimo de 90 dias. A camada de acesso frio tem custos de armazenamento mais baixos e custos de acesso mais altos em comparação com a camada de acesso esporádico.
Camada de arquivos: uma camada offline otimizada para armazenar dados acessados raramente e com requisitos de latência flexíveis, na ordem de horas. Os dados na camada de arquivos devem ser armazenados por um mínimo de 180 dias.

Para saber mais sobre as modalidades de acesso, confira Camadas de acesso de dados do blob.

Enquanto um blob estiver na camada de acesso aos arquivos, ele será considerado offline e não poderá ser lido nem alterado. Para ler ou modificar dados em um blob arquivado, primeiro você deve reidratar o blob para uma camada online. Para saber mais sobre como reidratar um blob da Camada de arquivos para uma camada online, confira Reidratação de blobs da Camada de arquivos.

Restrições

A configuração da camada de acesso somente é permitida em blobs de blocos. Para saber mais sobre restrições na configuração da camada de acesso de um blob de blocos, consulte Definir Camada de Blob (API REST).

Observação

Para definir a camada de acesso como Cold usando Python, você precisa usar uma versão mínima da biblioteca de clientes de 12.15.0.

Definir a camada de acesso de um blob durante o upload

Você pode definir a camada de acesso de um blob no carregamento passando o argumento de palavra-chave standard_blob_tier para upload_blob ou upload_blob_from_url.

O exemplo de código a seguir mostra como definir a camada de acesso ao carregar um 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)

Para saber mais sobre como carregar um blob com Python, confira Carregar um blob com Python.

Alterar a camada de acesso para um blob de bloco existente

Você pode alterar a camada de acesso de um blob de bloco existente usando a função a seguir:

set_standard_blob_tier

O exemplo de código a seguir mostra como alterar a camada de acesso de um blob existente para 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)

Se estiver reidratando um blob arquivado, opcionalmente, você pode passar o argumento de palavra-chave rehydrate_priority como HIGH ou STANDARD.

Copiar um blob para uma camada de acesso diferente

Você pode alterar a camada de acesso de um blob de blocos existente especificando uma camada de acesso como parte de uma operação de cópia. Para alterar a camada de acesso durante uma operação de cópia, passe o argumento de palavra-chave standard_blob_tier para start_copy_from_url. Se você estiver reidratando um blob da camada de arquivo usando uma operação de cópia, opcionalmente, poderá passar o argumento de palavra-chave rehydrate_priority como HIGH ou STANDARD.

O exemplo de código a seguir mostra como reidratar um blob arquivado na camada Hot usando uma operação de cópia:

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)

Para saber mais sobre como copiar um blob com Python, confira Copiar um blob com Python.

Alterar a camada de acesso de um blob de maneira assíncrona

A biblioteca de clientes do Armazenamento de Blobs do Azure para Python dá suporte à alteração assíncrona da camada de acesso de um contêiner de blobs. Para saber mais sobre os requisitos de instalação do projeto, confira Programação assíncrona.

Siga estas etapas para alterar a camada de acesso de um blob usando APIs assíncronas:

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

import asyncio

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

Adicione o código para executar o programa usando asyncio.run. Essa função executa a corrotina passada, main() no nosso exemplo, e gerencia o loop de eventos asyncio. As corrotinas são declaradas com a sintaxe async/await. Neste exemplo, a corrotina main() cria primeiro o nível superior BlobServiceClient usando async with e, em seguida, chama o método que altera a camada de acesso do blob. Observe que 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 = 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())

Adicione código para alterar a camada de acesso do blob. O código é igual ao exemplo síncrono, exceto que o método é declarado com a palavra-chave async e a palavra-chave await é usada ao chamar o método 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)
```

Com essa configuração básica em vigor, você pode implementar outros exemplos neste artigo como corrotinas usando sintaxe a async/await.

Recursos

Para saber mais sobre como configurar as camadas de acesso usando a biblioteca de clientes do Armazenamento de Blobs do Azure para Python, confira os recursos a seguir.

Operações da API REST

O SDK do Azure para Python contém bibliotecas que se baseiam na API REST do Azure, permitindo a interação com as operações da API REST por meio de paradigmas conhecidos do Python. Os métodos da biblioteca de clientes para configurar as camadas de acesso usam a seguinte operação de API REST:

Compartilhar via