Condividi tramite

Eliminare e ripristinare un BLOB con Python

  • Articolo

Questo articolo illustra come eliminare i BLOB usando la libreria client di Archiviazione di Azure per Python. Se è stata abilitata l'eliminazione temporanea per i BLOB, è possibile ripristinare i BLOB eliminati durante il periodo di conservazione.

Per informazioni sull'eliminazione di un BLOB tramite API asincrone, vedere Eliminare un BLOB in modo asincrono.

Prerequisiti

  • Questo articolo presuppone che sia già stato configurato un progetto per lavorare con la libreria client di Archiviazione BLOB di Azure per Python. Per informazioni sulla configurazione del progetto, tra cui l'installazione del pacchetto, l'aggiunta di import istruzioni e la creazione di un oggetto client autorizzato, vedere Introduzione ad Archiviazione BLOB di Azure e Python.
  • Per usare le API asincrone nel codice, vedere i requisiti nella sezione Programmazione asincrona.
  • Il meccanismo di autorizzazione deve disporre delle autorizzazioni per eliminare un BLOB o per ripristinare un BLOB eliminato temporaneamente. Per altre informazioni, vedere le linee guida per l'autorizzazione per le operazioni API REST seguenti:

Eliminare un BLOB

Per eliminare un BLOB, chiamare il metodo seguente:

L'esempio seguente elimina un BLOB:

def delete_blob(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)
    blob_client.delete_blob()

Se il BLOB ha snapshot associati, è necessario eliminare tutti gli snapshot per eliminare il BLOB. L'esempio seguente elimina un BLOB e i suoi snapshot:

def delete_blob_snapshots(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)
    blob_client.delete_blob(delete_snapshots="include")

Per eliminare solo gli snapshot e non il BLOB stesso, è possibile passare il parametro delete_snapshots="only".

Ripristinare un BLOB eliminato

L'eliminazione temporanea dei BLOB protegge un singolo BLOB con le sue versioni, gli snapshot e i metadati da eliminazioni o sovrascritture accidentali, mantenendo i dati eliminati nel sistema per un periodo di tempo specificato. Durante il periodo di conservazione è possibile ripristinare il BLOB nello stato in cui era al momento dell'eliminazione. Dopo la scadenza del periodo di conservazione, il BLOB viene eliminato definitivamente. Per altre informazioni sull'eliminazione temporanea dei BLOB, vedere Eliminazione temporanea per i BLOB.

È possibile usare le librerie client di Archiviazione di Azure per ripristinare un BLOB o uno snapshot eliminato temporaneamente.

La modalità di ripristino di un BLOB eliminato temporaneamente dipende dal fatto che l'account di archiviazione disponga o meno del controllo delle versioni per i BLOB abilitato. Per altre informazioni sul controllo delle versioni dei BLOB, vedere Controllo delle versioni per i BLOB. Passare a una delle sezioni seguenti in base allo scenario:

Ripristinare gli oggetti eliminati temporaneamente quando il controllo delle versioni è disabilitato

Per ripristinare i BLOB eliminati quando il controllo delle versioni è disabilitato, chiamare il metodo seguente:

Questo metodo ripristina il contenuto e i metadati di un BLOB eliminato temporaneamente e gli eventuali snapshot eliminati temporaneamente associati. Chiamare questo metodo per un BLOB che non è stato eliminato non ha alcun effetto.

def restore_blob(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)
    blob_client.undelete_blob()

Ripristinare gli oggetti eliminati temporaneamente quando è abilitato il controllo delle versioni

Se un account di archiviazione è configurato per abilitare il controllo delle versioni dei BLOB, l'eliminazione di un BLOB fa sì che la versione corrente del BLOB diventi la versione precedente. Per ripristinare un BLOB eliminato temporaneamente quando è abilitato il controllo delle versioni, copiare una versione precedente sul BLOB di base. È possibile usare il metodo seguente:

L'esempio di codice seguente ottiene l'ultima versione di un BLOB eliminato e la ripristina copiandola nel BLOB di base:

def restore_blob_version(self, blob_service_client: BlobServiceClient, container_name: str, blob_name: str):
    container_client = blob_service_client.get_container_client(container=container_name)

    # Get a reference to the soft-deleted base blob and list all the blob versions
    blob_client = container_client.get_blob_client(blob=blob_name)
    blob_list = container_client.list_blobs(name_starts_with=blob_name, include=['deleted','versions'])
    blob_versions = []
    for blob in blob_list:
        blob_versions.append(blob.version_id)
    
    # Get the latest version of the soft-deleted blob
    blob_versions.sort(reverse=True)
    latest_version = blob_versions[0]

    # Build the blob URI and add the version ID as a query string
    versioned_blob_url = f"{blob_client.url}?versionId={latest_version}"

    # Restore the latest version by copying it to the base blob
    blob_client.start_copy_from_url(versioned_blob_url)

Eliminare un BLOB in modo asincrono

La libreria client di Archiviazione BLOB di Azure per Python supporta l'eliminazione asincrona di un BLOB. Per altre informazioni sui requisiti di configurazione del progetto, vedere Programmazione asincrona.

Seguire questa procedura per eliminare un 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 elimina il BLOB. Si noti che solo il client di primo livello deve usare async with, poiché gli altri client creati da esso 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.delete_blob(blob_service_client, "sample-container", "sample-blob.txt")

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

  3. Aggiungere il codice per eliminare il BLOB. Il codice è uguale a quello dell'esempio sincrono, ad eccezione del fatto che il metodo viene dichiarato con la parola chiave async e che quando si chiama il metodo delete_blob viene usata la parola chiave await.

    async def delete_blob(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)
    await blob_client.delete_blob()

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 eliminare BLOB e ripristinare i BLOB eliminati con la libreria client di Archiviazione BLOB di Azure per Python, vedere le risorse seguenti.

Operazioni dell'API REST

Azure SDK per Python contiene librerie basate sull'API REST di Azure, che consentono di interagire con le operazioni dell'API REST tramite paradigmi Python noti. I metodi della libreria client per eliminare i BLOB e ripristinare i BLOB eliminati usano le operazioni API REST seguenti:

Esempi di codice

Risorse per la libreria client

Vedi anche