Encontre a carga da unidade de requisição das operações no Azure Cosmos DB para NoSQL

Aplica-se a: ✅ NoSQL

O Azure Cosmos DB dá suporte a muitas APIs, como SQL, MongoDB, Cassandra, Gremlin e Table. Cada API tem seu próprio conjunto de operações de banco de dados. Essas operações variam de simples leituras e gravações pontuais a consultas complexas. Cada operação de banco de dados consome recursos do sistema com base na complexidade da operação.

O custo de todas as operações na base de dados é normalizado pelo Azure Cosmos DB e é expresso por unidades de pedido (RU). A taxa de pedido são as unidades de pedido consumidas por todas as operações da sua base de dados. Você pode pensar em RUs como uma moeda de desempenho abstraindo os recursos do sistema, como CPU, IOPS e memória, necessários para executar as operações de banco de dados com suporte do Azure Cosmos DB. Independentemente da API que use para interagir com o seu contentor, os custos são sempre medidos em RUs. Seja a operação da base de dados de escrita, de leitura de ponto ou de consulta, os custos são sempre medidos em RU. Para saber mais, consulte Unidades de Pedido no Azure Cosmos DB.

Este artigo apresenta as diferentes formas de encontrar o consumo de unidades de pedido para qualquer operação executada num contentor no Azure Cosmos DB para NoSQL. Se estiveres a usar uma API diferente, vê API para MongoDB,API para Cassandra, API para Gremlin e API para Table.

Atualmente, só pode medir o consumo usando o portal Azure ou inspecionando a resposta enviada pelo Azure Cosmos DB através de um dos SDKs. Se estiveres a usar a API para NoSQL, tens várias opções para encontrar a carga de pedido para uma operação.

Utilizar o portal do Azure

Inicie sessão no portal Azure.
Crie uma nova conta Azure Cosmos DB e alimente-a com dados, ou selecione uma conta Azure Cosmos DB existente que já contenha dados.
Vá para o painel Data Explorer e selecione o contêiner no qual deseja trabalhar.
Selecione Nova Consulta SQL.
Introduza uma consulta válida e depois selecione Executar Consulta.
Selecione Estatísticas de consulta para exibir a cobrança de solicitação real para a solicitação executada.

Objetos que são devolvidos do .NET SDK v2 expõem uma RequestCharge propriedade:

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;
}

Objetos que são devolvidos do .NET SDK v3 expõem uma RequestCharge propriedade:

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;
}

Para mais informações, consulte Quickstart: Construa uma aplicação web .NET usando uma API para a conta NoSQL no Azure Cosmos DB.

Usar o Java SDK

Os objetos que são devolvidos do SDK Java expõem um getRequestCharge() método:

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();
});

Para mais informações, consulte Quickstart: Construa uma aplicação Java usando uma conta Azure Cosmos DB para NoSQL.

Usar o SDK do Node.js

Os objetos que são devolvidos do SDKNode.js expõem um headers subobjeto que mapeia todos os cabeçalhos devolvidos pela API HTTP subjacente. A taxa de pedido está disponível sob a x-ms-request-charge tecla:

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'];
}

Para mais informações, consulte Quickstart: Construa uma aplicação Node.js usando uma conta Azure Cosmos DB for NoSQL.

Utilizar o SDK Python

O Container objeto do SDK Python expõe um last_response_headers dicionário que mapeia todos os cabeçalhos devolvidos pela API HTTP subjacente para a última operação executada. A taxa de solicitação está disponível sob a chave 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"]

Para mais informações, consulte Quickstart: Construa uma aplicação Python usando uma conta Azure Cosmos DB for NoSQL.

Usar o SDK Go

Resposta é o tipo base de resposta para todas as respostas do Azure Cosmos DB. Expõe uma RequestCharge propriedade que contém a carga de pedido para a respetiva operação, como leituras, escritas e consultas.

Operação de leitura:

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

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

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

Operação de consulta:

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)
}

Próximos passos

Para saber mais sobre como otimizar seu consumo de RU, consulte estes artigos:

Feedback

Esta página foi útil?

Last updated on 2025-12-19