Trovare l'addebito delle unità richiesta per le operazioni eseguite in Azure Cosmos DB for NoSQL

Articolo
11/07/2024

SI APPLICA A: NoSQL

Azure Cosmos DB supporta un'ampia gamma di API, come SQL, MongoDB, Cassandra, Gremlin e Tabella. Ogni API ha il proprio set di operazioni di database, da semplici operazioni di lettura e scrittura puntuali a query complesse. Ogni operazione di database utilizza le risorse di sistema a seconda della complessità.

Il costo di tutte le operazioni di database viene normalizzato da Azure Cosmos DB ed è espresso in termini di unità richiesta (UR). L'addebito delle richieste è costituito dalle unità richiesta utilizzate da tutte le operazioni del database. Un'unità richiesta si può considerare come una valuta basata sulle prestazioni, determinata in base all'astrazione delle risorse di sistema, ad esempio CPU, operazioni di I/O al secondo e memoria, necessarie per eseguire le operazioni di database supportate da Azure Cosmos DB. I costi vengono sempre misurati in UR, indipendentemente dall'API usata per interagire con il contenitore. Sia che l'operazione di database sia una scrittura, una lettura di punti o una query, i costi sono sempre misurati in UR. Per altre informazioni, vedere Unità richiesta in Azure Cosmos DB.

Questo articolo presenta i vari modi in cui è possibile trovare il consumo di unità richiesta (UR) per qualsiasi operazione eseguita con un contenitore in Azure Cosmos DB for NoSQL. Se si usa un'API diversa, vedere API per MongoDB, API per Cassandra, API per Gremline API per Table.

È attualmente possibile misurare questo consumo solo usando il portale di Azure oppure esaminando la risposta inviata da Azure Cosmos DB tramite uno degli SDK. Se si usa l'API per NoSQL, sono disponibili diverse opzioni per trovare il consumo di unità richiesta per un'operazione.

Usare il portale di Azure

Accedere al portale di Azure.
Creare un nuovo account di Azure Cosmos DB e inserirvi dati oppure selezionare un account Azure Cosmos DB esistente che contiene già dati.
Passare al riquadro Esplora dati e quindi selezionare il contenitore da usare.
Selezionare Nuova query SQL.
Immettere una query valida e quindi fare clic su Esegui query.
Fare clic su Statistiche query per visualizzare l'addebito effettivo per la richiesta eseguita.

Gli oggetti restituiti da .NET SDK v2 espongono una proprietà RequestCharge:

ResourceResponse<Document> fetchDocumentResponse = await client.ReadDocumentAsync(
    UriFactory.CreateDocumentUri("database", "container", "itemId"),
    new RequestOptions
    {
        PartitionKey = new PartitionKey("partitionKey")
    });
var requestCharge = fetchDocumentResponse.RequestCharge;

StoredProcedureResponse<string> storedProcedureCallResponse = await client.ExecuteStoredProcedureAsync<string>(
    UriFactory.CreateStoredProcedureUri("database", "container", "storedProcedureId"),
    new RequestOptions
    {
        PartitionKey = new PartitionKey("partitionKey")
    });
requestCharge = storedProcedureCallResponse.RequestCharge;

IDocumentQuery<dynamic> query = client.CreateDocumentQuery(
    UriFactory.CreateDocumentCollectionUri("database", "container"),
    "SELECT * FROM c",
    new FeedOptions
    {
        PartitionKey = new PartitionKey("partitionKey")
    }).AsDocumentQuery();
while (query.HasMoreResults)
{
    FeedResponse<dynamic> queryResponse = await query.ExecuteNextAsync<dynamic>();
    requestCharge = queryResponse.RequestCharge;
}

Gli oggetti restituiti da .NET SDK v3 espongono una proprietà RequestCharge:

Container container = this.cosmosClient.GetContainer("database", "container");
string itemId = "myItem";
string partitionKey = "partitionKey";
string storedProcedureId = "storedProcedureId";
string queryText = "SELECT * FROM c";

ItemResponse<dynamic> itemResponse = await container.CreateItemAsync<dynamic>(
    item: new { id = itemId, pk = partitionKey },
    partitionKey: new PartitionKey(partitionKey));
_ = itemResponse.RequestCharge;

Scripts scripts = container.Scripts;
StoredProcedureExecuteResponse<object> sprocResponse = await scripts.ExecuteStoredProcedureAsync<object>(
    storedProcedureId: storedProcedureId,
    partitionKey: new PartitionKey(partitionKey),
    parameters: new dynamic[] { new object() });

_ = sprocResponse.RequestCharge;

FeedIterator<dynamic> feedIterator = container.GetItemQueryIterator<dynamic>(
     queryText: queryText,
     requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey(partitionKey) });
while (feedIterator.HasMoreResults)
{
    FeedResponse<dynamic> feedResponse = await feedIterator.ReadNextAsync();
    _ = feedResponse.RequestCharge;
}

Per altre informazioni, vedere Guida introduttiva: Compilare un'app Web .NET usando un account dell'API per NoSQL in Azure Cosmos DB.

Usare Java SDK

Gli oggetti restituiti da Java SDK espongono un metodo getRequestCharge():

RequestOptions requestOptions = new RequestOptions();
requestOptions.setPartitionKey(new PartitionKey("partitionKey"));

Observable<ResourceResponse<Document>> readDocumentResponse = client.readDocument(String.format("/dbs/%s/colls/%s/docs/%s", "database", "container", "itemId"), requestOptions);
readDocumentResponse.subscribe(result -> {
    double requestCharge = result.getRequestCharge();
});

Observable<StoredProcedureResponse> storedProcedureResponse = client.executeStoredProcedure(String.format("/dbs/%s/colls/%s/sprocs/%s", "database", "container", "storedProcedureId"), requestOptions, null);
storedProcedureResponse.subscribe(result -> {
    double requestCharge = result.getRequestCharge();
});

FeedOptions feedOptions = new FeedOptions();
feedOptions.setPartitionKey(new PartitionKey("partitionKey"));

Observable<FeedResponse<Document>> feedResponse = client
    .queryDocuments(String.format("/dbs/%s/colls/%s", "database", "container"), "SELECT * FROM c", feedOptions);
feedResponse.forEach(result -> {
    double requestCharge = result.getRequestCharge();
});

Per altre informazioni, vedere Guida introduttiva: Creare un'applicazione Java usando un account di Azure Cosmos DB for NoSQL.

Usare Node.js SDK

Gli oggetti restituiti da Node.js SDK espongono un oggetto secondario headers che viene mappato a tutte le intestazione restituite dall'API HTTP sottostante. L'addebito della richiesta è disponibile sotto la chiave x-ms-request-charge:

const item = await client
    .database('database')
    .container('container')
    .item('itemId', 'partitionKey')
    .read();
var requestCharge = item.headers['x-ms-request-charge'];

const storedProcedureResult = await client
    .database('database')
    .container('container')
    .storedProcedure('storedProcedureId')
    .execute({
        partitionKey: 'partitionKey'
    });
requestCharge = storedProcedureResult.headers['x-ms-request-charge'];

const query = client.database('database')
    .container('container')
    .items
    .query('SELECT * FROM c', {
        partitionKey: 'partitionKey'
    });
while (query.hasMoreResults()) {
    var result = await query.executeNext();
    requestCharge = result.headers['x-ms-request-charge'];
}

Per altre informazioni, vedere Guida introduttiva: Creare un'app Node.js usando un account di Azure Cosmos DB for NoSQL.

Usare Python SDK

L'oggetto Container proveniente da Python SDK espone un dizionario last_response_headers che viene mappato a tutte le intestazione restituite dall'API HTTP sottostante per l'ultima operazione eseguita. L'addebito della richiesta è disponibile sotto la chiave x-ms-request-charge:

new_item = {
    "id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    "partition_key": "61dba35b-4f02-45c5-b648-c6badc0cbd79",
    "name": "Yamba Surfboard"
}
container.create_item(new_item)

request_charge = container.client_connection.last_response_headers["x-ms-request-charge"]

existing_item = container.read_item(
    item="aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"
    partition_key="61dba35b-4f02-45c5-b648-c6badc0cbd79"
)

request_charge = container.client_connection.last_response_headers["x-ms-request-charge"]

Per altre informazioni, vedere Guida introduttiva: Creare un'app Python usando un account di Azure Cosmos DB for NoSQL.

Passaggi successivi

Per informazioni su come ottimizzare il consumo di UR, vedere questi articoli:

Condividi tramite