Hitta enhetsavgiften för begäranden för åtgärder i Azure Cosmos DB för NoSQL

Artikel
10/18/2023

GÄLLER FÖR: NoSQL

Azure Cosmos DB stöder många API:er, till exempel SQL, MongoDB, Cassandra, Gremlin och Table. Varje API har en egen uppsättning databasåtgärder. Dessa åtgärder sträcker sig från enkla punktläsningar och skrivningar till komplexa frågor. Varje databasåtgärd förbrukar systemresurser baserat på åtgärdens komplexitet.

Kostnaden för alla databasåtgärder normaliseras av Azure Cosmos DB och uttrycks av ru-enheter (request units ). Begärandeavgiften är de enheter för begäran som förbrukas av alla dina databasåtgärder. Du kan se RU:er som en prestandavaluta som abstraherar systemresurser som CPU, IOPS och minne som krävs för att utföra databasåtgärder som stöds av Azure Cosmos DB. Oavsett vilket API du använder för att interagera med din container mäts kostnaderna alltid i RU:er. Oavsett om databasåtgärden är en skrivning, punktläsning eller fråga mäts kostnaderna alltid i RU:er. Mer information finns i Enheter för begäran i Azure Cosmos DB.

Den här artikeln beskriver de olika sätt som du kan hitta enhetsförbrukningen för begäranden för alla åtgärder som körs mot en container i Azure Cosmos DB för NoSQL. Om du använder ett annat API kan du läsa API för MongoDB, API för Cassandra, API för Gremlin och API för Table.

För närvarande kan du endast mäta förbrukning med hjälp av Azure-portalen eller genom att inspektera svaret som skickas från Azure Cosmos DB via någon av SDK:erna. Om du använder API:et för NoSQL har du flera alternativ för att hitta begärandeavgiften för en åtgärd.

Använda Azure Portal

Logga in på Azure-portalen.
Skapa ett nytt Azure Cosmos DB-konto och mata det med data, eller välj ett befintligt Azure Cosmos DB-konto som redan innehåller data.
Gå till fönstret Datautforskaren och välj sedan den container som du vill arbeta med.
Välj Ny SQL-fråga.
Ange en giltig fråga och välj sedan Kör fråga.
Välj Frågestatistik för att visa den faktiska begärandeavgiften för den begäran som du körde.

Objekt som returneras från .NET SDK v2 exponerar en RequestCharge egenskap:

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

Objekt som returneras från .NET SDK v3 exponerar en RequestCharge egenskap:

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

Mer information finns i Snabbstart: Skapa en .NET-webbapp med hjälp av ett API för NoSQL-konto i Azure Cosmos DB.

Använda Java SDK

Objekt som returneras från Java SDK exponerar en getRequestCharge() metod:

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

Mer information finns i Snabbstart: Skapa ett Java-program med hjälp av ett Azure Cosmos DB för NoSQL-konto.

Använda Node.js SDK

Objekt som returneras från Node.js SDK exponerar en headers underobjekt som mappar alla rubriker som returneras av det underliggande HTTP-API:et. Begärandeavgiften är tillgänglig under x-ms-request-charge nyckeln:

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

Mer information finns i Snabbstart: Skapa en Node.js-app med hjälp av ett Azure Cosmos DB för NoSQL-konto.

Använda Python SDK

Objektet Container från Python SDK exponerar en last_response_headers ordlista som mappar alla rubriker som returneras av det underliggande HTTP-API:et för den senaste åtgärden som kördes. Begärandeavgiften är tillgänglig under x-ms-request-charge nyckeln:

new_item = {
    "id": "70b63682-b93a-4c77-aad2-65501347265f",
    "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="70b63682-b93a-4c77-aad2-65501347265f"
    partition_key="61dba35b-4f02-45c5-b648-c6badc0cbd79"
)

request_charge = container.client_connection.last_response_headers["x-ms-request-charge"]

Mer information finns i Snabbstart: Skapa en Python-app med hjälp av ett Azure Cosmos DB för NoSQL-konto.

Nästa steg

Mer information om hur du optimerar RU-förbrukningen finns i följande artiklar: