Migrera ditt program för att använda Azure Cosmos DB .NET SDK v3
GÄLLER FÖR: NoSQL
Viktigt
Mer information om Azure Cosmos DB .NET SDK v3 finns i Viktig information, .NET GitHub-lagringsplatsen, prestandatips för .NET SDK v3 och felsökningsguiden.
Den här artikeln beskriver några av övervägandena när du uppgraderar ditt befintliga .NET-program till nyare Azure Cosmos DB .NET SDK v3 för API för NoSQL. Azure Cosmos DB .NET SDK v3 motsvarar namnområdet Microsoft.Azure.Azure Cosmos DB. Du kan använda informationen i det här dokumentet om du migrerar ditt program från någon av följande Azure Cosmos DB .NET SDK:er:
- Azure Cosmos DB .NET Framework SDK v2 för API för NoSQL
- Azure Cosmos DB .NET Core SDK v2 för API för NoSQL
Anvisningarna i den här artikeln hjälper dig också att migrera följande externa bibliotek som nu ingår i Azure Cosmos DB .NET SDK v3 för API för NoSQL:
- .NET-ändringsflödesprocessorbibliotek 2.0
- .NET massexekutorbibliotek 1.1 eller senare
V3 SDK innehåller många förbättringar av användbarhet och prestanda, inklusive:
- Namngivning av intuitiv programmeringsmodell
- .NET Standard 2.0 **
- Ökad prestanda via stöd för stream-API
- Fluent-hierarki som ersätter behovet av URI-fabrik
- Inbyggt stöd för ändringsflödesprocessorbibliotek
- Inbyggt stöd för massåtgärder
- Modellerbara API:er för enklare enhetstestning
- Stöd för transaktionsbatch och Blazor
- Serialiserare som kan anslutas
- Skala icke-partitionerade containrar och autoskalningscontainrar
** SDK:et riktar sig mot .NET Standard 2.0 som förenar befintliga Azure Cosmos DB .NET Framework- och .NET Core SDK:er till en enda .NET SDK. Du kan använda .NET SDK på valfri plattform som implementerar .NET Standard 2.0, inklusive dina .NET Framework 4.6.1+ och .NET Core 2.0+-program.
De flesta nätverk, återförsökslogik och lägre nivåer i SDK:n förblir i stort sett oförändrade.
Azure Cosmos DB .NET SDK v3 är nu öppen källkod. Vi välkomnar alla pull-begäranden och kommer att logga problem och spåra feedback på GitHub. Vi kommer att arbeta med att ta på oss alla funktioner som förbättrar kundupplevelsen.
Utöver de många förbättringarna av användbarhet och prestanda kommer nya funktionsinvesteringar som gjorts i den senaste SDK:n inte att vara tillbaka portade till äldre versioner. V2 SDK är för närvarande i underhållsläge. För bästa möjliga utvecklingsupplevelse rekommenderar vi att du alltid börjar med den senaste versionen av SDK som stöds.
Följande namnändringar har tillämpats i .NET 3.0 SDK för att överensstämma med API-namngivningskonventionerna för API:et för NoSQL:
DocumentClient
har bytt namn tillCosmosClient
Collection
har bytt namn tillContainer
Document
har bytt namn tillItem
Alla resursobjekt byt namn med ytterligare egenskaper, vilket innehåller resursnamnet för tydlighetens skull.
Följande är några av de viktigaste klassnamnsändringarna:
.NET v2 SDK | .NET v3 SDK |
---|---|
Microsoft.Azure.Documents.Client.DocumentClient |
Microsoft.Azure.Cosmos.CosmosClient |
Microsoft.Azure.Documents.Client.ConnectionPolicy |
Microsoft.Azure.Cosmos.CosmosClientOptions |
Microsoft.Azure.Documents.Client.DocumentClientException |
Microsoft.Azure.Cosmos.CosmosException |
Microsoft.Azure.Documents.Client.Database |
Microsoft.Azure.Cosmos.DatabaseProperties |
Microsoft.Azure.Documents.Client.DocumentCollection |
Microsoft.Azure.Cosmos.ContainerProperties |
Microsoft.Azure.Documents.Client.RequestOptions |
Microsoft.Azure.Cosmos.ItemRequestOptions |
Microsoft.Azure.Documents.Client.FeedOptions |
Microsoft.Azure.Cosmos.QueryRequestOptions |
Microsoft.Azure.Documents.Client.StoredProcedure |
Microsoft.Azure.Cosmos.StoredProcedureProperties |
Microsoft.Azure.Documents.Client.Trigger |
Microsoft.Azure.Cosmos.TriggerProperties |
Microsoft.Azure.Documents.SqlQuerySpec |
Microsoft.Azure.Cosmos.QueryDefinition |
Följande klasser har ersatts på SDK:et 3.0:
Microsoft.Azure.Documents.UriFactory
Klassen Microsoft.Azure.Documents.UriFactory har ersatts av fluent-designen.
Container container = client.GetContainer(databaseName,containerName);
ItemResponse<SalesOrder> response = await this._container.CreateItemAsync(
salesOrder,
new PartitionKey(salesOrder.AccountNumber));
Microsoft.Azure.Documents.Document
Eftersom .NET v3 SDK tillåter användare att konfigurera en anpassad serialiseringsmotor, finns det ingen direkt ersättning för Document
typen. När du använder Newtonsoft.Json (standard serialiseringsmotor) JObject
kan du använda för att uppnå samma funktioner. När du använder en annan serialiseringsmotor kan du använda dess grundläggande json-dokumenttyp (till exempel JsonDocument
för System.Text.Json). Rekommendationen är att använda en C#-typ som återspeglar schemat för dina objekt i stället för att förlita sig på generiska typer.
Microsoft.Azure.Documents.Resource
Det finns ingen direkt ersättning för Resource
, i de fall där den användes för dokument följer du vägledningen för Document
.
Microsoft.Azure.Documents.AccessCondition
IfNoneMatch
eller IfMatch
är nu tillgängliga Microsoft.Azure.Cosmos.ItemRequestOptions
direkt.
Objekt-ID fylls inte längre i automatiskt i .NET v3 SDK. Därför måste objekt-ID:t specifikt innehålla ett genererat ID. Visa följande exempel:
[JsonProperty(PropertyName = "id")]
public Guid Id { get; set; }
SDK v3 är nu som standard Direct + TCP-anslutningslägen jämfört med föregående V2 SDK, som standard är Gateway + HTTPS-anslutningslägen. Den här ändringen ger bättre prestanda och skalbarhet.
Klassen FeedOptions
i SDK v2 har nu bytt namn till QueryRequestOptions
i SDK v3 och i klassen har flera egenskaper haft ändringar i namn och/eller standardvärde eller tagits bort helt.
.NET v2 SDK | .NET v3 SDK |
---|---|
FeedOptions.MaxDegreeOfParallelism |
QueryRequestOptions.MaxConcurrency – Standardvärdet och det associerade beteendet är detsamma, åtgärder som körs på klientsidan under parallell frågekörning körs seriellt utan parallellitet. |
FeedOptions.PartitionKey |
QueryRequestOptions.PartitionKey - Beteende upprätthålls. |
FeedOptions.EnableCrossPartitionQuery |
Avlägsnad. Standardbeteendet i SDK 3.0 är att frågor mellan partitioner körs utan att du behöver aktivera egenskapen specifikt. |
FeedOptions.PopulateQueryMetrics |
Avlägsnad. Den är nu aktiverad som standard och en del av diagnostiken. |
FeedOptions.RequestContinuation |
Avlägsnad. Den har nu befordrats till själva frågemetoderna. |
FeedOptions.JsonSerializerSettings |
Avlägsnad. Mer information finns i anpassa serialisering . |
FeedOptions.PartitionKeyRangeId |
Avlägsnad. Samma resultat kan hämtas från att använda FeedRange som indata till frågemetoden. |
FeedOptions.DisableRUPerMinuteUsage |
Avlägsnad. |
.NET SDK v3 tillhandahåller en fluent-klass CosmosClientBuilder
som ersätter behovet av SDK v2 URI Factory.
Fluent-designen skapar URL:er internt och gör att ett enda Container
objekt kan skickas runt i stället för , DocumentClient
DatabaseName
och DocumentCollection
.
I följande exempel skapas en ny CosmosClientBuilder
med en stark ConsistencyLevel och en lista över önskade platser:
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
accountEndpoint: "https://testcosmos.documents.azure.com:443/",
authKeyOrResourceToken: "SuperSecretKey")
.WithConsistencyLevel(ConsistencyLevel.Strong)
.WithApplicationRegion(Regions.EastUS);
CosmosClient client = cosmosClientBuilder.Build();
Om v2 SDK används DocumentClientException
för att signalera fel under åtgärder använder CosmosException
v3 SDK , som exponerar , Diagnostics
och annan svarsrelaterad StatusCode
information. All fullständig information serialiseras när ToString()
används:
catch (CosmosException ex)
{
HttpStatusCode statusCode = ex.StatusCode;
CosmosDiagnostics diagnostics = ex.Diagnostics;
// store diagnostics optionally with diagnostics.ToString();
// or log the entire error details with ex.ToString();
}
Om v2 SDK hade direktdiagnostik tillgänglig via RequestDiagnosticsString
egenskapen använder Diagnostics
V3 SDK tillgänglig i alla svar och undantag, som är rikare och inte begränsade till direktläge. De omfattar inte bara den tid som lagts på SDK:t för åtgärden, utan även de regioner som åtgärden kontaktade:
try
{
ItemResponse<MyItem> response = await container.ReadItemAsync<MyItem>(
partitionKey: new PartitionKey("MyPartitionKey"),
id: "MyId");
TimeSpan elapsedTime = response.Diagnostics.GetElapsedTime();
if (elapsedTime > somePreDefinedThreshold)
{
// log response.Diagnostics.ToString();
IReadOnlyList<(string region, Uri uri)> regions = response.Diagnostics.GetContactedRegions();
}
}
catch (CosmosException cosmosException) {
string diagnostics = cosmosException.Diagnostics.ToString();
TimeSpan elapsedTime = cosmosException.Diagnostics.GetElapsedTime();
IReadOnlyList<(string region, Uri uri)> regions = cosmosException.Diagnostics.GetContactedRegions();
// log cosmosException.ToString()
}
Vissa inställningar i ConnectionPolicy
har bytt namn eller ersatts av CosmosClientOptions
:
.NET v2 SDK | .NET v3 SDK |
---|---|
EnableEndpointDiscovery |
LimitToEndpoint - Värdet är nu inverterat, om EnableEndpointDiscovery har angetts till true , LimitToEndpoint bör anges till false . Innan du använder den här inställningen måste du förstå hur den påverkar klienten. |
ConnectionProtocol |
Avlägsnad. Protokollet är kopplat till läget, antingen gatewayen (HTTPS) eller direkt (TCP). Direktläge med HTTPS-protokoll stöds inte längre på V3 SDK och rekommendationen är att använda TCP-protokoll. |
MediaRequestTimeout |
Avlägsnad. Bifogade filer stöds inte längre. |
SetCurrentLocation |
CosmosClientOptions.ApplicationRegion kan användas för att uppnå samma effekt. |
PreferredLocations |
CosmosClientOptions.ApplicationPreferredRegions kan användas för att uppnå samma effekt. |
UserAgentSuffix |
CosmosClientBuilder.ApplicationName kan användas för att uppnå samma effekt. |
UseMultipleWriteLocations |
Avlägsnad. SDK identifierar automatiskt om kontot stöder flera skrivslutpunkter. |
I indexeringsprincipen går det inte att konfigurera dessa egenskaper. När de inte anges har de här egenskaperna alltid följande värden:
Egenskapsnamn | Nytt värde (kan inte konfigureras) |
---|---|
Kind |
range |
dataType |
String och Number |
Se det här avsnittet för indexering av principexempel för att inkludera och exkludera sökvägar. På grund av förbättringar i frågemotorn påverkar inte konfigurationen av dessa egenskaper, även om du använder en äldre SDK-version, prestanda.
Om v2 SDK exponerade sessionstoken för ett svar som ResourceResponse.SessionToken
för fall där insamling av sessionstoken krävdes, eftersom sessionstoken är en rubrik, exponerar v3 SDK det värdet i Headers.Session
egenskapen för alla svar.
Om v2 SDK exponerade tidsstämpeln för ett dokument via Timestamp
egenskapen, eftersom Document
den inte längre är tillgänglig, kan användarna mappa systemegenskapen _ts
till en egenskap i sin modell.
För användningsfall där OpenAsync()
användes för att värma upp V2 SDK-klienten CreateAndInitializeAsync
kan användas för att både skapa och värma upp en v3 SDK-klient.
V3 SDK har inbyggt stöd för API:erna för ändringsflödesprocessor, så att du kan använda samma SDK för att skapa din program- och ändringsflödesprocessorimplementering. Tidigare var du tvungen att använda ett separat ändringsflödesprocessorbibliotek.
Mer information finns i migrera från biblioteket för ändringsflödesprocessor till Azure Cosmos DB .NET v3 SDK
Körning av ändringsflödesfrågor på v3 SDK anses använda pull-modellen för ändringsflöde. Följ den här tabellen för att migrera konfigurationen:
.NET v2 SDK | .NET v3 SDK |
---|---|
ChangeFeedOptions.PartitionKeyRangeId |
FeedRange – För att uppnå parallellitet kan du läsa ändringsflödet FeedRanges . Det är inte längre en obligatorisk parameter, du kan läsa ändringsflödet för en hel container enkelt nu. |
ChangeFeedOptions.PartitionKey |
FeedRange.FromPartitionKey – En FeedRange som representerar önskad partitionsnyckel kan användas för att läsa ändringsflödet för det partitionsnyckelvärdet. |
ChangeFeedOptions.RequestContinuation |
ChangeFeedStartFrom.Continuation - Iteratorn för ändringsflöde kan stoppas och återupptas när som helst genom att spara fortsättningen och använda den när du skapar en ny iterator. |
ChangeFeedOptions.StartTime |
ChangeFeedStartFrom.Time |
ChangeFeedOptions.StartFromBeginning |
ChangeFeedStartFrom.Beginning |
ChangeFeedOptions.MaxItemCount |
ChangeFeedRequestOptions.PageSizeHint - Iteratorn för ändringsflöde kan stoppas och återupptas när som helst genom att spara fortsättningen och använda den när du skapar en ny iterator. |
IDocumentQuery.HasMoreResults |
response.StatusCode == HttpStatusCode.NotModified - Ändringsflödet är konceptuellt oändligt, så det kan alltid finnas fler resultat. När ett svar innehåller HttpStatusCode.NotModified statuskoden innebär det att det inte finns några nya ändringar att läsa just nu. Du kan använda det för att stoppa och spara fortsättningen eller för att tillfälligt sova eller vänta och sedan anropa ReadNextAsync igen för att testa nya ändringar. |
Delad hantering | Det krävs inte längre att användarna hanterar delade undantag när de läser ändringsflödet, delningar hanteras transparent utan att användaren behöver interagera. |
V3 SDK har inbyggt stöd för massexekutorbiblioteket, så att du kan använda samma SDK för att skapa ditt program och utföra massåtgärder. Tidigare var du skyldig att använda ett separat massexekutorbibliotek.
Mer information finns i migrera från massexekutorbiblioteket till massstöd i Azure Cosmos DB .NET V3 SDK
Med .NET V2 SDK kan du ange JsonSerializerSettings i RequestOptions på den driftsnivå som används för att deserialisera resultatdokumentet:
// .NET V2 SDK
var result = await container.ReplaceDocumentAsync(document, new RequestOptions { JsonSerializerSettings = customSerializerSettings })
.NET SDK v3 tillhandahåller ett serialiserargränssnitt för att helt anpassa serialiseringsmotorn, eller mer generiska serialiseringsalternativ som en del av klientkonstruktionen.
Du kan anpassa serialiseringen på åtgärdsnivå genom att använda Stream-API:er:
// .NET V3 SDK
using(Response response = await this.container.ReplaceItemStreamAsync(stream, "itemId", new PartitionKey("itemPartitionKey"))
{
using(Stream stream = response.ContentStream)
{
using (StreamReader streamReader = new StreamReader(stream))
{
// Read the stream and do dynamic deserialization based on type with a custom Serializer
}
}
}
Följande kodfragment visar skillnaderna i hur resurser skapas mellan .NET v2 och v3 SDK:er:
// Create database with no shared provisioned throughput
DatabaseResponse databaseResponse = await client.CreateDatabaseIfNotExistsAsync(DatabaseName);
Database database = databaseResponse;
DatabaseProperties databaseProperties = databaseResponse;
// Create a database with a shared manual provisioned throughput
string databaseIdManual = new string(DatabaseName + "_SharedManualThroughput");
database = await client.CreateDatabaseIfNotExistsAsync(databaseIdManual, ThroughputProperties.CreateManualThroughput(400));
// Create a database with shared autoscale provisioned throughput
string databaseIdAutoscale = new string(DatabaseName + "_SharedAutoscaleThroughput");
database = await client.CreateDatabaseIfNotExistsAsync(databaseIdAutoscale, ThroughputProperties.CreateAutoscaleThroughput(4000));
// Read a database
Console.WriteLine($"{Environment.NewLine} Read database resource: {DatabaseName}");
database = client.GetDatabase(DatabaseName);
Console.WriteLine($"{Environment.NewLine} database { database.Id.ToString()}");
// Read all databases
string findQueryText = "SELECT * FROM c";
using (FeedIterator<DatabaseProperties> feedIterator = client.GetDatabaseQueryIterator<DatabaseProperties>(findQueryText))
{
while (feedIterator.HasMoreResults)
{
FeedResponse<DatabaseProperties> databaseResponses = await feedIterator.ReadNextAsync();
foreach (DatabaseProperties _database in databaseResponses)
{
Console.WriteLine($"{ Environment.NewLine} database {_database.Id.ToString()}");
}
}
}
// Delete a database
await client.GetDatabase(DatabaseName).DeleteAsync();
Console.WriteLine($"{ Environment.NewLine} database {DatabaseName} deleted.");
// Delete all databases in an account
string deleteQueryText = "SELECT * FROM c";
using (FeedIterator<DatabaseProperties> feedIterator = client.GetDatabaseQueryIterator<DatabaseProperties>(deleteQueryText))
{
while (feedIterator.HasMoreResults)
{
FeedResponse<DatabaseProperties> databaseResponses = await feedIterator.ReadNextAsync();
foreach (DatabaseProperties _database in databaseResponses)
{
await client.GetDatabase(_database.Id).DeleteAsync();
Console.WriteLine($"{ Environment.NewLine} database {_database.Id} deleted");
}
}
}
private static async Task CreateManualThroughputContainer(Database database)
{
// Set throughput to the minimum value of 400 RU/s manually configured throughput
string containerIdManual = ContainerName + "_Manual";
ContainerResponse container = await database.CreateContainerIfNotExistsAsync(
id: containerIdManual,
partitionKeyPath: partitionKeyPath,
throughput: 400);
}
// Create container with autoscale
private static async Task CreateAutoscaleThroughputContainer(Database database)
{
string autoscaleContainerId = ContainerName + "_Autoscale";
ContainerProperties containerProperties = new ContainerProperties(autoscaleContainerId, partitionKeyPath);
Container container = await database.CreateContainerIfNotExistsAsync(
containerProperties: containerProperties,
throughputProperties: ThroughputProperties.CreateAutoscaleThroughput(autoscaleMaxThroughput: 4000);
}
// Create a container with TTL Expiration
private static async Task CreateContainerWithTtlExpiration(Database database)
{
string containerIdManualwithTTL = ContainerName + "_ManualTTL";
ContainerProperties properties = new ContainerProperties
(id: containerIdManualwithTTL,
partitionKeyPath: partitionKeyPath);
properties.DefaultTimeToLive = (int)TimeSpan.FromDays(1).TotalSeconds; //expire in 1 day
ContainerResponse containerResponse = await database.CreateContainerIfNotExistsAsync(containerProperties: properties);
ContainerProperties returnedProperties = containerResponse;
}
private static async Task ReadContainerProperties(Database database)
{
string containerIdManual = ContainerName + "_Manual";
Container container = database.GetContainer(containerIdManual);
ContainerProperties containerProperties = await container.ReadContainerAsync();
}
private static async Task DeleteContainers(Database database)
{
string containerIdManual = ContainerName + "_Manual";
// Delete a container
await database.GetContainer(containerIdManual).DeleteContainerAsync();
// Delete all CosmosContainer resources for a database
using (FeedIterator<ContainerProperties> feedIterator = database.GetContainerQueryIterator<ContainerProperties>())
{
while (feedIterator.HasMoreResults)
{
foreach (ContainerProperties _container in await feedIterator.ReadNextAsync())
{
await database.GetContainer(_container.Id).DeleteContainerAsync();
Console.WriteLine($"{Environment.NewLine} deleted container {_container.Id}");
}
}
}
}
private static async Task CreateItemAsync(Container container)
{
// Create a SalesOrder POCO object
SalesOrder salesOrder1 = GetSalesOrderSample("Account1", "SalesOrder1");
ItemResponse<SalesOrder> response = await container.CreateItemAsync(salesOrder1,
new PartitionKey(salesOrder1.AccountNumber));
}
private static async Task RunBasicOperationsOnDynamicObjects(Container container)
{
// Dynamic Object
dynamic salesOrder = new
{
id = "SalesOrder5",
AccountNumber = "Account1",
PurchaseOrderNumber = "PO18009186470",
OrderDate = DateTime.UtcNow,
Total = 5.95,
};
Console.WriteLine("\nCreating item");
ItemResponse<dynamic> response = await container.CreateItemAsync<dynamic>(
salesOrder, new PartitionKey(salesOrder.AccountNumber));
dynamic createdSalesOrder = response.Resource;
}
private static async Task ReadAllItems(Container container)
{
// Read all items in a container
List<SalesOrder> allSalesForAccount1 = new List<SalesOrder>();
using (FeedIterator<SalesOrder> resultSet = container.GetItemQueryIterator<SalesOrder>(
queryDefinition: null,
requestOptions: new QueryRequestOptions()
{
PartitionKey = new PartitionKey("Account1"),
MaxItemCount = 5
}))
{
while (resultSet.HasMoreResults)
{
FeedResponse<SalesOrder> response = await resultSet.ReadNextAsync();
SalesOrder salesOrder = response.First();
Console.WriteLine($"\n1.3.1 Account Number: {salesOrder.AccountNumber}; Id: {salesOrder.Id}");
allSalesForAccount1.AddRange(response);
}
}
}
Klassen SqlQuerySpec
i SDK v2 har nu bytt namn till QueryDefinition
i SDK v3.
SqlParameterCollection
och SqlParameter
har tagits bort. Parametrar läggs nu till i QueryDefinition
med en builder-modell med hjälp av QueryDefinition.WithParameter
. Användare kan komma åt parametrarna med QueryDefinition.GetQueryParameters
private static async Task QueryItems(Container container)
{
// Query for items by a property other than Id
QueryDefinition queryDefinition = new QueryDefinition(
"select * from sales s where s.AccountNumber = @AccountInput")
.WithParameter("@AccountInput", "Account1");
List<SalesOrder> allSalesForAccount1 = new List<SalesOrder>();
using (FeedIterator<SalesOrder> resultSet = container.GetItemQueryIterator<SalesOrder>(
queryDefinition,
requestOptions: new QueryRequestOptions()
{
PartitionKey = new PartitionKey("Account1"),
MaxItemCount = 1
}))
{
while (resultSet.HasMoreResults)
{
FeedResponse<SalesOrder> response = await resultSet.ReadNextAsync();
SalesOrder sale = response.First();
Console.WriteLine($"\n Account Number: {sale.AccountNumber}; Id: {sale.Id};");
allSalesForAccount1.AddRange(response);
}
}
}
private static async Task DeleteItemAsync(Container container)
{
ItemResponse<SalesOrder> response = await container.DeleteItemAsync<SalesOrder>(
partitionKey: new PartitionKey("Account1"), id: "SalesOrder3");
}
private static async Task QueryChangeFeedAsync(Container container)
{
FeedIterator<SalesOrder> iterator = container.GetChangeFeedIterator<SalesOrder>(ChangeFeedStartFrom.Beginning(), ChangeFeedMode.Incremental);
string continuation = null;
while (iterator.HasMoreResults)
{
FeedResponse<SalesOrder> response = await iteratorForTheEntireContainer.ReadNextAsync();
if (response.StatusCode == HttpStatusCode.NotModified)
{
// No new changes
continuation = response.ContinuationToken;
break;
}
else
{
// Process the documents in response
}
}
}
- Skapa en konsolapp för att hantera Azure Cosmos DB för NoSQL-data med hjälp av v3 SDK
- Läs mer om vad du kan göra med v3 SDK
- Försöker du planera kapacitet för en migrering till Azure Cosmos DB?
- Om allt du vet är antalet virtuella kärnor och servrar i ditt befintliga databaskluster läser du om att uppskatta enheter för begäranden med virtuella kärnor eller virtuella kärnor
- Om du känner till vanliga begärandefrekvenser för din aktuella databasarbetsbelastning kan du läsa om att uppskatta enheter för begäranden med azure Cosmos DB-kapacitetshanteraren