Avvio rapido: Gestire i BLOB con Python v2.1 SDK

In questo argomento di avvio rapido viene illustrato come gestire i BLOB con Python. I BLOB sono oggetti che possono contenere grandi quantità di dati di testo o binari, tra cui immagini, documenti, flussi multimediali e dati di archiviazione. Verranno caricati, scaricati ed elencati i BLOB e verranno creati ed eliminati i contenitori.

Nota

In questo argomento di avvio rapido si usa una versione legacy della libreria client di Archiviazione BLOB di Azure. Per un'introduzione alla versione più recente, vedere Avvio rapido: Gestire i BLOB con Python v12 SDK.

Prerequisiti

Scaricare l'applicazione di esempio

L'applicazione di esempio in questa guida rapida è un'applicazione Python di base.

Usare il comando git seguente per scaricare l'applicazione nell'ambiente di sviluppo.

git clone https://github.com/Azure-Samples/storage-blobs-python-quickstart.git 

Per esaminare il programma Python, aprire il file example.py nella radice del repository.

Copiare le credenziali dal portale di Azure

L'applicazione di esempio deve autorizzare l'accesso all'account di archiviazione. Fornire all'applicazione le credenziali dell'account di archiviazione sotto forma di stringa di connessione. Per visualizzare le credenziali dell'account di archiviazione:

  1. Nel portale di Azure passare all'account di archiviazione.

  2. Nella sezione Impostazioni della panoramica dell'account di archiviazione selezionare Chiavi di accesso per visualizzare le chiavi di accesso e la stringa di connessione dell'account.

  3. Prendere nota del nome dell'account di archiviazione, che sarà necessario per l'autorizzazione.

  4. Trovare il valore Chiave in key1 e selezionare Copia per copiare la chiave dell'account.

    Screenshot showing how to copy your account key from the Azure portal

Configurare la stringa di connessione di archiviazione

Nell'applicazione, inserire il nome dell'account di archiviazione e la chiave dell'account per creare un oggetto BlockBlobService.

  1. Aprire il file example.py da Esplora soluzioni nell'IDE.

  2. Sostituire i valori accountname e accountkey con il nome e la chiave dell'account di archiviazione:

    block_blob_service = BlockBlobService(
        account_name='accountname', account_key='accountkey')
    
  3. Salvare e chiudere il file.

Eseguire l'esempio

Il programma di esempio consente di creare un file di test nella cartella Documenti, caricare il file nell'archiviazione BLOB, elencare i BLOB nel file e quindi scaricare il file con un nuovo nome.

  1. Installare le dipendenze:

    pip install azure-storage-blob==2.1.0
    
  2. Passare all'applicazione di esempio:

    cd storage-blobs-python-quickstart
    
  3. Eseguire l'esempio:

    python example.py
    

    Verranno visualizzati messaggi simili all'output seguente:

    Temp file = C:\Users\azureuser\Documents\QuickStart_9f4ed0f9-22d3-43e1-98d0-8b2c05c01078.txt
    
    Uploading to Blob storage as blobQuickStart_9f4ed0f9-22d3-43e1-98d0-8b2c05c01078.txt
    
    List blobs in the container
             Blob name: QuickStart_9f4ed0f9-22d3-43e1-98d0-8b2c05c01078.txt
    
    Downloading blob to     C:\Users\azureuser\Documents\QuickStart_9f4ed0f9-22d3-43e1-98d0-8b2c05c01078_DOWNLOADED.txt
    
  4. Prima di continuare, controllare che nella cartella Documenti siano presenti due file.

    • QuickStart_<universally-unique-identifier>
    • QuickStart_<universally-unique-identifier>_DOWNLOADED
  5. È possibile aprirli e vedere che sono identici.

    È anche possibile usare uno strumento come Azure Storage Explorer per visualizzare i file nell'archivio BLOB. Azure Storage Explorer è uno strumento multipiattaforma gratuito che consente di accedere alle informazioni dell'account di archiviazione.

  6. Dopo aver esaminato i file, premere un tasto qualsiasi per terminare la demo ed eliminare i file di test.

Informazioni sul codice di esempio

Ora che si conosce il risultato dell'esempio, aprire il file example.py per esaminare il codice.

Ottenere i riferimenti agli oggetti di archiviazione

In questa sezione si creano istanze degli oggetti, si crea un nuovo contenitore e quindi si impostano le autorizzazioni nel contenitore in modo che i BLOB siano pubblici. Si chiamerà il contenitore quickstartblobs.

# Create the BlockBlockService that the system uses to call the Blob service for the storage account.
block_blob_service = BlockBlobService(
    account_name='accountname', account_key='accountkey')

# Create a container called 'quickstartblobs'.
container_name = 'quickstartblobs'
block_blob_service.create_container(container_name)

# Set the permission so the blobs are public.
block_blob_service.set_container_acl(
    container_name, public_access=PublicAccess.Container)

Prima di tutto, creare i riferimenti agli oggetti usati per accedere all'archivio BLOB e gestirlo. Questi oggetti si compilano a vicenda: ognuno di essi viene usato da quello successivo nell'elenco.

  • Creare un'istanza dell'oggetto BlockBlobService che punti al servizio BLOB nell'account di archiviazione.

  • Creare un'istanza dell'oggetto CloudBlobContainer che rappresenti il contenitore a cui si accede. Per organizzare i BLOB, il sistema usa i contenitori in modo analogo a come si usano le cartelle nel computer per organizzare i file.

Una volta creato il contenitore cloud di BLOB, creare un'istanza dell'oggetto CloudBlockBlob che punta allo specifico BLOB a cui è interessati. È possibile quindi caricare, scaricare e copiare il BLOB in base alle proprie esigenze.

Importante

I nomi dei contenitori devono essere in minuscolo. Per altre informazioni sui nomi di contenitori e BLOB, vedere Naming and Referencing Containers, Blobs, and Metadata (Denominazione e riferimento a contenitori, BLOB e metadati).

Caricare i BLOB nel contenitore

L'archiviazione BLOB supporta BLOB in blocchi, BLOB di aggiunta e BLOB di pagine. I BLOB in blocchi possono avere dimensioni pari a 4,7 TB e possono essere qualsiasi tipo di file, da fogli di calcolo di Excel ai file video di grandi dimensioni. È possibile usare i BLOB di accodamento per la registrazione quando si vuole scrivere in un file e quindi continuare ad aggiungere altre informazioni. I BLOB di pagine vengono usati principalmente per i file di disco rigido virtuale che supportano le macchine virtuali dell'infrastruttura distribuita come servizio (IaaS). I BLOB in blocchi sono i BLOB usati più frequentemente. In questa guida di avvio rapido si usano i BLOB in blocchi.

Per caricare un file in un BLOB, ottenere il percorso completo del file unendo il nome della directory con il nome del file nell'unità locale. È quindi possibile caricare il file nel percorso specificato con il metodo create_blob_from_path.

Il codice di esempio crea un file locale che viene usato dal sistema per il caricamento e il download, archiviando il file caricato dal sistema come full_path_to_file e il nome del BLOB come local_file_name. In questo esempio il file viene caricato in un contenitore denominato quickstartblobs:

# Create a file in Documents to test the upload and download.
local_path = os.path.expanduser("~\Documents")
local_file_name = "QuickStart_" + str(uuid.uuid4()) + ".txt"
full_path_to_file = os.path.join(local_path, local_file_name)

# Write text to the file.
file = open(full_path_to_file, 'w')
file.write("Hello, World!")
file.close()

print("Temp file = " + full_path_to_file)
print("\nUploading to Blob storage as blob" + local_file_name)

# Upload the created file, use local_file_name for the blob name.
block_blob_service.create_blob_from_path(
    container_name, local_file_name, full_path_to_file)

Esistono diversi metodi di caricamento che è possibile usare con l'archiviazione BLOB. Nel caso di un flusso di memoria, ad esempio, è possibile usare il metodo create_blob_from_stream anziché il metodo create_blob_from_path.

Elencare i BLOB in un contenitore

Il codice seguente crea un generator per il metodo list_blobs. Il codice scorre l'elenco di BLOB nel contenitore e stampa i relativi nomi nella console.

# List the blobs in the container.
print("\nList blobs in the container")
generator = block_blob_service.list_blobs(container_name)
for blob in generator:
    print("\t Blob name: " + blob.name)

Scaricare i BLOB

Scaricare i BLOB nel disco locale usando il metodo get_blob_to_path. Il codice seguente consente di scaricare il BLOB caricato in precedenza. Il sistema aggiunge il suffisso _DOWNLOADED al nome del BLOB in modo da poter visualizzare entrambi i file nel disco locale.

# Download the blob(s).
# Add '_DOWNLOADED' as prefix to '.txt' so you can see both files in Documents.
full_path_to_file2 = os.path.join(local_path, local_file_name.replace(
   '.txt', '_DOWNLOADED.txt'))
print("\nDownloading blob to " + full_path_to_file2)
block_blob_service.get_blob_to_path(
    container_name, local_file_name, full_path_to_file2)

Pulire le risorse

Se i BLOB caricati in questa guida rapida non sono più necessari, è possibile eliminare l'intero contenitore usando il metodo delete_container. Per eliminare singoli file, usare invece il metodo delete_blob.

# Clean up resources. This includes the container and the temp files.
block_blob_service.delete_container(container_name)
os.remove(full_path_to_file)
os.remove(full_path_to_file2)

Risorse per lo sviluppo di applicazioni Python con BLOB

Per altre informazioni sullo sviluppo di applicazioni Python con Archiviazione BLOB, vedere le risorse aggiuntive seguenti:

File binari e codice sorgente

Informazioni di riferimento ed esempi relativi alla libreria client

Passaggi successivi

In questa guida introduttiva si è appreso come trasferire file tra il disco locale e un archivio BLOB di Azure con Python.

Per altre informazioni su Azure Storage Explorer e i BLOB, vedere Gestire le risorse di archiviazione BLOB di Azure con Storage Explorer.