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

Articolo
10/18/2023

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 del database viene normalizzato da Azure Cosmos DB ed è espresso dalle unità richiesta (UR). L'addebito delle richieste è costituito dalle unità richiesta utilizzate da tutte le operazioni del database. È possibile considerare le UR come una valuta delle prestazioni che astrae le 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. Indipendentemente dall'API usata per interagire con il contenitore, i costi vengono sempre misurati in UR. 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 diversi modi in cui è possibile trovare il consumo di unità richiesta per qualsiasi operazione eseguita su un contenitore in Azure Cosmos DB per NoSQL. Se si usa un'API diversa, vedere API per MongoDB, API per Cassandra, API per Gremlin e API per Table.

Attualmente, è possibile misurare l'utilizzo solo usando il portale di Azure o esaminando la risposta inviata da Azure Cosmos DB tramite uno degli SDK. Se si usa l'API per NoSQL, sono disponibili più opzioni per trovare l'addebito della richiesta per un'operazione.

Usare il portale di Azure

Accedi al portale di Azure.
Creare un nuovo account Azure Cosmos DB e generarne il feed con i 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));
double requestCharge = itemResponse.RequestCharge;

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

requestCharge = 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();
    requestCharge = feedResponse.RequestCharge;
}

Per altre informazioni, vedere Avvio rapido: Creare un'app Web .NET usando un account 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 Avvio rapido: Creare un'applicazione Java usando un account Azure Cosmos DB per 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 Avvio rapido: Creare un'app Node.js usando un account Azure Cosmos DB per 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": "70b63682-b93a-4c77-aad2-65501347265f",
    "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="70b63682-b93a-4c77-aad2-65501347265f"
    partition_key="61dba35b-4f02-45c5-b648-c6badc0cbd79"
)

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

Per altre informazioni, vedere Avvio rapido: Creare un'app Python usando un account Azure Cosmos DB per NoSQL.

Passaggi successivi

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