Cet article explique comment activer le débit de mise à l’échelle automatique sur une base de données ou un conteneur (collection, graphique ou table) dans Azure Cosmos DB pour NoSQL. Vous pouvez activer la mise à l’échelle automatique sur un seul conteneur ou approvisionner le débit avec mise à l’échelle automatique sur une base de données et le partager entre tous les conteneurs de cette base de données.
Si vous utilisez une autre API, consultez l’API pour MongoDB, l’API pour Cassandra ou l’API pour Gremlin.
Portail Azure
Créer une base de données ou un conteneur avec mise à l’échelle automatique
Connectez-vous au portail Azure ou à l’Explorateur Azure Cosmos DB.
Accédez à votre compte Azure Cosmos DB et ouvrez l’onglet Explorateur de données.
Sélectionnez Nouveau conteneur. Entrez un nom pour votre base de données et votre conteneur ainsi qu’une clé de partition.
Sous Débit de la base de données ou d’un conteneur, sélectionnez l’option Mise à l’échelle automatique et définissez le débit maximal (RU/s) auquel vous souhaitez que la base de données ou le conteneur soit mis à l’échelle.
Sélectionnez OK.
Pour configurer la mise à l’échelle automatique sur une base de données à débit partagé, sélectionnez l’option Approvisionner le débit d’une base de données lors de la création d’une base de données.
Remarque
La définition du débit au niveau de la base de données est recommandée uniquement pour le développement/test ou lorsque la charge de travail sur tous les conteneurs de la base de données de débit partagé est uniforme. Pour des performances optimales pour les charges de travail de production volumineuses, il est recommandé de définir un débit dédié (mise à l’échelle automatique ou manuelle) au niveau du conteneur et non au niveau de la base de données.
Activer la mise à l’échelle automatique sur une base de données ou un conteneur existant
Connectez-vous au portail Azure ou à l’Explorateur Azure Cosmos DB.
Accédez à votre compte Azure Cosmos DB et ouvrez l’onglet Explorateur de données.
Sélectionnez Mise à l’échelle et paramètres pour votre conteneur ou Mise à l’échelle pour votre base de données.
Sous Mise à l’échelle, sélectionnez l’option Mise à l’échelle automatique, puis Enregistrer.
Remarque
Lorsque vous activez la mise à l’échelle automatique sur une base de données ou un conteneur existant, la valeur de départ pour le nombre maximum de RU/s est déterminée par le système, en fonction de vos paramètres de débit approvisionné manuellement et de votre stockage. Une fois l’opération terminée, vous pouvez modifier le nombre maximal de RU/s si nécessaire. Pour plus d’informations, consultez questions fréquentes sur la mise à l'échelle automatique du débit provisionné.
Kits de Développement Logiciel
Utilisez les kits SDK suivants pour gérer les ressources de mise à l’échelle automatique :
Créer une base de données avec débit partagé
Remarque
La définition du débit au niveau de la base de données est recommandée uniquement pour le développement/test ou lorsque la charge de travail sur tous les conteneurs de la base de données de débit partagé est uniforme. Pour des performances optimales pour les charges de travail de production volumineuses, il est recommandé de définir un débit dédié (mise à l’échelle automatique ou manuelle) au niveau du conteneur et non au niveau de la base de données.
Utilisez la version 3.9 ou ultérieure du Kit de développement logiciel (SDK) .NET Azure Cosmos DB pour l’API pour NoSQL pour gérer les ressources avec mise à l’échelle automatique.
Important
Vous pouvez utiliser le Kit de développement logiciel (SDK) .NET pour créer des ressources avec mise à l’échelle automatique. Le Kit de développement logiciel (SDK) ne prend pas en charge la migration entre le débit de mise à l’échelle automatique et le débit standard (manuel). Actuellement, le scénario de migration est pris en charge uniquement dans le portail Azure, l’interface CLI et PowerShell.
Remarque
Lorsque vous activez la mise à l’échelle automatique sur une base de données ou un conteneur existant, la valeur de départ pour le nombre maximum de RU/s est déterminée par le système, en fonction de vos paramètres de débit approvisionné manuellement et de votre stockage. Une fois l’opération terminée, vous pouvez modifier le nombre maximal de RU/s si nécessaire. Pour plus d’informations, consultez questions fréquentes sur la mise à l'échelle automatique du débit provisionné.
// Create instance of CosmosClient
CosmosClient cosmosClient = new CosmosClient(Endpoint, PrimaryKey);
// Autoscale throughput settings
ThroughputProperties autoscaleThroughputProperties = ThroughputProperties.CreateAutoscaleThroughput(1000); //Set autoscale max RU/s
//Create the database with autoscale enabled
database = await cosmosClient.CreateDatabaseAsync(DatabaseName, throughputProperties: autoscaleThroughputProperties);
Vous pouvez utiliser la version 4.0 ou ultérieure du Kit de développement logiciel (SDK) Java Azure Cosmos DB pour API pour NoSQL pour gérer les ressources avec mise à l’échelle automatique.
Important
Vous pouvez utiliser le Kit de développement logiciel (SDK) Java pour créer des ressources avec mise à l’échelle automatique. Le Kit de développement logiciel (SDK) ne prend pas en charge la migration entre le débit de mise à l’échelle automatique et le débit standard (manuel). Actuellement, le scénario de migration est pris en charge uniquement dans le portail Azure, l’interface CLI et PowerShell.
Remarque
Lorsque vous activez la mise à l’échelle automatique sur une base de données ou un conteneur existant, la valeur de départ pour le nombre maximum de RU/s est déterminée par le système, en fonction de vos paramètres de débit approvisionné manuellement et de votre stockage. Une fois l’opération terminée, vous pouvez modifier le nombre maximal de RU/s si nécessaire. Pour plus d’informations, consultez questions fréquentes sur la mise à l'échelle automatique du débit provisionné.
Asynchrone
// Create instance of CosmosClient
CosmosAsyncClient client = new CosmosClientBuilder()
.setEndpoint(HOST)
.setKey(PRIMARYKEY)
.setConnectionPolicy(CONNECTIONPOLICY)
.buildAsyncClient();
// Autoscale throughput settings
ThroughputProperties autoscaleThroughputProperties = ThroughputProperties.createAutoscaledThroughput(1000); //Set autoscale max RU/s
//Create the database with autoscale enabled
CosmosAsyncDatabase database = client.createDatabase(databaseName, autoscaleThroughputProperties).block().getDatabase();
Synchronisation
// Create instance of CosmosClient
CosmosClient client = new CosmosClientBuilder()
.setEndpoint(HOST)
.setKey(PRIMARYKEY)
.setConnectionPolicy(CONNECTIONPOLICY)
.buildClient();
// Autoscale throughput settings
ThroughputProperties autoscaleThroughputProperties = ThroughputProperties.createAutoscaledThroughput(1000); //Set autoscale max RU/s
//Create the database with autoscale enabled
CosmosDatabase database = client.createDatabase(databaseName, autoscaleThroughputProperties).getDatabase();
Important
Vous pouvez utiliser le Kit de développement logiciel (SDK) Python pour créer de nouvelles ressources de mise à l’échelle automatique. Le Kit de développement logiciel (SDK) ne prend pas en charge la migration entre le débit de mise à l’échelle automatique et le débit standard (manuel). Actuellement, le scénario de migration est pris en charge uniquement dans le portail Azure, l’interface CLI et PowerShell.
Remarque
Lorsque vous activez la mise à l’échelle automatique sur une base de données ou un conteneur existant, la valeur de départ pour le nombre maximum de RU/s est déterminée par le système, en fonction de vos paramètres de débit approvisionné manuellement et de votre stockage. Une fois l’opération terminée, vous pouvez modifier le nombre maximal de RU/s si nécessaire. Pour plus d’informations, consultez questions fréquentes sur la mise à l'échelle automatique du débit provisionné.
Synchronisation
from azure.cosmos import CosmosClient, ThroughputProperties
# Create your CosmosClient instance
client = CosmosClient(host, credential)
# Autoscale throughput settings
throughput_properties = ThroughputProperties(auto_scale_max_throughput=5000) #Set autoscale max RU/s
#Create the database with autoscale enabled
client.create_database(id=database_id, offer_throughput=throughput_properties)
Asynchrone
from azure.cosmos import ThroughputProperties
from azure.cosmos.aio import CosmosClient
# Create your CosmosClient instance
async with CosmosClient(host, credential) as client:
# Autoscale throughput settings
throughput_properties = ThroughputProperties(auto_scale_max_throughput=5000) #Set autoscale max RU/s
#Create the database with autoscale enabled
await client.create_database(id=database_id, offer_throughput=throughput_properties)
Vous pouvez utiliser ThroughputProperties sur les ressources de base de données et de conteneur.
Important
Vous pouvez utiliser le Kit de développement logiciel (SDK) Go pour créer de nouvelles ressources de mise à l’échelle automatique. Le Kit de développement logiciel (SDK) ne prend pas en charge la migration entre le débit de mise à l’échelle automatique et le débit standard (manuel). Actuellement, le scénario de migration est pris en charge uniquement dans le portail Azure, l’interface CLI et PowerShell.
Remarque
Lorsque vous activez la mise à l’échelle automatique sur une base de données ou un conteneur existant, la valeur de départ pour le nombre maximum de RU/s est déterminée par le système, en fonction de vos paramètres de débit approvisionné manuellement et de votre stockage. Une fois l’opération terminée, vous pouvez modifier le nombre maximal de RU/s si nécessaire. Pour plus d’informations, consultez questions fréquentes sur la mise à l'échelle automatique du débit provisionné.
// autoscale throughput properties
db_throughput := azcosmos.NewAutoscaleThroughputProperties(4000)
_, err = client.CreateDatabase(context.Background(), azcosmos.DatabaseProperties{
ID: "demo_db",
}, &azcosmos.CreateDatabaseOptions{
ThroughputProperties: &db_throughput,
})
Créer un conteneur avec débit dédié
// Get reference to database that container will be created in
Database database = await cosmosClient.GetDatabase("DatabaseName");
// Container and autoscale throughput settings
ContainerProperties autoscaleContainerProperties = new ContainerProperties("ContainerName", "/partitionKey");
ThroughputProperties autoscaleThroughputProperties = ThroughputProperties.CreateAutoscaleThroughput(1000); //Set autoscale max RU/s
// Create the container with autoscale enabled
container = await database.CreateContainerAsync(autoscaleContainerProperties, autoscaleThroughputProperties);
Asynchrone
// Get reference to database that container will be created in
CosmosAsyncDatabase database = client.createDatabase("DatabaseName").block().getDatabase();
// Container and autoscale throughput settings
CosmosContainerProperties autoscaleContainerProperties = new CosmosContainerProperties("ContainerName", "/partitionKey");
ThroughputProperties autoscaleThroughputProperties = ThroughputProperties.createAutoscaledThroughput(1000); //Set autoscale max RU/s
// Create the container with autoscale enabled
CosmosAsyncContainer container = database.createContainer(autoscaleContainerProperties, autoscaleThroughputProperties, new CosmosContainerRequestOptions())
.block()
.getContainer();
Synchronisation
// Get reference to database that container will be created in
CosmosDatabase database = client.createDatabase("DatabaseName").getDatabase();
// Container and autoscale throughput settings
CosmosContainerProperties autoscaleContainerProperties = new CosmosContainerProperties("ContainerName", "/partitionKey");
ThroughputProperties autoscaleThroughputProperties = ThroughputProperties.createAutoscaledThroughput(1000); //Set autoscale max RU/s
// Create the container with autoscale enabled
CosmosContainer container = database.createContainer(autoscaleContainerProperties, autoscaleThroughputProperties, new CosmosContainerRequestOptions())
.getContainer();
Synchronisation
from azure.cosmos import CosmosClient, ThroughputProperties
# Create your CosmosClient instance
client = CosmosClient(host, credential)
# Get your DatabaseProxy object
database = client.get_database_client(database_id)
# Autoscale throughput settings
throughput_properties = ThroughputProperties(auto_scale_max_throughput=5000) #Set autoscale max RU/s
#Create the container with autoscale enabled
database.create_container(id=container_id, partition_key=partition_key, offer_throughput=throughput_properties)
Asynchrone
from azure.cosmos import ThroughputProperties
from azure.cosmos.aio import CosmosClient
# Create your CosmosClient instance
async with CosmosClient(host, credential) as client:
# Get your DatabaseProxy object
database = client.get_database_client(database_id)
# Autoscale throughput settings
throughput_properties = ThroughputProperties(auto_scale_max_throughput=5000) #Set autoscale max RU/s
#Create the container with autoscale enabled
await database.create_container(id=container_id, partition_key=partition_key, offer_throughput=throughput_properties)
pkDefinition := azcosmos.PartitionKeyDefinition{
Paths: []string{"/state"},
Kind: azcosmos.PartitionKeyKindHash,
}
// autoscale throughput properties
throughput := azcosmos.NewAutoscaleThroughputProperties(4000)
db.CreateContainer(context.Background(), azcosmos.ContainerProperties{
ID: "demo_container",
PartitionKeyDefinition: pkDefinition,
}, &azcosmos.CreateContainerOptions{
ThroughputProperties: &throughput,
})
Lire le débit actuel (RU/s)
// Get a reference to the resource
Container container = cosmosClient.GetDatabase("DatabaseName").GetContainer("ContainerName");
// Read the throughput on a resource
ThroughputProperties autoscaleContainerThroughput = await container.ReadThroughputAsync(requestOptions: null);
// The autoscale max throughput (RU/s) of the resource
int? autoscaleMaxThroughput = autoscaleContainerThroughput.AutoscaleMaxThroughput;
// The throughput (RU/s) the resource is currently scaled to
int? currentThroughput = autoscaleContainerThroughput.Throughput;
Asynchrone
// Get a reference to the resource
CosmosAsyncContainer container = client.getDatabase("DatabaseName").getContainer("ContainerName");
// Read the throughput on a resource
ThroughputProperties autoscaleContainerThroughput = container.readThroughput().block().getProperties();
// The autoscale max throughput (RU/s) of the resource
int autoscaleMaxThroughput = autoscaleContainerThroughput.getAutoscaleMaxThroughput();
// The throughput (RU/s) the resource is currently scaled to
int currentThroughput = autoscaleContainerThroughput.Throughput;
Synchronisation
// Get a reference to the resource
CosmosContainer container = client.getDatabase("DatabaseName").getContainer("ContainerName");
// Read the throughput on a resource
ThroughputProperties autoscaleContainerThroughput = container.readThroughput().getProperties();
// The autoscale max throughput (RU/s) of the resource
int autoscaleMaxThroughput = autoscaleContainerThroughput.getAutoscaleMaxThroughput();
// The throughput (RU/s) the resource is currently scaled to
int currentThroughput = autoscaleContainerThroughput.Throughput;
Synchronisation
from azure.cosmos import CosmosClient, ThroughputProperties
# Create your CosmosClient instance
client = CosmosClient(host, credential)
# Get your DatabaseProxy object
database = client.get_database_client(database_id)
# Get your ContainerProxy object
container = database.get_container_client(container_id)
# Get your throughput settings
throughput = container.get_throughput()
# Get the autoscale max throughput (RU/s) of the resource
auto_scale_throughput = throughput.auto_scale_max_throughput
# Get the throughput (RU/s) the resource is currently scaled to
current_throughput = throughput.offer_throughput
Asynchrone
from azure.cosmos import ThroughputProperties
from azure.cosmos.aio import CosmosClient
# Create your CosmosClient instance
async with CosmosClient(host, credential) as client:
# Get your DatabaseProxy object
database = client.get_database_client(database_id)
# Get your ContainerProxy object
container = database.get_container_client(container_id)
# Get your throughput settings
throughput = await container.get_throughput()
# Get the autoscale max throughput (RU/s) of the resource
auto_scale_throughput = throughput.auto_scale_max_throughput
# Get the throughput (RU/s) the resource is currently scaled to
current_throughput = throughput.offer_throughput
Modifier le débit maximal avec mise à l’échelle automatique (RU/s)
// Change the autoscale max throughput (RU/s)
await container.ReplaceThroughputAsync(ThroughputProperties.CreateAutoscaleThroughput(newAutoscaleMaxThroughput));
Asynchrone
// Change the autoscale max throughput (RU/s)
container.replaceThroughput(ThroughputProperties.createAutoscaledThroughput(newAutoscaleMaxThroughput)).block();
Synchronisation
// Change the autoscale max throughput (RU/s)
container.replaceThroughput(ThroughputProperties.createAutoscaledThroughput(newAutoscaleMaxThroughput));
Synchronisation
from azure.cosmos import ThroughputProperties
# Change the autoscale max throughput (RU/s)
container.replace_throughput(ThroughputProperties(auto_scale_max_throughput=8000))
Asynchrone
from azure.cosmos import ThroughputProperties
# Change the autoscale max throughput (RU/s)
await container.replace_throughput(ThroughputProperties(auto_scale_max_throughput=8000))
Azure Resource Manager
Les modèles Azure Resource Manager peuvent être utilisés pour provisionner le débit avec mise à l’échelle automatique sur une nouvelle ressource de base de données ou au niveau du conteneur pour toutes les API Azure Cosmos DB. Pour obtenir des exemples, consultez les modèles Azure Resource Manager pour Azure Cosmos DB.
Par conception, les modèles Azure Resource Manager ne peuvent pas être utilisés pour migrer entre le débit provisionné et le débit de mise à l’échelle automatique sur une ressource existante.
Azure CLI (Interface de ligne de commande Azure)
Azure CLI peut être utilisé pour approvisionner le débit de mise à l’échelle automatique sur une nouvelle base de données ou une ressource au niveau du conteneur pour toutes les API Azure Cosmos DB, ou pour activer la mise à l’échelle automatique sur une ressource existante.
Azure PowerShell
Azure PowerShell peut être utilisé pour approvisionner le débit de mise à l’échelle automatique sur une nouvelle base de données ou une ressource au niveau du conteneur pour toutes les API Azure Cosmos DB, ou pour activer la mise à l’échelle automatique sur une ressource existante.
Étapes suivantes
