Znajdź opłatę za jednostkę żądania dla operacji w usłudze Azure Cosmos DB dla NoSQL

Dotyczy: ✅ NoSQL

Usługa Azure Cosmos DB obsługuje wiele interfejsów API, takich jak SQL, MongoDB, Cassandra, Gremlin i Table. Każdy interfejs API ma własny zestaw operacji bazy danych. Te operacje obejmują od prostych odczytów i zapisów do złożonych zapytań. Każda operacja bazy danych zużywa zasoby systemowe na podstawie złożoności operacji.

Koszt wszystkich operacji bazy danych jest znormalizowany przez usługę Azure Cosmos DB i jest wyrażany przez jednostki żądań (RU). Koszt żądania to jednostki żądania wykorzystywane przez każdą operację w bazie danych. Jednostki RU można traktować jako walutę wydajności abstrakcyjną zasobów systemowych, takich jak procesor CPU, liczba operacji we/wy na sekundę i pamięć, które są wymagane do wykonywania operacji bazy danych obsługiwanych przez usługę Azure Cosmos DB. Niezależnie od tego, którego interfejsu API używasz do interakcji z kontenerem, koszty są zawsze mierzone w jednostkach RU. Niezależnie od tego, czy operacja bazy danych jest zapisem, odczytem punktu czy zapytaniem, koszty są zawsze mierzone w jednostkach RU. Aby dowiedzieć się więcej, zobacz Request Units in Azure Cosmos DB (Jednostki żądań w usłudze Azure Cosmos DB).

W tym artykule przedstawiono różne sposoby znajdowania konsumpcji jednostek żądania dla każdej operacji uruchamianej względem kontenera w usłudze Azure Cosmos DB dla NoSQL. Jeśli używasz innego interfejsu API, zobacz interfejs API dla bazy danych MongoDB, interfejs API dla bazy danych Cassandra, interfejs API dla języka Gremlin i interfejs API dla tabeli.

Obecnie można mierzyć zużycie tylko przy użyciu witryny Azure Portal lub sprawdzając odpowiedź wysłaną z usługi Azure Cosmos DB za pomocą jednego z zestawów SDK. Jeśli używasz interfejsu API dla NoSQL, masz wiele możliwości na ustalenie opłaty za żądanie dla operacji.

Korzystanie z witryny Azure Portal

Zaloguj się do witryny Azure Portal.
Utwórz nowe konto usługi Azure Cosmos DB i przekaż je za pomocą danych lub wybierz istniejące konto usługi Azure Cosmos DB, które zawiera już dane.
Przejdź do okienka Eksplorator danych , a następnie wybierz kontener, nad którym chcesz pracować.
Wybierz pozycję Nowe zapytanie SQL.
Wprowadź prawidłowe zapytanie, a następnie wybierz pozycję Wykonaj zapytanie.
Wybierz Statystyki zapytania, aby wyświetlić rzeczywisty koszt żądania wykonanego.

Korzystanie z zestawu SDK dla platformy .NET

.NET SDK w wersji 2
SDK .NET wersja 3

Obiekty zwracane z .NET SDK w wersji 2 udostępniają właściwość 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;
}

Obiekty zwracane z zestawu .NET SDK w wersji 3 uwidaczniają RequestCharge właściwość:

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

Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie aplikacji internetowej platformy .NET przy użyciu interfejsu API dla konta NoSQL w usłudze Azure Cosmos DB.

Korzystanie z zestawu Java SDK

Obiekty zwracane z zestawu JAVA SDK uwidaczniają metodę 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();
});

Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie aplikacji Java przy użyciu konta usługi Azure Cosmos DB for NoSQL.

Korzystanie z zestawu SDK Node.js

Obiekty zwracane z zestawu Node.js SDK udostępniają podobiekt, który mapuje wszystkie nagłówki zwracane przez bazowy interfejs API HTTP. Opłata za żądanie jest dostępna pod kluczem 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'];
}

Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie aplikacji Node.js przy użyciu konta usługi Azure Cosmos DB for NoSQL.

Używanie zestawu Python SDK

Container Obiekt z zestawu SDK języka Python udostępnia słownik, który mapuje wszystkie nagłówki zwrócone przez podstawowy interfejs API HTTP dla ostatniej wykonanej operacji. Opłata za żądanie jest dostępna pod kluczem 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"]

Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie aplikacji w języku Python przy użyciu konta usługi Azure Cosmos DB for NoSQL.

Korzystanie z zestawu GO SDK

Odpowiedź to podstawowy typ odpowiedzi dla wszystkich odpowiedzi z usługi Azure Cosmos DB. Udostępnia właściwość zawierającą opłatę za żądanie RequestCharge dla danej operacji, na przykład odczyty, zapisy i zapytania.

Operacja odczytu:

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

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

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

Operacja kwerendy:

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

Dalsze kroki

Aby dowiedzieć się więcej na temat optymalizacji użycia jednostek RU, zobacz następujące artykuły:

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-12-19