Come usare l'archiviazione tabelle di Azure o l'API Tabelle di Azure Cosmos DB da Node.jsHow to use Azure Table storage or the Azure Cosmos DB Table API from Node.js

Suggerimento

Il contenuto di questo articolo è applicabile al servizio di archiviazione tabelle di Azure e all'API Tabelle di Azure Cosmos DB.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. L'API Tabelle di Azure Cosmos DB è un'offerta Premium per il servizio di archiviazione tabelle, che include tabelle con ottimizzazione per la velocità effettiva, distribuzione globale e indici secondari automatici.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

PanoramicaOverview

Questo articolo mostra come eseguire scenari comuni usando il servizio di archiviazione tabelle di Azure o Azure Cosmos DB in un'applicazione Node.js.This article shows how to perform common scenarios using Azure Storage Table service or Azure Cosmos DB in a Node.js application.

Creare un account del servizio di AzureCreate an Azure service account

È possibile usare tabelle con l'archiviazione tabelle di Azure o con Azure Cosmos DB.You can work with tables using Azure Table storage or Azure Cosmos DB. Per altre informazioni sulle differenze tra i servizi, vedere Offerte per tabelle.You can learn more about the differences between the services by reading Table offerings. Sarà necessario creare un account per il servizio che si intende usare.You'll need to create an account for the service you're going to use.

Creare un account di archiviazione di AzureCreate an Azure storage account

Il modo più semplice per creare il primo account di archiviazione di Azure consiste nell'usare il portale di Azure.The easiest way to create your first Azure storage account is by using the Azure portal. Per altre informazioni, vedere Creare un account di archiviazione.To learn more, see Create a storage account.

È possibile anche creare un account di archiviazione di Azure usando Azure PowerShell o l'interfaccia della riga di comando di Azure.You can also create an Azure storage account by using Azure PowerShell or Azure CLI.

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.If you prefer not to create a storage account at this time, you can also use the Azure storage emulator to run and test your code in a local environment. Per altre informazioni, vedere Usare l'emulatore di archiviazione di Azure per sviluppo e test.For more information, see Use the Azure Storage Emulator for Development and Testing.

Creare un account per l'API di tabella di Azure Cosmos DBCreate an Azure Cosmos DB Table API account

Per istruzioni per la creazione di un account per l'API di tabella di Azure Cosmos DB, vedere Creare un account per un'API di tabella.For instructions on creating an Azure Cosmos DB Table API account, see Create a Table API account.

Configurare l'applicazione per accedere ad archiviazione di Azure o all'API Tabelle di Azure Cosmos DBConfigure your application to access Azure Storage or the Azure Cosmos DB Table API

Per usare Archiviazione di Azure o Azure Cosmos DB, è necessario disporre di Azure Storage SDK per Node.js, in cui è incluso un set di pratiche librerie che comunicano con i servizi di archiviazione REST.To use Azure Storage or Azure Cosmos DB, you need the Azure Storage SDK for Node.js, which includes a set of convenience libraries that communicate with the Storage REST services.

Usare Node Package Manager (NPM) per installare il pacchettoUse Node Package Manager (NPM) to install the package

  1. Usare un'interfaccia della riga di comando come PowerShell (Windows), Terminale (Mac) o Bash (Unix) e passare alla cartella in cui è stata creata l'applicazione.Use a command-line interface such as PowerShell (Windows), Terminal (Mac), or Bash (Unix), and navigate to the folder where you created your application.

  2. Digitare npm install azure-storage nella finestra di comando.Type npm install azure-storage in the command window. L'output da questo comando sarà simile al seguente esempio:Output from the command is similar to the following example.

    azure-storage@0.5.0 node_modules\azure-storage
    +-- extend@1.2.1
    +-- xmlbuilder@0.4.3
    +-- mime@1.2.11
    +-- node-uuid@1.4.3
    +-- validator@3.22.2
    +-- underscore@1.4.4
    +-- readable-stream@1.0.33 (string_decoder@0.10.31, isarray@0.0.1, inherits@2.0.1, core-util-is@1.0.1)
    +-- xml2js@0.2.7 (sax@0.5.2)
    +-- request@2.57.0 (caseless@0.10.0, aws-sign2@0.5.0, forever-agent@0.6.1, stringstream@0.0.4, oauth-sign@0.8.0, tunnel-agent@0.4.1, isstream@0.1.2, json-stringify-safe@5.0.1, bl@0.9.4, combined-stream@1.0.5, qs@3.1.0, mime-types@2.0.14, form-data@0.2.0, http-signature@0.11.0, tough-cookie@2.0.0, hawk@2.3.1, har-validator@1.8.0)
    
  3. È possibile eseguire manualmente il comando ls per verificare che sia stata creata una cartella node_modules.You can manually run the ls command to verify that a node_modules folder was created. All'interno di questa cartella si trova il pacchetto azure-storage , che contiene le librerie necessarie per accedere all'archiviazione.Inside that folder you will find the azure-storage package, which contains the libraries you need to access storage.

Importare il pacchettoImport the package

Aggiungere il codice seguente all'inizio del file server.js nell'applicazione:Add the following code to the top of the server.js file in your application:

var azure = require('azure-storage');

Aggiungere una connessione ad Archiviazione di AzureAdd an Azure Storage connection

I modulo di Azure legge le variabili di ambiente AZURE_STORAGE_ACCOUNT e AZURE_STORAGE_ACCESS_KEY o AZURE_STORAGE_CONNECTION_STRING per ottenere le informazioni necessarie per la connessione all'account di archiviazione di Azure.The Azure module reads the environment variables AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY, or AZURE_STORAGE_CONNECTION_STRING for information required to connect to your Azure Storage account. Se queste variabili di ambiente non sono impostate, sarà necessario specificare le informazioni relative all'account quando si chiama TableService.If these environment variables are not set, you must specify the account information when calling TableService. Il codice seguente, ad esempio, crea un oggetto TableService:For example, the following code creates a TableService object:

var tableSvc = azure.createTableService('myaccount', 'myaccesskey');

Aggiungere una connessione ad Azure Cosmos DBAdd an Azure Cosmos DB connection

Per aggiungere una connessione ad Azure Cosmos DB, creare un oggetto TableService e specificare il nome dell'account, la chiave primaria e l'endpoint.To add an Azure Cosmos DB connection, create a TableService object and specify your account name, primary key, and endpoint. È possibile copiare questi valori da Impostazioni > Stringa di connessione nel portale di Azure per l'account DB Cosmos.You can copy these values from Settings > Connection String in the Azure portal for your Cosmos DB account. Ad esempio:For example:

var tableSvc = azure.createTableService('myaccount', 'myprimarykey', 'myendpoint');

Creare una tabellaCreate a table

Il codice seguente consente di creare un oggetto TableService e di utilizzarlo per creare una nuova tabella.The following code creates a TableService object and uses it to create a new table.

var tableSvc = azure.createTableService();

La chiamata a createTableIfNotExists crea una nuova tabella con il nome specificato, se non è già presente.The call to createTableIfNotExists creates a new table with the specified name if it does not already exist. Nell'esempio seguente viene creata una nuova tabella denominata "mytable" se questa non esiste ancora:The following example creates a new table named 'mytable' if it does not already exist:

tableSvc.createTableIfNotExists('mytable', function(error, result, response){
  if(!error){
    // Table exists or created
  }
});

result.created è true se viene creata una nuova tabella e false se la tabella è già presente.The result.created is true if a new table is created, and false if the table already exists. response contiene le informazioni sulla richiesta.The response contains information about the request.

FiltriFilters

È possibile applicare filtri facoltativi alle operazioni eseguite usando TableService.You can apply optional filtering to operations performed using TableService. I filtri possono essere applicati alla registrazione, alla ripetizione automatica dei tentativi e così via. I filtri sono oggetti che implementano un metodo con la firma:Filtering operations can include logging, automatic retries, etc. Filters are objects that implement a method with the signature:

function handle (requestOptions, next)

Dopo aver eseguito la pre-elaborazione sulle opzioni della richiesta, il metodo deve chiamare next passando un callback con la firma seguente:After doing its preprocessing on the request options, the method must call next, passing a callback with the following signature:

function (returnObject, finalCallback, next)

In questo callback, e dopo l'elaborazione di returnObject (la risposta della richiesta al server), il callback deve richiamare next, se questo esiste, per continuare a elaborare altri filtri oppure semplicemente richiamare finalCallback per concludere la chiamata al servizio.In this callback, and after processing the returnObject (the response from the request to the server), the callback must either invoke next if it exists to continue processing other filters or simply invoke finalCallback otherwise to end the service invocation.

In Azure SDK per Node.js sono inclusi due filtri che implementano la logica di ripetizione dei tentativi. Sono ExponentialRetryPolicyFilter e LinearRetryPolicyFilter.Two filters that implement retry logic are included with the Azure SDK for Node.js, ExponentialRetryPolicyFilter and LinearRetryPolicyFilter. Il codice seguente consente di creare un oggetto TableService che usa ExponentialRetryPolicyFilter:The following creates a TableService object that uses the ExponentialRetryPolicyFilter:

var retryOperations = new azure.ExponentialRetryPolicyFilter();
var tableSvc = azure.createTableService().withFilter(retryOperations);

Aggiungere un'entità a una tabellaAdd an entity to a table

Per aggiungere un'entità, creare prima un oggetto che definisca le proprietà dell'entità.To add an entity, first create an object that defines your entity properties. Tutte le entità devono contenere PartitionKey e RowKey che sono gli identificatori univoci dell'entità.All entities must contain a PartitionKey and RowKey, which are unique identifiers for the entity.

  • PartitionKey: determina la partizione in cui è archiviata l'entità.PartitionKey - Determines the partition in which the entity is stored.
  • RowKey: identifica in modo univoco l'entità all'interno della partizione.RowKey - Uniquely identifies the entity within the partition.

Sia PartitionKey che RowKey devono essere valori stringa.Both PartitionKey and RowKey must be string values. Per altre informazioni, vedere Informazioni sul modello di dati del servizio tabelle.For more information, see Understanding the Table Service Data Model.

Nell'esempio seguente viene definita un'entità.The following is an example of defining an entity. dueDate è definito come tipo di Edm.DateTime.Note that dueDate is defined as a type of Edm.DateTime. La definizione del tipo è facoltativa e i tipi vengono dedotti se non sono specificati.Specifying the type is optional, and types are inferred if not specified.

var task = {
  PartitionKey: {'_':'hometasks'},
  RowKey: {'_': '1'},
  description: {'_':'take out the trash'},
  dueDate: {'_':new Date(2015, 6, 20), '$':'Edm.DateTime'}
};

Nota

Per ogni record è anche presente un campo Timestamp , impostato da Azure quando viene inserita o aggiornata un'entità.There is also a Timestamp field for each record, which is set by Azure when an entity is inserted or updated.

È anche possibile usare entityGenerator per creare le entità.You can also use the entityGenerator to create entities. Nell'esempio seguente viene creata la stessa entità Task tramite entityGenerator.The following example creates the same task entity using the entityGenerator.

var entGen = azure.TableUtilities.entityGenerator;
var task = {
  PartitionKey: entGen.String('hometasks'),
  RowKey: entGen.String('1'),
  description: entGen.String('take out the trash'),
  dueDate: entGen.DateTime(new Date(Date.UTC(2015, 6, 20))),
};

Per aggiungere un'entità alla tabella, passare l'oggetto entità al metodo insertEntity .To add an entity to your table, pass the entity object to the insertEntity method.

tableSvc.insertEntity('mytable',task, function (error, result, response) {
  if(!error){
    // Entity inserted
  }
});

Se l'operazione ha esito positivo, result contiene l'ETag del record inserito e response contiene le informazioni sull'operazione.If the operation is successful, result contains the ETag of the inserted record and response contains information about the operation.

Esempio di risposta:Example response:

{ '.metadata': { etag: 'W/"datetime\'2015-02-25T01%3A22%3A22.5Z\'"' } }

Nota

Per impostazione predefinita, insertEntity non restituisce l'entità inserita come parte delle informazioni di response.By default, insertEntity does not return the inserted entity as part of the response information. Se si prevede di eseguire altre operazioni su questa entità o si vogliono memorizzare le informazioni nella cache, può essere utile fare in modo che l'entità venga restituita come parte di result.If you plan on performing other operations on this entity, or want to cache the information, it can be useful to have it returned as part of the result. A tale scopo, abilitare echoContent come segue:You can do this by enabling echoContent as follows:

tableSvc.insertEntity('mytable', task, {echoContent: true}, function (error, result, response) {...}

Aggiornare un'entitàUpdate an entity

Esistono vari metodi per aggiornare un'entità esistente:There are multiple methods available to update an existing entity:

  • replaceEntity: aggiorna un'entità esistente sostituendola.replaceEntity - Updates an existing entity by replacing it.
  • mergeEntity: aggiorna un'entità esistente unendovi nuovi valori delle proprietà.mergeEntity - Updates an existing entity by merging new property values into the existing entity.
  • insertOrReplaceEntity: aggiorna un'entità esistente sostituendola.insertOrReplaceEntity - Updates an existing entity by replacing it. Se non esiste alcuna entità, ne verrà inserita una nuova.If no entity exists, a new one will be inserted.
  • insertOrMergeEntity: aggiorna un'entità esistente unendovi nuovi valori delle proprietà.insertOrMergeEntity - Updates an existing entity by merging new property values into the existing. Se non esiste alcuna entità, ne verrà inserita una nuova.If no entity exists, a new one will be inserted.

Nell'esempio seguente viene illustrato l'aggiornamento di un'entità mediante replaceEntity:The following example demonstrates updating an entity using replaceEntity:

tableSvc.replaceEntity('mytable', updatedTask, function(error, result, response){
  if(!error) {
    // Entity updated
  }
});

Nota

Per impostazione predefinita, l'aggiornamento di un'entità non comporta la verifica dei dati per controllare se siano stati modificati da altri processi.By default, updating an entity does not check to see if the data being updated has previously been modified by another process. Per supportare gli aggiornamenti simultanei:To support concurrent updates:

  1. Recuperare il valore ETag dell'oggetto da aggiornare.Get the ETag of the object being updated. Questo valore viene restituito insieme a response per qualsiasi operazione associata all'entità e può essere recuperato tramite response['.metadata'].etag.This is returned as part of the response for any entity-related operation and can be retrieved through response['.metadata'].etag.

  2. Quando si esegue un'operazione di aggiornamento su un'entità, aggiungere le informazioni ETag precedentemente recuperate alla nuova entità.When performing an update operation on an entity, add the ETag information previously retrieved to the new entity. Ad esempio:For example:

    entity2['.metadata'].etag = currentEtag;entity2['.metadata'].etag = currentEtag;

  3. Eseguire l'operazione di aggiornamento.Perform the update operation. Se l'entità è stata modificata dall'ultimo recupero del valore ETag, ad esempio da un'altra istanza dell'applicazione, viene restituito un error per segnalare che la condizione di aggiornamento specificata nella richiesta non è stata soddisfatta.If the entity has been modified since you retrieved the ETag value, such as another instance of your application, an error is returned stating that the update condition specified in the request was not satisfied.

Con replaceEntity e mergeEntity, se l'entità da aggiornare non esiste, l'operazione di aggiornamento ha esito negativo. Pertanto, se si vuole archiviare un'entità indipendentemente dal fatto che sia già presente, usare insertOrReplaceEntity oppure insertOrMergeEntity.With replaceEntity and mergeEntity, if the entity that is being updated doesn't exist, then the update operation fails; therefore, if you want to store an entity regardless of whether it already exists, use insertOrReplaceEntity or insertOrMergeEntity.

L'oggetto result per le operazioni di aggiornamento riuscite contiene l'Etag dell'entità aggiornata.The result for successful update operations contains the Etag of the updated entity.

Usare i gruppi di entitàWork with groups of entities

È talvolta consigliabile inviare più operazioni in un batch per garantire l'elaborazione atomica da parte del server.Sometimes it makes sense to submit multiple operations together in a batch to ensure atomic processing by the server. A questo scopo, usare la classe TableBatch per creare un batch e quindi usare il metodo executeBatch di TableService per eseguire le operazioni in batch.To accomplish that, use the TableBatch class to create a batch, and then use the executeBatch method of TableService to perform the batched operations.

Nell'esempio seguente viene dimostrato l'invio di due entità in un batch:The following example demonstrates submitting two entities in a batch:

var task1 = {
  PartitionKey: {'_':'hometasks'},
  RowKey: {'_': '1'},
  description: {'_':'Take out the trash'},
  dueDate: {'_':new Date(2015, 6, 20)}
};
var task2 = {
  PartitionKey: {'_':'hometasks'},
  RowKey: {'_': '2'},
  description: {'_':'Wash the dishes'},
  dueDate: {'_':new Date(2015, 6, 20)}
};

var batch = new azure.TableBatch();

batch.insertEntity(task1, {echoContent: true});
batch.insertEntity(task2, {echoContent: true});

tableSvc.executeBatch('mytable', batch, function (error, result, response) {
  if(!error) {
    // Batch completed
  }
});

Per le operazioni in batch riuscite, result contiene le informazioni relative a ogni operazione nel batch.For successful batch operations, result contains information for each operation in the batch.

Uso delle operazioni in batchWork with batched operations

È possibile esaminare le operazioni aggiunte a un batch visualizzando la proprietà operations.You can inspect operations added to a batch by viewing the operations property. Per usare le operazioni sono disponibili anche i metodi seguenti:You can also use the following methods to work with operations:

  • clear: cancella tutte le operazioni da un batch.clear - Clears all operations from a batch.
  • getOperations: recupera un'operazione dal batch.getOperations - Gets an operation from the batch.
  • hasOperations: restituisce true se il batch contiene operazioni.hasOperations - Returns true if the batch contains operations.
  • removeOperations: rimuove un'operazione.removeOperations - Removes an operation.
  • size: restituisce il numero di operazioni nel batch.size - Returns the number of operations in the batch.

Recuperare un'entità in base alla chiaveRetrieve an entity by key

Per restituire un'entità specifica in base a PartitionKey e RowKey, usare il metodo retrieveEntity.To return a specific entity based on the PartitionKey and RowKey, use the retrieveEntity method.

tableSvc.retrieveEntity('mytable', 'hometasks', '1', function(error, result, response){
  if(!error){
    // result contains the entity
  }
});

Al termine di questa operazione, result contiene l'entità.After this operation is complete, result contains the entity.

Eseguire query su un set di entitàQuery a set of entities

Per eseguire una query su una tabella, usare l'oggetto TableQuery per creare un'espressione di query con queste clausole:To query a table, use the TableQuery object to build up a query expression using the following clauses:

  • select: i campi che la query deve restituire.select - The fields to be returned from the query.

  • where: la clausola where.where - The where clause.

    • and: una condizione where and.and - An and where condition.
    • or: una condizione where or.or - An or where condition.
  • top: il numero di elementi da recuperare.top - The number of items to fetch.

L'esempio seguente crea una query che restituisce i primi cinque elementi con PartitionKey 'hometasks'.The following example builds a query that returns the top five items with a PartitionKey of 'hometasks'.

var query = new azure.TableQuery()
  .top(5)
  .where('PartitionKey eq ?', 'hometasks');

Poiché la clausola select non viene usata, vengono restituiti tutti i campi.Because select is not used, all fields are returned. Per eseguire la query su una tabella, usare queryEntities.To perform the query against a table, use queryEntities. Nell'esempio seguente viene usata questa query per restituire entità da 'mytable'.The following example uses this query to return entities from 'mytable'.

tableSvc.queryEntities('mytable',query, null, function(error, result, response) {
  if(!error) {
    // query was successful
  }
});

Se la query ha esito positivo, result.entries contiene una matrice delle entità che corrispondono alla query.If successful, result.entries contains an array of entities that match the query. Se la query non è riuscita a restituire tutte le entità, result.continuationToken è un valore diverso da null e può essere usato come terzo parametro di queryEntities per recuperare altri risultati.If the query was unable to return all entities, result.continuationToken is non-null and can be used as the third parameter of queryEntities to retrieve more results. Per la query iniziale, utilizzare null per il terzo parametro.For the initial query, use null for the third parameter.

Eseguire query su un subset di proprietà di entitàQuery a subset of entity properties

Una query su una tabella può recuperare solo alcuni campi da un'entità.A query to a table can retrieve just a few fields from an entity. Questa tecnica permette di ridurre la larghezza di banda e di migliorare le prestazioni della query, in particolare per entità di grandi dimensioni.This reduces bandwidth and can improve query performance, especially for large entities. Usare la clausola select e passare i nomi dei campi da restituire.Use the select clause and pass the names of the fields to return. La query seguente, ad esempio, restituisce solo i campi description e dueDate.For example, the following query returns only the description and dueDate fields.

var query = new azure.TableQuery()
  .select(['description', 'dueDate'])
  .top(5)
  .where('PartitionKey eq ?', 'hometasks');

Eliminare un'entitàDelete an entity

È possibile eliminare un'entità utilizzando le relative chiavi di riga e di partizione.You can delete an entity using its partition and row keys. In questo esempio l'oggetto task1 contiene i valori RowKey e PartitionKey dell'entità da eliminare.In this example, the task1 object contains the RowKey and PartitionKey values of the entity to delete. L'oggetto viene quindi passato al metodo deleteEntity .Then the object is passed to the deleteEntity method.

var task = {
  PartitionKey: {'_':'hometasks'},
  RowKey: {'_': '1'}
};

tableSvc.deleteEntity('mytable', task, function(error, response){
  if(!error) {
    // Entity deleted
  }
});

Nota

Quando si eliminano elementi, è bene valutare l'uso di ETag per assicurarsi che l'elemento non sia stato modificato da un altro processo.Consider using ETags when deleting items, to ensure that the item hasn't been modified by another process. Vedere Aggiornare un'entità per informazioni sull'uso di ETag.See Update an entity for information on using ETags.

Eliminare una tabellaDelete a table

Nell'esempio di codice seguente viene illustrato come eliminare una tabella da un account di archiviazione.The following code deletes a table from a storage account.

tableSvc.deleteTable('mytable', function(error, response){
    if(!error){
        // Table deleted
    }
});

Se non si è certi dell'esistenza della tabella, usare deleteTableIfExists.If you are uncertain whether the table exists, use deleteTableIfExists.

Utilizzare i token di continuazioneUse continuation tokens

Quando si esegue una query di tabelle di grandi quantità di risultati, ricercare i token di continuazione.When you are querying tables for large amounts of results, look for continuation tokens. Potrebbero essere disponibili grandi quantità di dati per la query di cui si potrebbe non essere consapevoli se non si compila il riconoscimento della presenza di un token di continuazione.There may be large amounts of data available for your query that you might not realize if you do not build to recognize when a continuation token is present.

L'oggetto results restituito quando si esegue una query sulle entità imposta una proprietà continuationToken quando è presente un token di questo tipo.The results object returned during querying entities sets a continuationToken property when such a token is present. È possibile quindi utilizzarlo quando si esegue una query per continuare a spostarsi tra le entità della partizione e della tabella.You can then use this when performing a query to continue to move across the partition and table entities.

Quando si esegue una query, è possibile specificare un parametro continuationToken tra l'istanza dell'oggetto della query e la funzione di callback:When querying, you can provide a continuationToken parameter between the query object instance and the callback function:

var nextContinuationToken = null;
dc.table.queryEntities(tableName,
    query,
    nextContinuationToken,
    function (error, results) {
        if (error) throw error;

        // iterate through results.entries with results

        if (results.continuationToken) {
            nextContinuationToken = results.continuationToken;
        }

    });

Se si osserva l'oggetto continuationToken, si troveranno proprietà come nextPartitionKey, nextRowKey e targetLocation che possono essere usate per eseguire l'iterazione di tutti i risultati.If you inspect the continuationToken object, you will find properties such as nextPartitionKey, nextRowKey and targetLocation, which can be used to iterate through all the results.

È anche possibile usare top con continuationToken per impostare le dimensioni della pagina.You can also use top along with continuationToken to set the page size.

Usare le firme di accesso condiviso di AzureWork with shared access signatures

Le firme di accesso condiviso rappresentano un modo sicuro per fornire accesso granulare alle tabelle senza specificare il nome o le chiavi dell'account di archiviazione.Shared access signatures (SAS) are a secure way to provide granular access to tables without providing your Storage account name or keys. Le firme di accesso condiviso vengono spesso usate per fornire accesso limitato ai dati, ad esempio per consentire a un'app per dispositivi mobili di eseguire query sui record.SAS are often used to provide limited access to your data, such as allowing a mobile app to query records.

Un'applicazione attendibile, ad esempio un servizio basato sul cloud, genera una firma di accesso condiviso tramite il metodo generateSharedAccessSignature dell'oggetto TableService e la fornisce a un'applicazione non attendibile o parzialmente attendibile, ad esempio a un'app per dispositivi mobili.A trusted application such as a cloud-based service generates a SAS using the generateSharedAccessSignature of the TableService, and provides it to an untrusted or semi-trusted application such as a mobile app. La firma di accesso condiviso viene generata tramite un criterio che indica le date di inizio e di fine del periodo di validità della firma, nonché il livello di accesso concesso al titolare della firma di accesso condiviso.The SAS is generated using a policy, which describes the start and end dates during which the SAS is valid, as well as the access level granted to the SAS holder.

Nell'esempio seguente viene generato un nuovo criterio di accesso condiviso che consentirà al titolare della firma di accesso condiviso di eseguire una query ('r') per la tabella e che scadrà 100 minuti dopo la data di creazione.The following example generates a new shared access policy that will allow the SAS holder to query ('r') the table, and expires 100 minutes after the time it is created.

var startDate = new Date();
var expiryDate = new Date(startDate);
expiryDate.setMinutes(startDate.getMinutes() + 100);
startDate.setMinutes(startDate.getMinutes() - 100);

var sharedAccessPolicy = {
  AccessPolicy: {
    Permissions: azure.TableUtilities.SharedAccessPermissions.QUERY,
    Start: startDate,
    Expiry: expiryDate
  },
};

var tableSAS = tableSvc.generateSharedAccessSignature('mytable', sharedAccessPolicy);
var host = tableSvc.host;

Si noti che è necessario specificare anche le informazioni sull'host poiché vengono richieste quando il titolare della firma di accesso condiviso prova ad accedere alla tabella.Note that you must also provide the host information, as it is required when the SAS holder attempts to access the table.

L'applicazione client usa quindi la firma di accesso condiviso con il metodo TableServiceWithSAS per eseguire operazioni sulla tabella.The client application then uses the SAS with TableServiceWithSAS to perform operations against the table. Nell'esempio seguente viene eseguita la connessione alla tabella e viene eseguita una query.The following example connects to the table and performs a query. Per il formato di tableSAS, vedere l'articolo Concedere accesso limitato alle risorse di Archiviazione di Azure usando firme di accesso condiviso (SAS).See Grant limited access to Azure Storage resources using shared access signatures (SAS) article for the format of tableSAS.

// Note in the following command, host is in the format: `https://<your_storage_account_name>.table.core.windows.net` and the tableSAS is in the format: `sv=2018-03-28&si=saspolicy&tn=mytable&sig=9aCzs76n0E7y5BpEi2GvsSv433BZa22leDOZXX%2BXXIU%3D`;

var sharedTableService = azure.createTableServiceWithSas(host, tableSAS);
var query = azure.TableQuery()
  .where('PartitionKey eq ?', 'hometasks');

sharedTableService.queryEntities(query, null, function(error, result, response) {
  if(!error) {
    // result contains the entities
  }
});

Poiché la firma di accesso condiviso è stata generata con accesso solo query, se si prova a inserire, aggiornare o eliminare entità viene restituito un errore.Because the SAS was generated with only query access, an error is returned if you attempt to insert, update, or delete entities.

Elenchi di controllo di accessoAccess Control Lists

Per impostare i criteri di accesso per una firma di accesso condiviso è anche possibile usare un elenco di controllo di accesso.You can also use an Access Control List (ACL) to set the access policy for a SAS. Questa soluzione è utile quando si vuole consentire a più client di accedere alla tabella, ma si impostano criteri di accesso diversi per ogni client.This is useful if you want to allow multiple clients to access the table, but provide different access policies for each client.

Un elenco di controllo di accesso viene implementato usando una matrice di criteri di accesso, con un ID associato a ogni criterio.An ACL is implemented using an array of access policies, with an ID associated with each policy. L'esempio seguente definisce due criteri, uno per 'user1' e uno per 'user2':The following example defines two policies, one for 'user1' and one for 'user2':

var sharedAccessPolicy = {
  user1: {
    Permissions: azure.TableUtilities.SharedAccessPermissions.QUERY,
    Start: startDate,
    Expiry: expiryDate
  },
  user2: {
    Permissions: azure.TableUtilities.SharedAccessPermissions.ADD,
    Start: startDate,
    Expiry: expiryDate
  }
};

L'esempio seguente recupera l'elenco di controllo di accesso corrente per la tabella hometasks e quindi aggiunge i nuovi criteri tramite setTableAcl.The following example gets the current ACL for the hometasks table, and then adds the new policies using setTableAcl. Risultato:This approach allows:

var extend = require('extend');
tableSvc.getTableAcl('hometasks', function(error, result, response) {
if(!error){
    var newSignedIdentifiers = extend(true, result.signedIdentifiers, sharedAccessPolicy);
    tableSvc.setTableAcl('hometasks', newSignedIdentifiers, function(error, result, response){
      if(!error){
        // ACL set
      }
    });
  }
});

Dopo avere impostato l'elenco di controllo di accesso, è possibile creare una firma di accesso condiviso in base all'ID di un criterio.After the ACL has been set, you can then create a SAS based on the ID for a policy. Nell'esempio seguente viene creata una nuova firma di accesso condiviso per 'user2':The following example creates a new SAS for 'user2':

tableSAS = tableSvc.generateSharedAccessSignature('hometasks', { Id: 'user2' });

Passaggi successiviNext steps

Per altre informazioni, vedere le risorse seguenti:For more information, see the following resources.