Condividi tramite

Gestire le proprietà e i metadati dei BLOB con Python

  • Articolo

Oltre ai dati che contengono, i BLOB supportano le proprietà di sistema e i metadati definiti dall'utente. Questo articolo illustra come gestire le proprietà di sistema e i metadati definiti dall’utente usando la libreria client di Archiviazione di Azure per Python.

Per informazioni sulla gestione di proprietà e metadati tramite API asincrone, vedere Impostare i metadati BLOB in modo asincrono.

Prerequisiti

Configurazione dell'ambiente

Se non si ha un progetto esistente, questa sezione illustra come configurare un progetto per l’uso con la libreria client di Archiviazione BLOB di Azure per Python. Per altre informazioni, vedere Introduzione all’Archiviazione BLOB di Azure e a Python.

Per usare gli esempi di codice in questo articolo, seguire questa procedura per configurare il progetto.

Installare i pacchetti

Installare i pacchetti seguenti tramite pip install:

pip install azure-storage-blob azure-identity

Aggiungere le istruzioni di importazione

Aggiungere le istruzioni import seguenti:

from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient, ContentSettings

Autorizzazione

Il meccanismo di autorizzazione deve disporre delle autorizzazioni necessarie per utilizzare proprietà o metadati dei contenitori. Per l'autorizzazione con Microsoft Entra ID (scelta consigliata), è necessario disporre del ruolo predefinito di Controllo degli accessi in base al ruolo di Azure Lettore dei dati del BLOB di archiviazione o ruolo superiore per le operazioni get, e del ruolo Collaboratore ai dati del BLOB di archiviazione o ruolo superiore per le operazioni set. Per altre informazioni, vedere le indicazioni sulle autorizzazioni per Set Blob Properties (API REST), Get Blob Properties (API REST), Set Blob Metadata (API REST) o Get Blob Metadata (API REST).

Creare un oggetto client

Per connettere un'app ad Archiviazione BLOB, creare un'istanza di BlobServiceClient. Nell'esempio seguente viene illustrato come creare un oggetto client usando DefaultAzureCredential per l'autorizzazione:

# 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)

È anche possibile creare oggetti client per contenitori specifici o BLOB, direttamente o dall’oggetto BlobServiceClient. Per altre informazioni sulla creazione e la gestione di oggetti client, vedere Creare e gestire oggetti client che interagiscono con le risorse dati.

Informazioni su proprietà e metadati

  • Proprietà di sistema: le proprietà di sistema esistono in ogni risorsa di archiviazione BLOB. Alcune di esse possono essere lette o impostate, mentre altre sono di sola lettura. Anche se in modo non esplicito, alcune proprietà di sistema corrispondono a specifiche intestazioni HTTP standard. La libreria client di Archiviazione di Azure per Python gestisce automaticamente queste proprietà.

  • Metadati definiti dall'utente: i metadati definiti dall'utente sono costituiti da una o più coppie nome-valore specificate per una risorsa di archiviazione BLOB. È possibile usare i metadati per archiviare valori aggiuntivi con la risorsa. I valori di metadati sono solo per le proprie esigenze e non influiscono sul comportamento della risorsa.

    Le coppie nome/valore di metadati sono intestazioni HTTP valide e devono essere conformi alle restrizioni imposte sulle intestazioni HTTP. Per ulteriori informazioni sui requisiti di denominazione dei metadati, consultare Nomi dei metadati.

Nota

I tag indice BLOB offrono anche la possibilità di archiviare attributi chiave/valore arbitrari definiti dall'utente insieme a una risorsa di Archiviazione BLOB di Azure. Analogamente ai metadati, solo i tag indice BLOB vengono indicizzati automaticamente e resi ricercabili dal servizio BLOB nativo. I metadati non possono essere indicizzati e sottoposti a query a meno che non si usi un servizio diverso, ad esempio Ricerca cognitiva di Azure.

Per altre informazioni su questa funzionalità, vedere Gestire e trovare i dati nell'archiviazione BLOB di Azure con l'indice BLOB (anteprima).

Impostare e recuperare le proprietà

Per impostare le proprietà in un BLOB, usare il metodo seguente:

Tutte le proprietà non impostate in modo esplicito vengono cancellate. Per conservare le proprietà esistenti, innanzitutto è possibile recuperare le proprietà del BLOB, quindi usarle per popolare le intestazioni che non vengono aggiornate.

Nell'esempio di codice seguente vengono impostate le proprietà di sistema content_type e content_language in un BLOB, conservando al tempo stesso le proprietà esistenti:

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)

Per recuperare le proprietà in un BLOB, usare il metodo seguente:

L'esempio di codice seguente recupera le proprietà di sistema di un BLOB e visualizza alcuni dei valori:

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

Impostare e recuperare i metadati

È possibile specificare i metadati come uno o più coppie nome-valore in una risorsa BLOB o contenitore. Per impostare i metadati, inviare un dizionario contenente coppie nome-valore usando il metodo seguente:

Il seguente codice di esempio imposta i metadati in un 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)

Per recuperare metadati, chiamare il metodo get_blob_properties nel BLOB per popolare la raccolta di metadati, quindi leggere i valori come illustrato nell’esempio seguente. Il metodo get_blob_properties recupera le proprietà e i metadati del BLOB chiamando sia l'operazione Get Blob Properties, sia l'operazione Get Blob Metadata.

L'esempio di codice seguente legge i metadati in un BLOB e stampa ogni coppia chiave/valore:

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)

Impostare i metadati blob in modo asincrono

La libreria client di Archiviazione BLOB di Azure per Python supporta la gestione asincrona delle proprietà e dei metadati dei BLOB. Per altre informazioni sui requisiti di configurazione del progetto, consultare Programmazione asincrona.

Seguire questa procedura per impostare i metadati del BLOB usando le API asincrone:

  1. Aggiungere le seguenti istruzioni Import:

    import asyncio

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

  2. Aggiungere il codice per eseguire il programma utilizzando asyncio.run. Questa funzione esegue la coroutine passata, main() nell'esempio, e gestisce il ciclo di eventi asyncio. Le coroutine vengono dichiarate con la sintassi async/await. In questo esempio, la coroutine main() crea innanzitutto il BlobServiceClient di primo livello usando async with, quindi chiama il metodo che imposta i metadati del BLOB. Si noti che soltanto il client di primo livello deve utilizzare async with, poiché gli altri client da esso creati condividono lo stesso pool di connessioni.

    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. Aggiungere il codice per impostare i metadati del BLOB. Il codice è uguale all'esempio sincrono, ad eccezione del fatto che il metodo viene dichiarato con la parola chiave async e la parola chiave await viene usata quando si chiamano i metodi get_blob_properties e 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)

Con questa configurazione di base, è possibile implementare altri esempi in questo articolo come coroutine usando la sintassi async/await.

Risorse

Per altre informazioni su come gestire le proprietà di sistema e i metadati definiti dagli utenti usando la libreria client di Archiviazione BLOB di Azure per Python, vedere le risorse seguenti.

Esempi di codice

Operazioni dell'API REST

Azure SDK per Python contiene librerie basate su API REST di Azure che consentono di interagire con le operazioni API REST tramite paradigmi Python noti. I metodi della libreria client per gestire le proprietà di sistema e i metadati definiti dall'utente usano le operazioni API REST seguenti:

Risorse della libreria client

Contenuto correlato

  • Questo articolo fa parte della Guida per sviluppatori di Archiviazione BLOB per Python. Per altre informazioni, vedere l’elenco completo degli articoli della Guida per sviluppatori in Compilare la propria app Python.