Búsqueda del cargo de la unidad de solicitud en las operaciones de Azure Cosmos DB for NoSQL

Artículo
06/01/2023

SE APLICA A: NoSQL

Azure Cosmos DB admite varias API, como SQL, MongoDB, Cassandra, Gremlin y Table. Cada API tiene su propio conjunto de operaciones de base de datos. Estas abarcan desde sencillas lecturas y escrituras de punto hasta consultas complejas. Cada operación de base de datos consume recursos del sistema en función de la complejidad de la operación.

Azure Cosmos DB normaliza el coste de todas las operaciones de base de datos, que se expresa en unidades de solicitud (RU). La solicitud de cargos son las unidades de solicitud que consumen todas las operaciones de base de datos. Puede considerar que las unidades de solicitud son como una moneda de rendimiento, que resume los recursos del sistema, como CPU, IOPS y memoria, necesarios para realizar las operaciones de base de datos compatibles con Azure Cosmos DB. Con independencia de qué API utilice para interactuar con el contenedor, los costos siempre se miden en RU. Si la operación de base de datos es una escritura, lectura puntual o consulta, los costos siempre se miden en RU. Para obtener más información, consulte Unidades de solicitud en Azure Cosmos DB.

En este artículo se presentan las distintas formas de encontrar el consumo de unidades de solicitud de cualquier operación que se ejecute en un contenedor en Azure Cosmos DB for NoSQL. Si usa una API diferente, consulte API para MongoDB, API para Cassandra, API para Gremlin y API para Table.

Actualmente, puede medir el consumo solo con Azure Portal o por medio de la inspección de la respuesta enviada desde Azure Cosmos DB mediante uno de los SDK. Si usa la API para NoSQL, tiene varias opciones para buscar el cargo de solicitudes de una operación.

Uso de Azure Portal

Inicie sesión en Azure Portal.
Cree una cuenta de Azure Cosmos DB y suminístrele datos, o seleccione una cuenta existente de Azure Cosmos DB que ya contenga datos.
Vaya al panel Data Explorer y seleccione el contenedor en el que quiere trabajar.
Seleccione Nueva consulta SQL.
Escriba una consulta válida y, luego, seleccione Ejecutar consulta.
Seleccione Query Stats (Estadísticas de consulta) para mostrar el cargo de solicitud real correspondiente a la solicitud que ha ejecutado.

Los objetos devueltos desde el SDK de .NET v2 exponen una propiedad 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;
}

Los objetos que se devuelven desde el SDK de .NET v3 exponen una propiedad RequestCharge:

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

Para obtener más información, vea Inicio rápido: Compilación de una aplicación web de .NET mediante una cuenta de la API para NoSQL en Azure Cosmos DB.

Uso del SDK de Java

Los objetos devueltos desde el SDK de Java exponen un método 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();
});

Para obtener más información, vea Inicio rápido: Compilación de una aplicación de Java mediante una cuenta de Azure Cosmos DB for NoSQL.

Uso del SDK de Node.js

Los objetos devueltos por el SDK de Node.js exponen un subobjeto headers que asigna todos los encabezados devueltos por la API HTTP subyacente. El cargo de solicitud está disponible en la clave 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'];
}

Para obtener más información, vea Inicio rápido: Compilación de una aplicación de Node.js mediante una cuenta de Azure Cosmos DB for NoSQL.

Uso del SDK de Python

El objeto Container del SDK de Python expone un diccionario last_response_headers que asigna todos los encabezados devueltos por la API HTTP subyacente de la última operación ejecutada. El cargo de solicitud está disponible en la clave x-ms-request-charge:

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

Para obtener más información, vea Inicio rápido: Compilación de una aplicación de Python mediante una cuenta de Azure Cosmos DB for NoSQL.

Pasos siguientes

Para obtener información sobre cómo optimizar el consumo de RU, vea estos artículos: