De kosten voor aanvraageenheden voor bewerkingen zoeken in Azure Cosmos DB for NoSQL

Artikel
11/07/2024

VAN TOEPASSING OP: NoSQL

Azure Cosmos DB ondersteunt veel API's, zoals SQL, MongoDB, Cassandra, Gremlin en Table. Elke API heeft een eigen set databasebewerkingen. Deze bewerkingen variëren van eenvoudige puntlees- en schrijfbewerkingen tot complexe query's. Elke databasebewerking verbruikt systeembronnen op basis van de complexiteit van de bewerking.

De kosten van alle databasebewerkingen worden genormaliseerd door Azure Cosmos DB en worden uitgedrukt in aanvraageenheden (RU). Aanvraagkosten zijn de aanvraageenheden die worden verbruikt door al uw databasebewerkingen. U kunt RU's beschouwen als een prestatievaluta die de systeemresources abstraheert, zoals CPU, IOPS en geheugen die nodig zijn om de databasebewerkingen uit te voeren die worden ondersteund door Azure Cosmos DB. Ongeacht welke API u gebruikt om te communiceren met uw container, worden de kosten altijd gemeten in RU's. Of de databasebewerking nu een schrijf-, puntlees-of querybewerking is, de kosten worden altijd gemeten in RU/s. Zie Aanvraageenheden in Azure Cosmos DB voor meer informatie.

Dit artikel bevat de verschillende manieren waarop u het verbruik van de aanvraageenheid kunt vinden voor elke bewerking die wordt uitgevoerd op een container in Azure Cosmos DB voor NoSQL. Als u een andere API gebruikt, raadpleegt u API voor MongoDB, API voor Cassandra, API voor Gremlin en API voor Table.

Op dit moment kunt u het verbruik alleen meten met behulp van Azure Portal of door het antwoord dat vanuit Azure Cosmos DB wordt verzonden te inspecteren via een van de SDK's. Als u de API voor NoSQL gebruikt, hebt u meerdere opties voor het vinden van de aanvraagkosten voor een bewerking.

De Azure-portal gebruiken

Meld u aan bij het Azure-portaal.
Maak een nieuw Azure Cosmos DB-account en voer dit in met gegevens of selecteer een bestaand Azure Cosmos DB-account dat al gegevens bevat.
Ga naar het deelvenster Data Explorer en selecteer vervolgens de container waaraan u wilt werken.
Selecteer New SQL Query.
Voer een geldige query in en selecteer Vervolgens Query uitvoeren.
Selecteer Querystatistieken om de werkelijke aanvraagkosten weer te geven voor de aanvraag die u hebt uitgevoerd.

Objecten die worden geretourneerd vanuit de .NET SDK v2 , maken een RequestCharge eigenschap beschikbaar:

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

Objecten die worden geretourneerd vanuit de .NET SDK v3 , maken een RequestCharge eigenschap beschikbaar:

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

Zie quickstart: Een .NET-web-app bouwen met behulp van een API voor NoSQL-account in Azure Cosmos DB voor meer informatie.

De Java SDK gebruiken

Objecten die worden geretourneerd vanuit de Java SDK maken een getRequestCharge() methode beschikbaar:

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

Zie quickstart: Een Java-toepassing bouwen met behulp van een Azure Cosmos DB for NoSQL-account voor meer informatie.

De Node.js SDK gebruiken

Objecten die worden geretourneerd vanuit de Node.js SDK maken een headers subobject beschikbaar waarmee alle headers worden toegewezen die worden geretourneerd door de onderliggende HTTP-API. De aanvraagkosten zijn beschikbaar onder de x-ms-request-charge sleutel:

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

Zie quickstart: Een Node.js-app bouwen met behulp van een Azure Cosmos DB for NoSQL-account voor meer informatie.

De Python-SDK gebruiken

Het Container object van de Python SDK toont een last_response_headers woordenlijst waarmee alle headers die worden geretourneerd door de onderliggende HTTP-API, worden toegewezen voor de laatste bewerking die is uitgevoerd. De aanvraagkosten zijn beschikbaar onder de x-ms-request-charge sleutel:

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"]

Zie quickstart: Een Python-app bouwen met behulp van een Azure Cosmos DB for NoSQL-account voor meer informatie.

Volgende stappen

Zie de volgende artikelen voor meer informatie over het optimaliseren van uw RU-verbruik:

Share via