Dela via

Hantera konsekvensnivåer i Azure Cosmos DB

  • Artikel

GÄLLER FÖR: NoSQL

Den här artikeln förklarar hur du hanterar konsekvensnivåer i Azure Cosmos DB. Du lär dig att konfigurera standardkonsekvensnivån, åsidosätta standardkonsekvensen, manuellt hantera sessionstoken och förstå PBS-mått (probabilistiskt begränsad föråldring).

När du ändrar konsekvensen på kontonivån kontrollerar du att du distribuerar om dina program och gör eventuella nödvändiga kodändringar för att tillämpa dessa ändringar.

Kommentar

Vi rekommenderar att du använder Azure Az PowerShell-modulen för att interagera med Azure. Information om hur du kommer igång finns i Installera Azure PowerShell. Information om hur du migrerar till Az PowerShell-modulen finns i artikeln om att migrera Azure PowerShell från AzureRM till Az.

Konfigurera standardkonsekvensnivån

Standardkonsekvensnivån är den konsekvensnivå som klienter använder som standard.

Om du vill visa eller ändra standardkonsekvensnivån loggar du in på Azure-portalen. Leta reda på ditt Azure Cosmos DB-konto och öppna fönsterrutan Standardkonsekvens. Välj den konsekvensnivå som du vill ha som den nya standarden, och välj sedan Spara. Azure-portalen innehåller också en visualisering av olika konsekvensnivåer med musikanteckningar.

Konsekvensmeny på Azure-portalen

Åsidosätta standardkonsekvensnivån

Klienter kan åsidosätta standardkonsekvensnivån som anges av tjänsten. Konsekvensnivån kan anges per begäran, vilket åsidosätter den standardkonsekvensnivå som angetts på kontonivå.

Dricks

Konsekvens kan bara vara avslappnad på SDK-instans- eller begärandenivå. Om du vill gå från svagare till starkare konsekvens uppdaterar du standardkonsekvensen för Azure Cosmos DB-kontot.

Dricks

Att åsidosätta standardkonsekvensnivån gäller endast läsningar i SDK-klienten. Ett konto som konfigurerats för stark konsekvens som standard skriver och replikerar fortfarande data synkront till varje region i kontot. När SDK-klientinstansen eller begäran åsidosätter detta med sessionskonsekvens eller svagare konsekvens utförs läsningar med en enda replik. Mer information finns i Konsekvensnivåer och dataflöde .

.NET SDK

// Override consistency at the client level
documentClient = new DocumentClient(new Uri(endpoint), authKey, connectionPolicy, ConsistencyLevel.Eventual);

// Override consistency at the request level via request options
RequestOptions requestOptions = new RequestOptions { ConsistencyLevel = ConsistencyLevel.Eventual };

var response = await client.ReadDocumentAsync(collectionUri, document, requestOptions);

Java V4 SDK

Java SDK V4 (Maven com.azure::azure-cosmos) Async API


CosmosAsyncClient client =
        new CosmosClientBuilder()
                .endpoint(HOST)
                .key(MASTER_KEY)
                .consistencyLevel(ConsistencyLevel.EVENTUAL)
                .buildAsyncClient();

Java V2 SDK:er

Async Java V2 SDK (Maven com.microsoft.azure::azure-cosmosdb)

// Override consistency at the client level
ConnectionPolicy policy = new ConnectionPolicy();

AsyncDocumentClient client =
        new AsyncDocumentClient.Builder()
                .withMasterKey(this.accountKey)
                .withServiceEndpoint(this.accountEndpoint)
                .withConsistencyLevel(ConsistencyLevel.Eventual)
                .withConnectionPolicy(policy).build();

Node.js/JavaScript/TypeScript SDK

// Override consistency at the client level
const client = new CosmosClient({
  /* other config... */
  consistencyLevel: ConsistencyLevel.Eventual
});

// Override consistency at the request level via request options
const { body } = await item.read({ consistencyLevel: ConsistencyLevel.Eventual });

Python SDK

# Override consistency at the client level
connection_policy = documents.ConnectionPolicy()
client = cosmos_client.CosmosClient(self.account_endpoint, {
                                    'masterKey': self.account_key}, connection_policy, documents.ConsistencyLevel.Eventual)

Använda sessionstoken

En av konsekvensnivåerna i Azure Cosmos DB är Sessionskonsekvens . Det här är standardnivån som tillämpas på Azure Cosmos DB-konton som standard. När du arbetar med sessionskonsekvens tilldelas varje ny skrivbegäran till Azure Cosmos DB en ny SessionToken. CosmosClient använder den här token internt med varje läs-/frågebegäran för att säkerställa att den angivna konsekvensnivån bibehålls.

I vissa scenarier måste du hantera den här sessionen själv. Överväg ett webbprogram med flera noder. Varje nod har en egen instans av CosmosClient. Om du vill att dessa noder ska delta i samma session (för att kunna läsa dina egna skrivningar konsekvent över webbnivåer) måste du skicka SessionToken från FeedResponse<T> för skrivåtgärden till slutanvändaren med hjälp av en cookie eller någon annan mekanism, och få tokenflödet tillbaka till webbnivån och slutligen CosmosClient för efterföljande läsningar. Om du använder en lastbalanserare för resursallokering som inte upprätthåller sessionstillhörighet mellan begäranden, till exempel Azure Load Balancer, kan läsningen eventuellt landa på en annan nod än skrivbegäran, där sessionen skapades.

Om du inte flödar över Azure Cosmos DB SessionToken enligt beskrivningen ovan kan du få inkonsekventa läsresultat ett tag.

Sessionstoken i Azure Cosmos DB är partitionsbundna, vilket innebär att de uteslutande är associerade med en partition. För att säkerställa att du kan läsa dina skrivningar använder du sessionstoken som senast genererades för relevanta objekt. Om du vill hantera sessionstoken manuellt hämtar du sessionstoken från svaret och anger dem per begäran. Om du inte behöver hantera sessionstoken manuellt behöver du inte använda de här exemplen. SDK håller reda på sessionstoken automatiskt. Om du inte anger sessionstoken manuellt använder SDK som standard den senaste sessionstoken.

.NET SDK

var response = await client.ReadDocumentAsync(
                UriFactory.CreateDocumentUri(databaseName, collectionName, "SalesOrder1"));
string sessionToken = response.SessionToken;

RequestOptions options = new RequestOptions();
options.SessionToken = sessionToken;
var response = await client.ReadDocumentAsync(
                UriFactory.CreateDocumentUri(databaseName, collectionName, "SalesOrder1"), options);

Java V4 SDK

Java SDK V4 (Maven com.azure::azure-cosmos) Async API


// Get session token from response
CosmosItemResponse<JsonNode> response = container.readItem(itemId, new PartitionKey(partitionKey), JsonNode.class).block();
String sessionToken = response.getSessionToken();

// Resume the session by setting the session token on the RequestOptions
CosmosItemRequestOptions options = new CosmosItemRequestOptions();
options.setSessionToken(sessionToken);
CosmosItemResponse<JsonNode> response2 = container.readItem(itemId, new PartitionKey(partitionKey), JsonNode.class).block();

Java V2 SDK:er

Async Java V2 SDK (Maven com.microsoft.azure::azure-cosmosdb)

// Get session token from response
RequestOptions options = new RequestOptions();
options.setPartitionKey(new PartitionKey(document.get("mypk")));
Observable<ResourceResponse<Document>> readObservable = client.readDocument(document.getSelfLink(), options);
readObservable.single()           // we know there will be one response
  .subscribe(
      documentResourceResponse -> {
          System.out.println(documentResourceResponse.getSessionToken());
      },
      error -> {
          System.err.println("an error happened: " + error.getMessage());
      });

// Resume the session by setting the session token on RequestOptions
RequestOptions options = new RequestOptions();
requestOptions.setSessionToken(sessionToken);
Observable<ResourceResponse<Document>> readObservable = client.readDocument(document.getSelfLink(), options);

Node.js/JavaScript/TypeScript SDK

// Get session token from response
const { headers, item } = await container.items.create({ id: "meaningful-id" });
const sessionToken = headers["x-ms-session-token"];

// Immediately or later, you can use that sessionToken from the header to resume that session.
const { body } = await item.read({ sessionToken });

Python SDK

// Get the session token from the last response headers
item = client.ReadItem(item_link)
session_token = client.last_response_headers["x-ms-session-token"]

// Resume the session by setting the session token on the options for the request
options = {
    "sessionToken": session_token
}
item = client.ReadItem(doc_link, options)

Övervaka PBS-mått (probabilistiskt begränsad föråldring)

Hur slutlig är slutlig konsekvens? För det genomsnittliga fallet kan vi erbjuda inaktuella gränser med avseende på versionshistorik och tid. Måttet Probabilistically Bounded Staleness (PBS) försöker kvantifiera sannolikheten för inaktuellhet och visar det som ett mått.

Om du vill visa PBS-måttet går du till ditt Azure Cosmos DB-konto på Azure-portalen. Öppna fönstret Mått (klassisk) och välj fliken Konsekvens . Titta på diagrammet Med namnet Sannolikhet för starkt konsekventa läsningar baserat på din arbetsbelastning (se PBS).

PBS-graf i Azure-portalen

Nästa steg

Läs mer om hur du hanterar datakonflikter eller gå vidare till nästa viktiga begrepp i Azure Cosmos DB. Mer information finns i följande artiklar: