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

Artículo
11/14/2024

适用范围： 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，请参阅 API for MongoDB、API for Cassandra、API for Gremlin 和 API for Table。

目前，若要度量消耗，只能使用 Azure 门户，或者通过 SDK 之一检查从 Azure Cosmos DB 发送的响应。如果使用 API for NoSQL，则可以使用多个选项来查找某个操作的请求费用。

使用 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 中的 API for NoSQL 帐户生成 .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

从 Python SDK 返回的 Container 对象公开 last_response_headers 字典，该字典可映射底层 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 应用。

后续步骤

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

Compartir a través de