在 Azure Cosmos DB for NoSQL 中查找作的请求单位费用

適用対象: ✅ NoSQL

Azure Cosmos DB 支持多种 API，例如 SQL、MongoDB、Cassandra、Gremlin 和表。每个 API 具有自身的数据库操作集。这些操作包括简单的点读取和写入，以及复杂的查询等等。每个数据库操作根据其复杂性消耗系统资源。

所有数据库作的成本由 Azure Cosmos DB 规范化，并由 请求单位 （RU）表示。 请求计费 是所有数据库操作消耗的请求单位。你可以将 RU 视为性能货币，它抽象化了执行 Azure Cosmos DB 支持的数据库操作所需的系统资源，例如 CPU、IOPS 和内存。无论使用哪种 API 与容器交互，成本始终以 RU 为单位。无论数据库操作是写入、点读取还是查询，都始终以 RU 来计量成本。若要了解详细信息，请参阅 Azure Cosmos DB 中的请求单位。

本文介绍了几种方法，可以查找在 Azure Cosmos DB for NoSQL 中对容器运行的任何操作的请求单位的消耗量。如果使用其他 API，请参阅用于 MongoDB 的 API、Cassandra API、Gremlin API 和用于表的 API。

目前，只能通过使用 Azure 门户或通过其中一个 SDK 检查从 Azure Cosmos DB 发送的响应来度量消耗量。如果您在使用 NoSQL 的 API，有多种选项可以查找操作的请求费用。

使用 Azure 门户

登录到 Azure 门户。
创建新的 Azure Cosmos DB 帐户并使用数据馈送它，或选择已包含数据的现有 Azure Cosmos DB 帐户。
转到 “数据资源管理器” 窗格，然后选择要使用的容器。
选择“新建 SQL 查询”。
输入有效的查询，然后选择“ 执行查询”。
选择 “查询统计信息 ”以显示所执行请求的实际请求费用。

从 .NET SDK v2 返回的对象公开属性 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;
}

从 .NET SDK v3 返回的对象公开属性 RequestCharge ：

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------

namespace Microsoft.Azure.Cosmos.SampleCodeForDocs
{
    using Microsoft.Azure.Cosmos.Scripts;
    using System.Threading.Tasks;

    class CustomDocsSampleCode
    {
        private CosmosClient cosmosClient;

        internal void intitialize()
        {
            this.cosmosClient = new CosmosClient(
                accountEndpoint: "TestAccount",
                authKeyOrResourceToken: "TestKey",
                clientOptions: new CosmosClientOptions());
        }

        public async Task GetRequestChargeFromResource()
        {
            // <GetRequestCharge>
            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;
            }
            // </GetRequestCharge>
        }
    }
}

有关详细信息，请参阅快速入门：在 Azure Cosmos DB 中使用用于 NoSQL 帐户的 API 生成 .NET Web 应用。

使用 Java SDK

从 Java SDK 返回的对象会调用一个名为 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();
});

有关详细信息，请参阅快速入门：使用 Azure Cosmos DB for NoSQL 帐户生成 Java 应用程序。

使用 Node.js SDK

从 Node.js SDK 返回的对象公开一个 headers 子对象，该子对象映射基础 HTTP API 返回的所有标头。请求费用在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'];
}

有关详细信息，请参阅快速入门：使用 Azure Cosmos DB for NoSQL 帐户生成 Node.js 应用。

使用 Python SDK

Container来自Python SDK的对象公开了一个字典，其中映射了上一次执行的操作的基础 HTTP API 返回的所有标头。请求费用在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"]

有关详细信息，请参阅快速入门：使用 Azure Cosmos DB for NoSQL 帐户生成 Python 应用。

使用 Go SDK

响应是 Azure Cosmos DB 中所有响应的基本响应类型。它公开一个 RequestCharge 属性，其中包含相应操作的请求费用信息，例如读取、写入和查询。

读取操作

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

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

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

查询操作：

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

后续步骤

若要了解如何优化 RU 消耗量，请参阅以下文章：

Last updated on 2026-01-14