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

Artigo
10/31/2024

Este artigo mostra como definir ou alterar a camada de acesso para um blob de bloco usando a biblioteca de cliente do Armazenamento do 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 forma assíncrona.

Pré-requisitos

Subscrição do Azure - crie uma gratuitamente
Conta de armazenamento do Azure - criar uma conta de armazenamento
Python 3.8+

Configurar o ambiente

Se você não tiver um projeto existente, esta seção mostra como configurar um projeto para trabalhar com a biblioteca de cliente do Armazenamento de Blobs do Azure para Python. Para obter mais detalhes, consulte Introdução ao Armazenamento de Blobs do Azure e Python.

Para trabalhar com os exemplos de código neste artigo, siga estas etapas para configurar seu projeto.

Instalar pacotes

Instale os seguintes pacotes usando pip install:

pip install azure-storage-blob azure-identity

Adicionar instruções de importação

Adicione as seguintes instruções import:

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

Autorização

O mecanismo de autorização deve ter as permissões necessárias para definir a camada de acesso de um blob. Para autorização com o Microsoft Entra ID (recomendado), você precisa da função interna do RBAC do Azure RBAC Storage Blob Data Contributor ou superior. Para saber mais, consulte as diretrizes de autorização para Definir camada de Blob.

Criar um objeto cliente

Para conectar um aplicativo ao Armazenamento de Blob, crie uma instância de BlobServiceClient. O exemplo a seguir mostra como criar um objeto cliente usando DefaultAzureCredential para autorização:

# TODO: Replace <storage-account-name> with your actual storage account name
account_url = "https://<storage-account-name>.blob.core.windows.net"
credential = DefaultAzureCredential()

# Create the BlobServiceClient object
blob_service_client = BlobServiceClient(account_url, credential=credential)

Você também pode criar objetos de cliente para contêineres ou blobs específicos, diretamente ou a partir do BlobServiceClient objeto. Para saber mais sobre como criar e gerenciar objetos de cliente, consulte Criar e gerenciar objetos de cliente que interagem com recursos de dados.

Sobre as camadas de acesso de blob de bloco

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 blobs

As camadas de acesso do Armazenamento do Azure incluem:

Hot tier - Uma camada online otimizada para armazenar dados que são acessados ou modificados com frequência. O nível quente tem os custos de armazenamento mais altos, mas os menores custos de acesso.
Camada legal - Uma camada online otimizada para armazenar dados que são acessados ou modificados com pouca frequência. Os dados na camada fria devem ser armazenados por um período mínimo de 30 dias. O nível frio tem custos de armazenamento mais baixos e custos de acesso mais altos em comparação com o nível quente.
Camada fria - Uma camada online otimizada para armazenar dados acessados ou modificados com pouca frequência. Os dados na camada de acesso infrequente devem ser armazenados durante um mínimo de 90 dias. A camada de acesso infrequente tem custos de armazenamento inferiores e custos de acesso superiores em comparação com a camada de acesso esporádico.
Camada de arquivamento - Uma camada offline otimizada para armazenar dados que raramente são acessados e que tem requisitos de latência flexíveis, na ordem das horas. Os dados na camada de arquivo devem ser armazenados por um período mínimo de 180 dias.

Para saber mais sobre camadas de acesso, consulte Camadas de acesso para dados de blob.

Embora um blob esteja na camada de acesso Arquivo, ele é considerado offline e não pode ser lido ou modificado. Para ler ou modificar dados em um blob arquivado, você deve primeiro reidratar o blob para uma camada online. Para saber mais sobre como reidratar um blob da camada Arquivo para uma camada online, consulte Reidratação de Blob da camada Arquivo.

Restrições

A definição da camada de acesso só é permitida em blobs de bloco. Para saber mais sobre as restrições na definição da camada de acesso de um blob de bloco, consulte Definir camada de blob (API REST).

Nota

Para definir a camada de acesso para Cold usar Python, você deve usar uma versão mínima da biblioteca de cliente de 12.15.0.

Definir a camada de acesso de um blob durante o carregamento

Você pode definir a camada de acesso de um blob no upload passando o argumento da standard_blob_tier palavra-chave 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, consulte 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 seguinte função:

set_standard_blob_tier

O exemplo de código a seguir mostra como alterar a camada de acesso para 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 a reidratar uma blob arquivada, pode opcionalmente passar o argumento da rehydrate_priority palavra-chave como HIGH ou STANDARD.

Copiar um blob para uma camada de acesso diferente

Você pode alterar a camada de acesso de um blob de bloco 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 da standard_blob_tier palavra-chave para start_copy_from_url. Se você estiver reidratando um blob da camada de arquivo usando uma operação de cópia, você pode, opcionalmente, passar o argumento de rehydrate_priority palavra-chave como HIGH ou STANDARD.

O exemplo de código a seguir mostra como reidratar um blob arquivado para a Hot camada 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, consulte Copiar um blob com Python.

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

A biblioteca de cliente do Armazenamento de Blobs do Azure para Python dá suporte à alteração assíncrona da camada de acesso de um blob. Para saber mais sobre os requisitos de configuração do projeto, consulte 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 código para executar o programa usando asyncio.runo . Essa função executa a co-rotina passada, main() em nosso exemplo, e gerencia o loop de asyncio eventos. As co-rotinas são declaradas com a sintaxe async/await. Neste exemplo, a main() co-rotina primeiro cria o nível BlobServiceClient superior usando async withe, em seguida, chama o método que altera a camada de acesso do blob. Observe que apenas o cliente de nível superior precisa usar async witho , pois 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 é o mesmo que o exemplo síncrono, exceto que o método é declarado com a async palavra-chave e a await palavra-chave é usada ao chamar o set_standard_blob_tier método.
```
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 co-rotinas usando a sintaxe async/await.

Recursos

Para saber mais sobre como definir camadas de acesso usando a biblioteca de cliente do Armazenamento de Blobs do Azure para Python, consulte 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 que você interaja com operações da API REST por meio de paradigmas Python familiares. Os métodos da biblioteca de cliente para definir camadas de acesso usam a seguinte operação de API REST:

Partilhar via