Rechercher les frais unitaires de requête pour les opérations dans Azure Cosmos DB pour NoSQL

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 est normalisé par Azure Cosmos DB et est exprimé par unités de requête (RU). Les frais de requête sont les 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 que vous utilisez pour interagir avec votre conteneur, les coûts sont toujours mesurés en RUs. 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 plus d’informations, consultez Unités de requête dans Azure Cosmos DB.

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

Actuellement, vous pouvez mesurer la consommation uniquement à l’aide du portail Azure ou en inspectant la réponse envoyée à partir d’Azure Cosmos DB via l’un des kits SDK. Si vous utilisez l’API pour NoSQL, vous avez plusieurs options pour rechercher les frais de demande pour une opération.

Utilisation du portail Azure

Connectez-vous au portail Azure.
Créez un compte Azure Cosmos DB et alimentez-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 souhaitez travailler.
Sélectionnez Nouvelle requête SQL.
Entrez une requête valide, puis sélectionnez Exécuter la requête.
Sélectionnez Statistiques de requête pour afficher les frais de requête réels pour 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 RequestCharge propriété :

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 par le Kit de développement logiciel (SDK) .NET v3 exposent une RequestCharge propriété :

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 : Créer une application web .NET à l’aide d’une API pour un compte NoSQL dans Azure Cosmos DB.

Utiliser le SDK Java

Les objets retournés par le Kit de développement logiciel (SDK) Java exposent une getRequestCharge() méthode :

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 : Créer une application Java à l’aide d’un compte Azure Cosmos DB pour NoSQL.

Utiliser le SDK Node.js

Les objets retournés par le KIT de développement logiciel (SDK)Node.js exposent un headers sous-objet 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 : Créer une application Node.js à l’aide d’un compte Azure Cosmos DB pour NoSQL.

Utiliser le Kit de développement logiciel (SDK) Python

L’objet Container du Kit de développement logiciel (SDK) Python expose un last_response_headers dictionnaire 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 : Créer une application Python à l’aide d’un compte Azure Cosmos DB pour NoSQL.

Utiliser le Kit de développement logiciel (SDK) Go

La réponse est le type de réponse de base pour toutes les réponses d’Azure Cosmos DB. Elle expose une propriété RequestCharge comportant les frais de demande pour l’opération concernée, comme les lectures, les écritures et les requêtes.

Opération de lecture :

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

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

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

Opération de requête :

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

Étapes suivantes

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

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-12-19