Guida introduttiva: libreria client Archiviazione BLOB di Azure per Python

Introduzione alla libreria client Archiviazione BLOB di Azure per Python per gestire BLOB e contenitori. Seguire questa procedura per installare il pacchetto e provare il codice di esempio per le attività di base in un'app console interattiva.

Esempi di codice sorgente | della libreria della documentazione | di riferimento dell'API (PyPi) | Samples

Questo video illustra come iniziare a usare la libreria client Archiviazione BLOB di Azure per Python.

I passaggi del video sono descritti anche nelle sezioni seguenti.

Prerequisiti

• Account Azure con una sottoscrizione attiva: creare gratuitamente un account
• Account di archiviazione di Azure: creare un account di archiviazione
• Python 3.8+

Configurazione

Questa sezione illustra come preparare un progetto da usare con la libreria client Archiviazione BLOB di Azure per Python.

Creare il progetto

Creare un'applicazione Python denominata blob-quickstart.

1. In una finestra della console, ad esempio PowerShell o Bash, creare una nuova directory per il progetto:

   mkdir blob-quickstart
   

2. Passare alla directory blob-quickstart appena creata:

   cd blob-quickstart
   

Installare i pacchetti

Nella directory del progetto installare i pacchetti per le librerie client di Archiviazione BLOB di Azure e Azure Identity usando il pip install comando . Il pacchetto azure-identity è necessario per le connessioni senza password ai servizi di Azure.

pip install azure-storage-blob azure-identity

Configurare il framework dell'app

Nella directory del progetto seguire la procedura per creare la struttura di base dell'app:

1. Aprire un nuovo file di testo nell'editor di codice.
2. Aggiungere import istruzioni, creare la struttura per il programma e includere la gestione delle eccezioni di base, come illustrato di seguito.
3. Salvare il nuovo file come blob_quickstart.py nella directory blob-quickstart .

import os, uuid
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient

try:
    print("Azure Blob Storage Python quickstart sample")

    # Quickstart code goes here

except Exception as ex:
    print('Exception:')
    print(ex)

Modello a oggetti

Il servizio Archiviazione BLOB di Azure è ottimizzato per archiviare enormi quantità di dati non strutturati. I dati non strutturati sono dati che non seguono una definizione o un modello di dati specifico, ad esempio dati di testo o binari. L'archiviazione BLOB offre tre tipi di risorse:

• L'account di archiviazione
• Un contenitore nell'account di archiviazione
• Un oggetto BLOB in un contenitore

Il diagramma seguente illustra la relazione tra queste risorse:

Per interagire con queste risorse, usare le classi Python seguenti:

• BlobServiceClient: la BlobServiceClient classe consente di modificare Archiviazione di Azure risorse e contenitori BLOB.
• ContainerClient: la ContainerClient classe consente di modificare Archiviazione di Azure contenitori e i relativi BLOB.
• BlobClient: la BlobClient classe consente di modificare Archiviazione di Azure BLOB.

Esempi di codice

Questi frammenti di codice di esempio illustrano come eseguire le attività seguenti con la libreria client Archiviazione BLOB di Azure per Python:

• Eseguire l'autenticazione in Azure e autorizzare l'accesso ai dati BLOB
• Creare un contenitore
• Caricare BLOB in un contenitore
• Elencare i BLOB in un contenitore
• Scaricare BLOB
• Eliminare un contenitore

Eseguire l'autenticazione in Azure e autorizzare l'accesso ai dati BLOB

Le richieste dell'applicazione a Archiviazione BLOB di Azure devono essere autorizzate. L'uso della DefaultAzureCredential classe fornita dalla libreria client di Identità di Azure è l'approccio consigliato per l'implementazione di connessioni senza password ai servizi di Azure nel codice, incluso l'Archiviazione BLOB.

È anche possibile autorizzare le richieste di Archiviazione BLOB di Azure usando la chiave di accesso dell'account. Tuttavia, questo approccio deve essere usato con cautela. Gli sviluppatori devono essere diligenti per non esporre mai la chiave di accesso in una posizione non sicura. Chiunque abbia la chiave di accesso è in grado di autorizzare le richieste all'account di archiviazione e può accedere in modo efficace a tutti i dati. DefaultAzureCredential offre vantaggi di gestione e sicurezza migliorati rispetto alla chiave dell'account per consentire l'autenticazione senza password. Entrambe le opzioni sono illustrate nell'esempio seguente.

az storage account show --resource-group '<your-resource-group-name>' --name '<your-storage-account-name>' --query id

az role assignment create --assignee "<user@domain>" \
    --role "Storage Blob Data Contributor" \
    --scope "<your-resource-id>"

Get-AzResource -ResourceGroupName "<yourResourceGroupname>" -Name "<yourStorageAccountName>"

New-AzRoleAssignment -SignInName <user@domain> `
    -RoleDefinitionName "Storage Blob Data Contributor" `
    -Scope <yourStorageAccountId>

az storage account show-connection-string --name "<your-storage-account-name>"

$saName = "yourStorageAccountName"
$rgName = "yourResourceGroupName"
$sa = Get-AzStorageAccount -StorageAccountName $saName -ResourceGroupName $rgName

$saKey = (Get-AzStorageAccountKey -ResourceGroupName $rgName -Name $saName)[0].Value

'DefaultEndpointsProtocol=https;AccountName=' + $saName + ';AccountKey=' + $saKey + ';EndpointSuffix=core.windows.net'

setx AZURE_STORAGE_CONNECTION_STRING "<yourconnectionstring>"

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

# Retrieve the connection string for use with the application. The storage
# connection string is stored in an environment variable on the machine
# running the application called AZURE_STORAGE_CONNECTION_STRING. If the environment variable is
# created after the application is launched in a console or with Visual Studio,
# the shell or application needs to be closed and reloaded to take the
# environment variable into account.
connect_str = os.getenv('AZURE_STORAGE_CONNECTION_STRING')

# Create the BlobServiceClient object
blob_service_client = BlobServiceClient.from_connection_string(connect_str)

Creazione di un contenitore

Decidere un nome per il nuovo contenitore. Il codice seguente aggiunge un valore UUID al nome del contenitore per assicurarsi che sia univoco.

Chiamare il metodo create_container per creare effettivamente il contenitore nell'account di archiviazione.

Aggiungere questo codice alla fine del blocco try:

# Create a unique name for the container
container_name = str(uuid.uuid4())

# Create the container
container_client = blob_service_client.create_container(container_name)

Per altre informazioni sulla creazione di un contenitore e per esplorare altri esempi di codice, vedere Creare un contenitore BLOB con Python.

Caricare BLOB in un contenitore

Il frammento di codice seguente consente di:

1. Crea una directory locale per contenere i file di dati.
2. Creare un file di testo nella directory locale.
3. Ottenere un riferimento a un oggetto BlobClient chiamando il metodo get_blob_client su BlobServiceClient dalla sezione Creare un contenitore.
4. Caricare il file di testo locale nel BLOB chiamando il metodo upload_blob.

Aggiungere questo codice alla fine del blocco try:

# Create a local directory to hold blob data
local_path = "./data"
os.mkdir(local_path)

# Create a file in the local data directory to upload and download
local_file_name = str(uuid.uuid4()) + ".txt"
upload_file_path = os.path.join(local_path, local_file_name)

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

# Create a blob client using the local file name as the name for the blob
blob_client = blob_service_client.get_blob_client(container=container_name, blob=local_file_name)

print("\nUploading to Azure Storage as blob:\n\t" + local_file_name)

# Upload the created file
with open(file=upload_file_path, mode="rb") as data:
    blob_client.upload_blob(data)

Per altre informazioni sul caricamento di BLOB e per esplorare altri esempi di codice, vedere Caricare un BLOB con Python.

Elencare i BLOB in un contenitore

Elencare i BLOB presenti nel contenitore chiamando il metodo list_blobs. In questo caso, al contenitore è stato aggiunto un unico BLOB, quindi l'operazione di recupero dell'elenco restituisce solo tale BLOB.

Aggiungere questo codice alla fine del blocco try:

print("\nListing blobs...")

# List the blobs in the container
blob_list = container_client.list_blobs()
for blob in blob_list:
    print("\t" + blob.name)

Per altre informazioni sull'elenco dei BLOB e per esplorare altri esempi di codice, vedere Elencare i BLOB con Python.

Scaricare BLOB

Scaricare il BLOB creato in precedenza chiamando il metodo download_blob. Il codice di esempio aggiunge il suffisso "DOWNLOAD" al nome del file in modo da consentire la visualizzazione di entrambi i file nel file system locale.

Aggiungere questo codice alla fine del blocco try:

# Download the blob to a local file
# Add 'DOWNLOAD' before the .txt extension so you can see both files in the data directory
download_file_path = os.path.join(local_path, str.replace(local_file_name ,'.txt', 'DOWNLOAD.txt'))
container_client = blob_service_client.get_container_client(container= container_name) 
print("\nDownloading blob to \n\t" + download_file_path)

with open(file=download_file_path, mode="wb") as download_file:
 download_file.write(container_client.download_blob(blob.name).readall())

Per altre informazioni sul download di BLOB e per esplorare altri esempi di codice, vedere Scaricare un BLOB con Python.

Eliminare un contenitore

Il codice seguente pulisce le risorse create dall'app rimuovendo l'intero contenitore usando il metodo delete_container . È anche possibile eliminare i file locali, se si vuole.

L'app viene sospesa per l'input dell'utente chiamando input() prima dell'eliminazione di BLOB, contenitore e file locali. Verificare che le risorse siano state create correttamente prima dell'eliminazione.

Aggiungere questo codice alla fine del blocco try:

# Clean up
print("\nPress the Enter key to begin clean up")
input()

print("Deleting blob container...")
container_client.delete_container()

print("Deleting the local source and downloaded files...")
os.remove(upload_file_path)
os.remove(download_file_path)
os.rmdir(local_path)

print("Done")

Per altre informazioni sull'eliminazione di un contenitore e per esplorare altri esempi di codice, vedere Eliminare e ripristinare un contenitore BLOB con Python.

Eseguire il codice

Questa app crea un file di test nella cartella locale e lo carica in Archiviazione BLOB di Azure. L'esempio elenca quindi i BLOB nel contenitore e scarica il file con un nuovo nome. È possibile confrontare i file vecchi e nuovi.

Passare alla directory contenente il file blob_quickstart.py , quindi eseguire il comando seguente python per eseguire l'app:

python blob_quickstart.py

L'output dell'app è simile all'esempio seguente (i valori UUID omessi per la leggibilità):

Azure Blob Storage Python quickstart sample

Uploading to Azure Storage as blob:
        quickstartUUID.txt

Listing blobs...
        quickstartUUID.txt

Downloading blob to
        ./data/quickstartUUIDDOWNLOAD.txt

Press the Enter key to begin clean up

Deleting blob container...
Deleting the local source and downloaded files...
Done

Prima di iniziare il processo di pulizia, controllare la cartella dei dati per i due file. È possibile confrontarli e osservare che sono identici.

Pulire le risorse

Dopo aver verificato i file e aver completato il test, premere INVIO per eliminare i file di test insieme al contenitore creato nell'account di archiviazione. È anche possibile usare l'interfaccia della riga di comando di Azure per eliminare le risorse.

Passaggi successivi

In questo avvio rapido si è appreso come caricare, scaricare ed elencare i BLOB con Python.

Per visualizzare le app di esempio di Archiviazione BLOB, procedere con:

• Per altre informazioni, vedere le librerie client Archiviazione BLOB di Azure per Python.
• Per esercitazioni, esempi, guide di avvio rapido e altre documentazioni, vedere Azure per sviluppatori Python.