Come usare l'archiviazione tabelle di Azure da Ruby

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.

Panoramica

Questa guida illustra come eseguire scenari comuni con il servizio tabelle di Azure. Gli esempi sono scritti utilizzando l'API Ruby. Gli scenari presentati includono creazione ed eliminazione di una tabella, inserimento di entità ed esecuzione di query sulle entità in una tabella.

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.

Creare un'applicazione Ruby

Per istruzioni su come creare un'applicazione Ruby, vedere Ruby on Rails Web application on an Azure VM (Applicazione Web Ruby on Rails in una VM di Azure).

Configurare l'applicazione per l'accesso all'archiviazione

Per usare l'archiviazione di Azure, è necessario scaricare e usare il pacchetto Ruby Azure, che comprende un set di pratiche librerie che comunicano con i servizi di archiviazione REST.

Utilizzare RubyGems per ottenere il pacchetto

  1. Usare un'interfaccia della riga di comando, ad esempio PowerShell (Windows), Terminal (Mac) o Bash (Unix).
  2. Digitare gem install azure nella finestra di comando per installare la gemma e le dipendenze.

Importare il pacchetto

Usando l'editor di testo preferito aggiungere quanto segue alla parte superiore del file Ruby dove si intende usare l'archiviazione:

require "azure"

Configurare una connessione di archiviazione di Azure

Il modulo di Azure leggerà le variabili di ambiente AZURE_STORAGE_ACCOUNT e AZURE_STORAGE_ACCESS_KEY per ottenere le informazioni necessarie per la connessione all'account di archiviazione di Azure. Se queste variabili di ambiente non sono impostate, sarà necessario specificare le informazioni relative all'account prima di utilizzare Azure::TableService con il codice seguente:

Azure.config.storage_account_name = "<your azure storage account>"
Azure.config.storage_access_key = "<your azure storage access key>"

Per ottenere questi valori da un account di archiviazione classico o di Resource Manager nel portale di Azure:

  1. Accedere al Portale di Azure.
  2. Passare all'account di archiviazione che si desidera utilizzare.
  3. Nel pannello Impostazioni a destra fare clic su Chiavi di accesso.
  4. Nel pannello Chiavi di accesso visualizzato notare la chiave di accesso 1 e la chiave di accesso 2. È possibile usare una di queste indifferentemente.
  5. Fare clic sull'icona Copia per copiare la chiave negli Appunti.

Per ottenere questi valori da un account di archiviazione classico nel portale di Azure classico:

  1. Accedere al portale di Azure classico.
  2. Passare all'account di archiviazione che si desidera utilizzare.
  3. Fare clic su GESTISCI CHIAVI DI ACCESSO nella parte inferiore del riquadro di spostamento.
  4. Nella finestra di dialogo popup saranno visualizzati il nome dell'account di archiviazione, la chiave di accesso primaria e la chiave di accesso secondaria. Per la chiave di accesso è possibile usare sia la chiave primaria che secondaria.
  5. Fare clic sull'icona Copia per copiare la chiave negli Appunti.

Creare una tabella

L'oggetto Azure::TableService consente di utilizzare tabelle ed entità. Per creare una tabella, usare il metodo create_table(). Nell'esempio seguente viene creata una tabella o stampato l'eventuale errore.

azure_table_service = Azure::TableService.new
begin
    azure_table_service.create_table("testtable")
rescue
    puts $!
end

Aggiungere un'entità a una tabella

Per aggiungere un'entità, creare innanzitutto un oggetto hash che definisca le proprietà dell'entità. Si noti che per ogni entità è necessario specificare un oggetto PartitionKey e un oggetto RowKey. Si tratta di identificatori univoci dell'entità e sono valori che possono essere interrogati molto più velocemente di altre proprietà. Archiviazione Azure utilizza PartitionKey per distribuire automaticamente le entità della tabella su molti nodi di archiviazione. Le entità con lo stesso oggetto PartitionKey vengono archiviate nello stesso nodo. RowKey è l'ID univoco dell'entità all'interno della partizione cui appartiene.

entity = { "content" => "test entity",
    :PartitionKey => "test-partition-key", :RowKey => "1" }
azure_table_service.insert_entity("testtable", entity)

Aggiornare un'entità

Esistono vari metodi per aggiornare un'entità esistente:

  • update_entity(): aggiorna un'entità esistente sostituendola.
  • merge_entity(): aggiorna un'entità esistente unendovi i nuovi valori delle proprietà.
  • insert_or_merge_entity(): aggiorna un'entità esistente sostituendola. Se non esiste alcuna entità, ne verrà inserita una nuova:
  • insert_or_replace_entity(): aggiorna un'entità esistente unendovi i nuovi valori delle proprietà. Se non esiste alcuna entità, ne verrà inserita una nuova.

Nell'esempio seguente viene dimostrato l'aggiornamento di un'entità mediante l'uso di update_entity():

entity = { "content" => "test entity with updated content",
    :PartitionKey => "test-partition-key", :RowKey => "1" }
azure_table_service.update_entity("testtable", entity)

Con update_entity() e merge_entity(), se l'entità che si sta aggiornando non esiste, l'operazione di aggiornamento avrà esito negativo. Se pertanto si desidera archiviare un'entità indipendentemente dal fatto che esista o meno, è necessario usare insert_or_replace_entity() oppure insert_or_merge_entity().

Usare i gruppi di entità

È talvolta consigliabile inviare più operazioni in un batch per garantire l'elaborazione atomica da parte del server. A tale scopo, è necessario prima creare un oggetto Batch e quindi usare il metodo execute_batch() su TableService. Nell'esempio seguente viene dimostrato l'invio di due entità con RowKey 2 e 3 in un batch: Si noti che funziona solo per le entità con lo stesso oggetto PartitionKey.

azure_table_service = Azure::TableService.new
batch = Azure::Storage::Table::Batch.new("testtable",
    "test-partition-key") do
    insert "2", { "content" => "new content 2" }
    insert "3", { "content" => "new content 3" }
end
results = azure_table_service.execute_batch(batch)

Eseguire una query su un'entità

Per eseguire una query su un'entità in una tabella, usare il metodo get_entity() passando il nome tabella e i parametri PartitionKey e RowKey.

result = azure_table_service.get_entity("testtable", "test-partition-key",
    "1")

Eseguire query su un set di entità

Per eseguire query su un set di entità in una tabella, creare un oggetto hash di query e usare il metodo query_entities(). Nell'esempio seguente viene dimostrato l'invio di tutte le entità con lo stesso oggetto PartitionKey:

query = { :filter => "PartitionKey eq 'test-partition-key'" }
result, token = azure_table_service.query_entities("testtable", query)
Nota

Se il risultato impostato è troppo grande affinché sia restituito da un'unica query, verrà restituito un token di continuazione per recuperare le pagine successive.

Eseguire query su un subset di proprietà di entità

Mediante una query su una tabella è possibile recuperare solo alcune proprietà da un'entità. Questa tecnica, denominata "proiezione", consente di ridurre la larghezza di banda e di migliorare le prestazioni della query, in particolare per entità di grandi dimensioni. Utilizzare la clausola select e passare i nomi delle proprietà da inoltrare al client.

query = { :filter => "PartitionKey eq 'test-partition-key'",
    :select => ["content"] }
result, token = azure_table_service.query_entities("testtable", query)

Eliminare un'entità

Per eliminare un'entità, usare il metodo delete_entity(). È necessario passare il nome della tabella contenente l'entità e i parametri PartitionKey e RowKey dell'entità.

azure_table_service.delete_entity("testtable", "test-partition-key", "1")

Eliminare una tabella

Per eliminare una tabella, usare il metodo delete_table() e passare il nome della tabella che si desidera eliminare.

azure_table_service.delete_table("testtable")

Passaggi successivi