Partilhar via

Gerencie propriedades de blob e metadados com Python

  • Artigo

Além dos dados que contêm, os blobs suportam propriedades do sistema e metadados definidos pelo usuário. Este artigo mostra como gerenciar propriedades do sistema e metadados definidos pelo usuário usando a biblioteca de cliente do Armazenamento do Azure para Python.

Para saber mais sobre como gerenciar propriedades e metadados usando APIs assíncronas, consulte Definir metadados de blob de forma assíncrona.

Pré-requisitos

Sobre propriedades e metadados

  • Propriedades do sistema: as propriedades do sistema existem em cada recurso de armazenamento de Blob. Alguns deles podem ser lidos ou definidos, enquanto outros são somente leitura. Sob as capas, algumas propriedades do sistema correspondem a determinados cabeçalhos HTTP padrão. A biblioteca de cliente do Armazenamento do Azure para Python mantém essas propriedades para você.

  • Metadados definidos pelo usuário: os metadados definidos pelo usuário consistem em um ou mais pares nome-valor que você especifica para um recurso de armazenamento de Blob. Você pode usar metadados para armazenar valores adicionais com o recurso. Os valores de metadados são apenas para seus próprios fins e não afetam como o recurso se comporta.

    Os pares nome/valor de metadados são cabeçalhos HTTP válidos e devem aderir a todas as restrições que regem os cabeçalhos HTTP. Para obter mais informações sobre requisitos de nomenclatura de metadados, consulte Nomes de metadados.

Nota

As tags de índice de Blob também fornecem a capacidade de armazenar atributos de chave/valor arbitrários definidos pelo usuário ao lado de um recurso de armazenamento de Blob do Azure. Embora semelhante aos metadados, apenas as tags de índice de blob são automaticamente indexadas e tornadas pesquisáveis pelo serviço de blob nativo. Os metadados não podem ser indexados e consultados, a menos que você utilize um serviço separado, como a Pesquisa do Azure.

Para saber mais sobre esse recurso, consulte Gerenciar e localizar dados no armazenamento de Blob do Azure com índice de blob (visualização).

Definir e recuperar propriedades

Para definir propriedades em um blob, use o seguinte método:

Todas as propriedades não definidas explicitamente são limpas. Para preservar quaisquer propriedades existentes, você pode primeiro recuperar as propriedades de blob e, em seguida, usá-las para preencher os cabeçalhos que não estão sendo atualizados.

O exemplo de código a seguir define as propriedades e content_language system content_type em um blob, preservando as propriedades existentes:

def set_properties(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # Get the existing blob properties
    properties = blob_client.get_blob_properties()

    # Set the content_type and content_language headers, and populate the remaining headers from the existing properties
    blob_headers = ContentSettings(content_type="text/plain",
                                   content_encoding=properties.content_settings.content_encoding,
                                   content_language="en-US",
                                   content_disposition=properties.content_settings.content_disposition,
                                   cache_control=properties.content_settings.cache_control,
                                   content_md5=properties.content_settings.content_md5)
    
    blob_client.set_http_headers(blob_headers)

Para recuperar propriedades em um blob, use o seguinte método:

O exemplo de código a seguir obtém as propriedades do sistema de um blob e exibe alguns dos valores:

def get_properties(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    properties = blob_client.get_blob_properties()

    print(f"Blob type: {properties.blob_type}")
    print(f"Blob size: {properties.size}")
    print(f"Content type: {properties.content_settings.content_type}")
    print(f"Content language: {properties.content_settings.content_language}")

Definir e recuperar metadados

Você pode especificar metadados como um ou mais pares nome-valor em um recurso de blob ou contêiner. Para definir metadados, envie um dicionário contendo pares nome-valor usando o seguinte método:

O exemplo de código a seguir define metadados em um blob:

def set_metadata(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # Retrieve existing metadata, if desired
    blob_metadata = blob_client.get_blob_properties().metadata

    more_blob_metadata = {'docType': 'text', 'docCategory': 'reference'}
    blob_metadata.update(more_blob_metadata)

    # Set metadata on the blob
    blob_client.set_blob_metadata(metadata=blob_metadata)

Para recuperar metadados, chame o método get_blob_properties em seu blob para preencher a coleção de metadados e, em seguida, leia os valores, conforme mostrado no exemplo abaixo. O get_blob_properties método recupera propriedades de blob e metadados chamando a operação Get Blob Properties e a operação Get Blob Metadata .

O exemplo de código a seguir lê metadados em um blob e imprime cada par chave/valor:

def get_metadata(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # Retrieve existing metadata, if desired
    blob_metadata = blob_client.get_blob_properties().metadata

    for k, v in blob_metadata.items():
        print(k, v)

Definir metadados de blob de forma assíncrona

A biblioteca de cliente do Armazenamento de Blobs do Azure para Python dá suporte ao gerenciamento assíncrono de propriedades de blob e metadados. Para saber mais sobre os requisitos de configuração do projeto, consulte Programação assíncrona.

Siga estas etapas para definir metadados de blob usando APIs assíncronas:

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

    import asyncio

from azure.identity.aio import DefaultAzureCredential
from azure.storage.blob.aio import BlobServiceClient

  2. 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 define os metadados de 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 = 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.set_metadata(blob_service_client, "sample-container")

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

  3. Adicione código para definir os metadados de 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 os get_blob_properties métodos and set_blob_metadata .

    async def set_metadata(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # Retrieve existing metadata, if desired
    properties = await blob_client.get_blob_properties()
    blob_metadata = properties.metadata

    more_blob_metadata = {'docType': 'text', 'docCategory': 'reference'}
    blob_metadata.update(more_blob_metadata)

    # Set metadata on the blob
    await blob_client.set_blob_metadata(metadata=blob_metadata)

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 gerenciar propriedades do sistema e metadados definidos pelo usuário 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 gerenciar propriedades do sistema e metadados definidos pelo usuário usam as seguintes operações da API REST:

Amostras de código

Recursos da biblioteca do cliente