Come usare l'archiviazione tabelle in Python

Suggerimento

Il contenuto in questo articolo si applica all'archivio tabelle Basic originale di Azure. Tuttavia, è ora disponibile un'offerta Premium per l'archivio tabelle di Azure in anteprima pubblica che include tabelle con ottimizzazione per la velocità effettiva, distribuzione globale e indici secondari automatici. Per altre informazioni e per provare la nuova esperienza Premium, vedere Azure Cosmos DB: API di tabella. Il linguaggio di programmazione usato in questo articolo non è ancora supportato nell'offerta Premium, ma verrà aggiunto in futuro.

Questa guida illustra come eseguire scenari comuni di archiviazione tabelle di Azure in Python usando l'SDK di Archiviazione di Microsoft Azure per Python. Gli scenari presentati includono la creazione e l'eliminazione di una tabella, oltre che l'inserimento di entità e l'esecuzione di query sulle entità.

Mentre si lavora agli scenari di questa esercitazione, è possibile vedere le informazioni di riferimento sull'API dell'SDK di Archiviazione di Azure per Python.

Informazioni sul Servizio tabelle

Il servizio di archiviazione tabelle di Azure consente di archiviare grandi quantità di dati strutturati. Il servizio è un datastore NoSQL che accetta chiamate autenticate dall'interno e dall'esterno del cloud di Azure. Le tabelle di Azure sono ideali per l'archiviazione di dati strutturati non relazionali. Di seguito sono riportati gli utilizzi più comuni per il servizio tabelle.

  • Archiviazione di terabyte di dati strutturati in grado di servire applicazioni su scala Web
  • Archiviazione di set di dati che non richiedono join complessi, chiavi esterne o stored procedure e che possono essere denormalizzati per l'accesso rapido
  • Esecuzione rapida di query sui dati mediante un indice cluster
  • Accesso ai dati tramite il protocollo OData e query LINQ con librerie .NET WCF Data Service

È possibile utilizzare il servizio tabelle per archiviare e interrogare grandi set di dati strutturati non relazionali, con tabelle scalabili in base all'aumento della domanda

Concetti del servizio tabelle

Il servizio tabelle contiene i componenti seguenti:

Diagramma dei componenti del servizio tabelle

  • Formato dell'URL: il codice fa riferimento alle tabelle in un account usando il formato di indirizzo seguente:
    http://<storage account>.table.core.windows.net/<table>

    È possibile fare riferimento direttamente alle tabelle di Azure utilizzando questo indirizzo con il protocollo OData. Per altre informazioni, vedere OData.org.

  • Account di archiviazione: l'accesso ad Archiviazione di Azure viene eseguito esclusivamente tramite un account di archiviazione. Per informazioni sulla capacità dell'account di archiviazione, vedere Obiettivi di scalabilità e prestazioni per Archiviazione di Azure .
  • Tabella: una tabella è una raccolta di entità. Le tabelle non impongono uno schema sulle entità, pertanto una singola tabella può contenere entità che presentano set di proprietà diversi. Il numero di tabelle che un account di archiviazione può contenere è limitato solo in base al limite di capacità dell'account di archiviazione.
  • Entità: un'entità è un set di proprietà, simile a una riga di database. Un'entità può avere una dimensione massima di 1 MB.
  • Proprietà: una proprietà è una coppia nome-valore. Ogni entità può includere fino a 252 proprietà per l'archiviazione dei dati. Ogni entità dispone inoltre di 3 proprietà di sistema che specificano una chiave di partizione, una chiave di riga e un timestamp. Le entità con la stessa chiave di partizione possono essere interrogate più rapidamente e inserite o aggiornate in operazioni atomiche. La chiave di riga di un'entità ne rappresenta l'identificatore univoco all'interno di una partizione.

Per informazioni sulle proprietà e i tipi di tabelle, vedere Informazioni sul modello di dati del servizio tabelle.

Creare un account di archiviazione di Azure

Il modo più semplice per creare il primo account di archiviazione di Azure consiste nell'usare il portale di Azure. Per altre informazioni, vedere Creare un account di archiviazione.

È anche possibile creare un account di archiviazione di Azure usando Azure PowerShell, l'interfaccia della riga di comando di Azure o la libreria client del provider di risorse di archiviazione per .NET.

Se si preferisce non creare un account di archiviazione in questa fase, è anche possibile usare l'emulatore di archiviazione di Azure per eseguire e testare il codice in un ambiente locale. Per altre informazioni, vedere Usare l'emulatore di archiviazione di Azure per sviluppo e test.

Installare l'SDK di Archiviazione di Azure per Python

Dopo aver creato un account di archiviazione, il passaggio successivo consiste nell'installare l'SDK di Archiviazione di Microsoft Azure per Python. Per informazioni dettagliate sull'installazione dell'SDK, vedere il file README.rst nell'archivio relativo all'SDK di Archiviazione per Python su GitHub.

Creare una tabella

Per usare il servizio tabelle di Azure in Python, è necessario importare il modulo TableService. Poiché si useranno entità tabella, è necessaria anche la classe Entity. Aggiungere il codice seguente nella parte iniziale del file Python per importare entrambi gli elementi:

from azure.storage.table import TableService, Entity

Creare un oggetto TableService passando il nome dell'account di archiviazione e la chiave dell'account. Sostituire myaccount e mykey con il nome e la chiave dell'account e chiamare create_table per creare la tabella in Archiviazione di Azure.

table_service = TableService(account_name='myaccount', account_key='mykey')

table_service.create_table('tasktable')

Aggiungere un'entità a una tabella

Per aggiungere un'entità, creare innanzitutto un oggetto che rappresenta l'entità, quindi passare l'oggetto al metodo TableService.insert_entity. L'oggetto entità può essere un dizionario o un oggetto di tipo Entity e definisce i nomi e i valori delle proprietà dell'entità. Ogni entità deve includere le proprietà PartitionKey e RowKey necessarie, oltre a tutte le altre proprietà definite per l'entità.

Questo esempio crea un oggetto dizionario che rappresenta un'entità e quindi passa l'oggetto al metodo insert_entity per aggiungerlo alla tabella:

task = {'PartitionKey': 'tasksSeattle', 'RowKey': '001', 'description' : 'Take out the trash', 'priority' : 200}
table_service.insert_entity('tasktable', task)

Questo esempio crea un oggetto Entity e quindi lo passa al metodo insert_entity per aggiungerlo alla tabella:

task = Entity()
task.PartitionKey = 'tasksSeattle'
task.RowKey = '002'
task.description = 'Wash the car'
task.priority = 100
table_service.insert_entity('tasktable', task)

PartitionKey e RowKey

È necessario specificare entrambe le proprietà PartitionKey e RowKey per ogni entità. Si tratta degli identificatori univoci delle entità, che insieme formano la chiave primaria di un'entità. È possibile eseguire query usando questi valori in modo molto più rapido rispetto a quanto è possibile fare su qualsiasi altra proprietà dell'entità, perché solo queste proprietà sono indicizzate.

Il servizio tabelle usa PartitionKey per distribuire in modo intelligente le entità della tabella nei nodi di archiviazione. Le entità con la stessa proprietà PartitionKey vengono archiviate nello stesso nodo. RowKey è l'ID univoco dell'entità all'interno della partizione a cui appartiene.

Aggiornare un'entità

Per aggiornare tutti i valori delle proprietà di un'entità, chiamare il metodo update_entity. Questo esempio mostra come sostituire un'entità esistente con una versione aggiornata:

task = {'PartitionKey': 'tasksSeattle', 'RowKey': '001', 'description' : 'Take out the garbage', 'priority' : 250}
table_service.update_entity('tasktable', task)

Se l'entità da aggiornare non esiste già, l'operazione di aggiornamento non riuscirà. Se si vuole archiviare un'entità indipendentemente dal fatto che esista o meno, usare insert_or_replace_entity. Nell'esempio seguente, la prima chiamata sostituirà l'entità esistente. La seconda chiamata inserisce una nuova entità, perché nella tabella non c'è alcuna entità con le proprietà PartitionKey e RowKey specificate.

# Replace the entity created earlier
task = {'PartitionKey': 'tasksSeattle', 'RowKey': '001', 'description' : 'Take out the garbage again', 'priority' : 250}
table_service.insert_or_replace_entity('tasktable', task)

# Insert a new entity
task = {'PartitionKey': 'tasksSeattle', 'RowKey': '003', 'description' : 'Buy detergent', 'priority' : 300}
table_service.insert_or_replace_entity('tasktable', task)
Suggerimento

Il metodo update_entity sostituisce tutte le proprietà e i valori di un'entità esistente e può anche essere usato per rimuovere le proprietà da un'entità esistente. È possibile usare il metodo merge_entity per aggiornare un'entità esistente con i valori delle proprietà nuovi o modificati senza sostituire completamente l'entità.

Modificare più entità

Per garantire l'elaborazione atomica delle richieste da parte del servizio tabelle, è possibile inviare più operazioni insieme in un batch. Usare prima di tutto la classe TableBatch per aggiungere più operazioni a un singolo batch. Chiamare quindi TableService.commit_batch per inviare le operazioni in un'operazione atomica. Tutte le entità da modificare in batch devono trovarsi nella stessa partizione.

Questo esempio aggiunge due entità in un batch:

from azure.storage.table import TableBatch
batch = TableBatch()
task004 = {'PartitionKey': 'tasksSeattle', 'RowKey': '004', 'description' : 'Go grocery shopping', 'priority' : 400}
task005 = {'PartitionKey': 'tasksSeattle', 'RowKey': '005', 'description' : 'Clean the bathroom', 'priority' : 100}
batch.insert_entity(task004)
batch.insert_entity(task005)
table_service.commit_batch('tasktable', batch)

I batch possono essere usati anche con la sintassi di gestione contesto:

task006 = {'PartitionKey': 'tasksSeattle', 'RowKey': '006', 'description' : 'Go grocery shopping', 'priority' : 400}
task007 = {'PartitionKey': 'tasksSeattle', 'RowKey': '007', 'description' : 'Clean the bathroom', 'priority' : 100}

with table_service.batch('tasktable') as batch:
    batch.insert_entity(task006)
    batch.insert_entity(task007)

Eseguire una query su un'entità

Per eseguire una query per un'entità in una tabella, passare le relative proprietà PartitionKey e RowKey al metodo TableService.get_entity.

task = table_service.get_entity('tasktable', 'tasksSeattle', '001')
print(task.description)
print(task.priority)

Eseguire query su un set di entità

È possibile eseguire query per un set di entità specificando una stringa di filtro con il parametro filter. Questo esempio trova tutte le attività di Seattle applicando un filtro a PartitionKey:

tasks = table_service.query_entities('tasktable', filter="PartitionKey eq 'tasksSeattle'")
for task in tasks:
    print(task.description)
    print(task.priority)

Eseguire query su un subset di proprietà di entità

È anche possibile limitare le proprietà restituite per ogni entità in una query. Questa tecnica, denominata proiezione, consente di ridurre la larghezza di banda e di migliorare le prestazioni di query, in particolare per entità o set di risultati di grandi dimensioni. Usare il parametro select e passare i nomi delle proprietà da restituire al client.

La query nel codice seguente restituisce solo le descrizioni delle entità nella tabella.

Nota

Il frammento di codice seguente funziona solo in Archiviazione di Azure. Non è supportato dall'emulatore di archiviazione.

tasks = table_service.query_entities('tasktable', filter="PartitionKey eq 'tasksSeattle'", select='description')
for task in tasks:
    print(task.description)

Eliminare un'entità

Eliminare un'entità passando le relative proprietà PartitionKey e RowKey al metodo delete_entity.

table_service.delete_entity('tasktable', 'tasksSeattle', '001')

Eliminare una tabella

Se una tabella o una delle entità al suo interno non è più necessaria, chiamare il metodo delete_table per eliminare definitivamente la tabella da Archiviazione di Azure.

table_service.delete_table('tasktable')

Passaggi successivi