Trova il costo in unità di richiesta delle operazioni in Azure Cosmos DB con NoSQL

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). Costo delle richieste sono le unità di richiesta consumate da tutte le operazioni sui database. Le RUs possono essere considerate come una sorta di "valuta di prestazioni" che astrae le risorse di sistema come CPU, operazioni di I/O al secondo e memoria, necessarie per eseguire le operazioni del 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 puntuale o una query, i costi sono sempre misurati in RU. 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 su cui si vuole lavorare.
Selezionare Nuova query SQL.
Immettere una query valida e quindi selezionare Esegui query.
Seleziona Statistiche query per visualizzare il costo effettivo della richiesta eseguita.

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

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 RequestCharge proprietà:

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 Avvio rapido: Creare un'app Web .NET usando un account API per NoSQL in Azure Cosmos DB.

Utilizzare il Java SDK

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

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 il Node.js SDK

Gli oggetti restituiti dall'SDK diNode.js espongono un headers sottooggetto che esegue il mapping di tutte le intestazioni restituite dall'API HTTP sottostante. L'addebito per la 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.

Utilizzare il Python SDK

L'oggetto Container di Python SDK mette a disposizione un last_response_headers dizionario che mappa tutte le intestazioni restituite dall'API HTTP sottostante dell'ultima operazione eseguita. L'addebito per la 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 Avvio rapido: Creare un'app Python usando un account Azure Cosmos DB per NoSQL.

Usa il Go SDK

La risposta è il tipo di risposta di base per tutte le risposte di Azure Cosmos DB. Espone una RequestCharge proprietà che contiene l'addebito della richiesta per la rispettiva operazione, ad esempio letture, scritture e query.

Operazione di lettura:

container, _ := c.NewContainer("moviesdb", "movies")

resp, _ := container.ReadItem(context.Background(), azcosmos.NewPartitionKeyString("Quentin Tarantino"), "Pulp Fiction", nil)

log.Println("read request charge", resp.RequestCharge)

Operazione di query:

container, _ := c.NewContainer("moviesdb", "movies")

pager := container.NewQueryItemsPager("select * from c", azcosmos.NewPartitionKey(), nil)

if pager.More() {
	page, _ := pager.NextPage(context.Background())
	// use the result
	log.Println("query request charge", page.RequestCharge)
}

Passaggi successivi

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

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-27