Localizar o encargo da unidade de solicitação para operações no Azure Cosmos DB for 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 de pontos 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 de banco de dados é normalizado pelo Azure Cosmos DB e é expresso por RU (unidades de solicitação ). Carga de solicitação representa as unidades de solicitação consumidas por todas as suas operações de banco de dados. Você pode encarar as RUs como uma moeda de desempenho que abstrai os recursos do sistema (como CPU, IOPS e memória) necessários para executar as operações de banco de dados compatíveis com o Azure Cosmos DB. Não importa qual API você usa para interagir com seu contêiner, os custos são sempre medidos em RUs. Independentemente da operação de banco de dados ser uma gravação, uma leitura pontual ou uma consulta, os custos serão sempre medidos em RUs. Para saber mais, consulte Unidades de Solicitação no Azure Cosmos DB.

Este artigo apresenta as diferentes maneiras pelas quais você pode encontrar o consumo de unidade de solicitação para qualquer operação executada em um contêiner no Azure Cosmos DB para NoSQL. Se você estiver usando uma API diferente, consulte API para MongoDB, API para Cassandra, API para Gremlin e API para Tabela.

Atualmente, você só pode medir o consumo usando o portal do Azure ou inspecionando a resposta enviada do Azure Cosmos DB por meio de um dos SDKs. Se você estiver usando a API para NoSQL, terá várias opções para localizar o custo de solicitação de uma operação.

Use o portal do Azure

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

Objetos retornados do SDK do .NET 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 retornados do SDK do .NET 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 obter mais informações, consulte Início Rápido: Criar um aplicativo Web .NET usando uma conta da API para NoSQL no Azure Cosmos DB.

Usar o SDK do Java

Os objetos retornados do SDK do 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 obter mais informações, consulte Início Rápido: Criar um aplicativo Java usando uma conta do Azure Cosmos DB para NoSQL.

Usar o SDK do Node.js

Objetos retornados pelo SDK de Node.js expõem um headers subobjeto que mapeia todos os cabeçalhos retornados pela API HTTP subjacente. O preço de solicitação está disponível na chave 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'];
}

Para obter mais informações, consulte Início Rápido: Criar um aplicativo Node.js usando uma conta do Azure Cosmos DB para NoSQL.

Usar o SDK do Python

O Container objeto do SDK do Python expõe um last_response_headers dicionário que mapeia todos os cabeçalhos retornados pela API HTTP subjacente para a última operação executada. O preço de solicitação está disponível na 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 obter mais informações, consulte Início Rápido: Criar um aplicativo Python usando uma conta do Azure Cosmos DB para NoSQL.

Utilize o SDK do Go

A resposta é o tipo de resposta base para todas as respostas do Azure Cosmos DB. Ele expõe uma propriedade RequestCharge que contém o encargo de solicitação para a respectiva operação, como leituras, gravações 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óximas etapas

Para saber mais sobre como otimizar o consumo de RU, confira estes artigos:

Comentários

Esta página foi útil?

Last updated on 2025-12-29