Ermitteln der Gebühr für Anforderungseinheiten für Vorgänge in Azure Cosmos DB for NoSQL

Artikel
06/01/2023

GILT FÜR: NoSQL

Azure Cosmos DB unterstützt viele APIs wie z.B. SQL, MongoDB, Cassandra, Gremlin und Tabelle. Jede API verfügt über einen eigenen Satz von Datenbankvorgängen. Diese Vorgänge reichen von einfachen Lese- und Schreibvorgängen für Datenpunkte bis hin zu komplexen Abfragen. Jeder Datenbankvorgang beansprucht je nach Komplexität eine bestimmte Menge an Systemressourcen.

Die Kosten sämtlicher Datenbankvorgänge werden von Azure Cosmos DB normalisiert und als Anforderungseinheiten (Request Units, RUs) ausgedrückt. Die Anforderungsgebühr entspricht den insgesamt für Ihre Datenbankvorgänge genutzten Anforderungseinheiten. Sie können sich Anforderungseinheiten als Währung zur Abstrahierung der Systemressourcen wie CPU, IOPS und Arbeitsspeicher vorstellen, die zum Ausführen der von Azure Cosmos DB unterstützten Datenbankvorgänge erforderlich sind. Unabhängig davon, welche API Sie für die Interaktion mit Ihrem Container verwenden, werden die Kosten immer in RUs gemessen. Unabhängig davon, ob es sich bei dem Datenbankvorgang um einen Schreib-, Lese- oder Abfragevorgang handelt, werden die Kosten immer in RUs gemessen. Weitere Informationen finden Sie unter Anforderungseinheiten in Azure Cosmos DB.

In diesem Artikel werden verschiedene Methoden beschrieben, mit denen Sie den Verbrauch von Anforderungseinheiten für einen beliebigen Vorgang ermitteln können, der für einen Container in Azure Cosmos DB for NoSQL ausgeführt wurde. Wenn Sie eine andere API verwenden, finden Sie weitere Informationen in den Artikeln zur API für MongoDB, API für Cassandra, API für Gremlin, und API für Table.

Aktuell können Sie den Verbrauch nur über das Azure-Portal oder mithilfe eines der SDKs anhand der von Azure Cosmos DB zurückgegebenen Antwort ermitteln. Wenn Sie die API für NoSQL verwenden, bestehen mehrere Optionen zum Ermitteln der Anforderungsgebühr für einen Vorgang.

Verwenden des Azure-Portals

Melden Sie sich beim Azure-Portal an.
Erstellen Sie ein neues Azure Cosmos DB-Konto, und fügen Sie ihm Daten hinzu, oder wählen Sie ein vorhandenes Azure Cosmos DB-Konto aus, das bereits Daten enthält.
Wechseln Sie zum Bereich Daten-Explorer, und wählen Sie dann den gewünschten Container aus.
Wählen Sie Neue SQL-Abfrage aus.
Geben Sie eine gültige Abfrage ein, und wählen Sie dann Abfrage ausführen aus.
Wählen Sie Query Stats (Abfragestatistik) aus, um die tatsächliche Anforderungsgebühr für die ausgeführte Anforderung anzuzeigen.

Objekte, die vom .NET SDK v2 zurückgegeben werden, machen eine Eigenschaft RequestCharge verfügbar:

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

Objekte, die vom .NET SDK v3 zurückgegeben werden, machen eine RequestCharge-Eigenschaft verfügbar:

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

Weitere Informationen finden Sie unter Schnellstart: Erstellen einer .NET-Web-App mithilfe eines API für NoSQL-Kontos in Azure Cosmos DB.

Verwenden des Java SDK

Objekte, die vom Java SDK zurückgegeben werden, machen eine Methode getRequestCharge() verfügbar:

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

Weitere Informationen finden Sie unter Schnellstart: Erstellen einer Java-Anwendung mithilfe eines Azure Cosmos DB for NoSQL-Kontos.

Verwenden des Node.js SDK

Vom Node.js SDK zurückgegebene Objekte machen ein Unterobjekt headers verfügbar, das alle von der zugrunde liegenden HTTP-API zurückgegebenen Header zuordnet. Die Anforderungsgebühr ist unter dem Schlüssel x-ms-request-charge verfügbar:

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

Weitere Informationen finden Sie unter Schnellstart: Erstellen einer Node.js-App mithilfe eines Azure Cosmos DB for NoSQL-Kontos.

Verwenden des Python SDK

Das Objekt Container des Python SDK macht ein Wörterbuch last_response_headers verfügbar, das alle Header zuordnet, die von der zugrunde liegenden HTTP-API für den letzten ausgeführten Vorgang zurückgegeben wurden. Die Anforderungsgebühr ist unter dem Schlüssel x-ms-request-charge verfügbar:

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

Weitere Informationen finden Sie unter Schnellstart: Erstellen einer Python-App mithilfe eines Azure Cosmos DB for NoSQL-Kontos.

Nächste Schritte

Informationen zum Optimieren Ihres RU-Verbrauchs finden Sie in diesen Artikeln: