Rechercher les frais d’unités de requête pour les opérations dans Azure Cosmos DB for NoSQL

Article
11/07/2024

S’APPLIQUE À : NoSQL

Azure Cosmos DB prend en charge de nombreuses API, notamment SQL, MongoDB, Cassandra, Gremlin et Table. Chaque API possède son propre ensemble d’opérations de base de données, qui vont de simples opérations ponctuelles de lecture et d'écriture à des requêtes complexes. Chaque opération de base de données consomme des ressources système en fonction de sa complexité.

Le coût de toutes les opérations de base de données, normalisé par Azure Cosmos DB, est exprimé en unités de requête (RU). Les frais de requête correspondent aux unités de requête consommées par toutes vos opérations de base de données. Les RU correspondent en quelque sorte à une devise de performances, faisant abstraction des ressources système (UC, IOPS, mémoire, etc.) requises pour effectuer les opérations de base de données prises en charge par Azure Cosmos DB. Quelle que soit l’API utilisée pour interagir avec votre conteneur, les coûts sont toujours mesurés en unités de requête. Que l’opération de base de données soit une opération d’écriture, de lecture de point ou de requête, les coûts sont toujours mesurés en unités de requête. Pour en savoir plus, consultez Unités de requête dans Azure Cosmos DB.

Cet article présente les différentes façons de rechercher la consommation d’unités de requête pour toute opération exécutée sur un conteneur dans Azure Cosmos DB for NoSQL. Si vous utilisez une autre API, consultez les sections API pour MongoDB, API pour Cassandra, API pour Gremlin ou API pour Table.

Il n’est actuellement possible de mesurer la consommation que sur le portail Azure ou en examinant la réponse envoyée par Azure Cosmos DB via l’un des kits de développement logiciel (SDK). Si vous utilisez l’API pour NoSQL, vous disposez de plusieurs options pour trouver les frais de requête pour une opération.

Utilisation du portail Azure

Connectez-vous au portail Azure.
Créez un compte Azure Cosmos DB et remplissez-le avec des données, ou sélectionnez un compte Azure Cosmos DB existant qui contient déjà des données.
Accédez au volet Explorateur de données, puis sélectionnez le conteneur sur lequel vous voulez travailler.
Sélectionnez Nouvelle requête SQL.
Entrez une requête valide, puis sélectionnez Exécuter la requête.
Sélectionnez Statistiques des requêtes pour afficher les frais réels de la demande que vous avez exécutée.

Utiliser le kit de développement logiciel (SDK) .NET

Kit de développement logiciel (SDK) .NET V2
Kit de développement logiciel (SDK) .NET V3

Les objets retournés à partir du Kit de développement logiciel (SDK) .NET v2 exposent une propriété 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;
}

Les objets retournés à partir du SDK .NET v3 exposent une propriété 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));
_ = 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;
}

Pour plus d’informations, consultez Démarrage rapide : Générer une application web .NET à l’aide d’un compte d’API pour NoSQL dans Azure Cosmos DB.

Utiliser le SDK Java

Les objets retournés à partir du Kit de développement logiciel Java exposent une méthode 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();
});

Pour plus d’informations, consultez Démarrage rapide : Générer une application Java à l’aide d’un compte Azure Cosmos DB for NoSQL.

Utiliser le SDK Node.js

Les objets retournés à partir du Kit de développement logiciel (SDK) Node.js exposent un sous-objet headers qui mappe tous les en-têtes retournés par l’API HTTP sous-jacente. Les frais de demande sont disponibles sous la clé 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'];
}

Pour plus d’informations, consultez Démarrage rapide : Générer une application Node.js à l’aide d’un compte Azure Cosmos DB for NoSQL.

Utiliser le SDK Python

L’objet Container retourné à partir du Kit de développement logiciel (SDK) Python expose un dictionnaire last_response_headers qui mappe tous les en-têtes retournés par l’API HTTP sous-jacente pour la dernière opération exécutée. Les frais de demande sont disponibles sous la clé 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"]

Pour plus d’informations, consultez Démarrage rapide : Générer une application Python à l’aide d’un compte Azure Cosmos DB for NoSQL.

Étapes suivantes

Pour en savoir plus sur l’optimisation de votre consommation d’unités de requête, consultez les articles suivants :

Partager via