Partage via

Configurer les fonctionnalités multirégions dans les applications qui utilisent Azure Cosmos DB

  • Article

S’APPLIQUE À : NoSQL

Dans les scénarios d’écriture dans plusieurs régions, vous pouvez obtenir un avantage en matière de performances en écrivant uniquement dans la région proche de votre instance d’application. Azure Cosmos DB gère la réplication pour vous en arrière-plan.

Après avoir activé votre compte pour plusieurs régions d’écriture, vous devez apporter deux modifications à votre application dans ConnectionPolicy. Dans ConnectionPolicy, définissez UseMultipleWriteLocations sur true et passez le nom de la région où l’application est déployée à ApplicationRegion. Cette action remplira la propriété PreferredLocations en fonction de la géo-proximité à partir de l’emplacement transmis. Si une nouvelle région est ajoutée ultérieurement au compte, l’application n’a pas besoin d’être mise à jour ou redéployée. Elle détecte automatiquement la région plus proche et passe automatiquement dessus en cas d’événement régional.

Notes

Les comptes Azure Cosmos DB initialement configurés avec une seule région d’écriture peuvent être configurés pour plusieurs régions d’écriture avec un temps de non-disponibilité égal à zéro. Pour en savoir plus, consultez Configurer plusieurs régions d’écriture.

Portail Azure

Pour utiliser les écritures multirégions, activez votre compte Azure Cosmos DB pour plusieurs régions à l’aide du Portail Azure. Spécifiez les régions dans lesquelles votre application peut écrire.

Pour activer les écritures multirégions, procédez comme suit :

  1. Connectez-vous au portail Azure.

  2. Accédez à votre compte Azure Cosmos DB et, dans le menu, ouvrez le volet Répliquer les données globalement.

  3. Sous l’option Écritures multirégions, choisissez Activer. Cela ajoute automatiquement les régions existantes aux régions en lecture et en écriture.

  4. Vous pouvez ajouter des régions supplémentaires en sélectionnant les icônes sur la carte ou en sélectionnant le bouton Ajouter une région. Toutes les régions que vous ajoutez sont disponibles en lecture et en écriture.

  5. Après avoir mis à jour la liste des régions, sélectionnez Enregistrer pour appliquer les modifications.

    Capture d’écran pour permettre les écritures multirégions à l’aide du portail Azure.

SDK .NET v2

Pour activer les écritures multirégions dans votre application, définissez UseMultipleWriteLocations sur true. Définissez également SetCurrentLocation en fonction de la région sur laquelle l’application est déployée et où Azure Cosmos DB est répliquée :

ConnectionPolicy policy = new ConnectionPolicy
    {
        ConnectionMode = ConnectionMode.Direct,
        ConnectionProtocol = Protocol.Tcp,
        UseMultipleWriteLocations = true
    };
policy.SetCurrentLocation("West US 2");

SDK .NET v3

Pour activer les écritures multirégions dans votre application, définissez ApplicationRegion en fonction de la région sur laquelle l’application est déployée et où le service Azure Cosmos DB est répliqué :

CosmosClient cosmosClient = new CosmosClient(
    "<connection-string-from-portal>", 
    new CosmosClientOptions()
    {
        ApplicationRegion = Regions.WestUS2,
    });

Si vous le souhaitez, vous pouvez utiliser CosmosClientBuilder et WithApplicationRegion pour obtenir le même résultat :

CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder("<connection-string-from-portal>")
            .WithApplicationRegion(Regions.WestUS2);
CosmosClient client = cosmosClientBuilder.Build();

SDK Java V4

Pour activer les écritures multirégions à votre application, appelez .multipleWriteRegionsEnabled(true) et .preferredRegions(preferredRegions) dans le générateur de client, où preferredRegions est un List des régions dans lesquelles les données sont répliquées de préférence, idéalement en premier les régions avec la distance la plus courte/la meilleure latence :

API Async du Kit de développement logiciel (SDK) Java v4 (Maven com.azure::azure-cosmos)


ArrayList<String> preferredRegions = new ArrayList<String>();
preferredRegions.add(region);

CosmosAsyncClient client =
        new CosmosClientBuilder()
                .endpoint(HOST)
                .key(MASTER_KEY)
                .multipleWriteRegionsEnabled(true)
                .preferredRegions(preferredRegions)
                .buildAsyncClient();

Kit de développement logiciel (SDK) Async Java v2

Le kit de développement logiciel (SDK) Java v2 utilisait l’outil Maven com.microsoft.azure::azure-cosmosdb. Pour activer les écritures multi-régions à votre application, définissez policy.setUsingMultipleWriteLocations(true) et policy.setPreferredLocations au List des régions dans lesquelles les données sont répliquées de préférence, idéalement en premier les régions avec la distance la plus courte/la meilleure latence :

ConnectionPolicy policy = new ConnectionPolicy();
policy.setUsingMultipleWriteLocations(true);
policy.setPreferredLocations(Collections.singletonList(region));

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

Kits SDK Node.js, JavaScript et TypeScript

Pour activer les écritures multirégions dans votre application, définissez connectionPolicy.UseMultipleWriteLocations sur true. En outre, définissez connectionPolicy.PreferredLocations vers les régions dans lesquelles les données sont répliquées de préférence, idéalement en premier les régions avec la distance la plus courte/la meilleure latence :

const connectionPolicy: ConnectionPolicy = new ConnectionPolicy();
connectionPolicy.UseMultipleWriteLocations = true;
connectionPolicy.PreferredLocations = [region];

const client = new CosmosClient({
  endpoint: config.endpoint,
  auth: { masterKey: config.key },
  connectionPolicy,
  consistencyLevel: ConsistencyLevel.Eventual
});

Kit de développement logiciel (SDK) Python

Pour activer les écritures multirégions dans votre application, définissez connection_policy.UseMultipleWriteLocations sur true. En outre, définissez connection_policy.PreferredLocations vers les régions dans lesquelles les données sont répliquées de préférence, idéalement en premier les régions avec la distance la plus courte/la meilleure latence.

connection_policy = documents.ConnectionPolicy()
connection_policy.UseMultipleWriteLocations = True
connection_policy.PreferredLocations = [region]

client = cosmos_client.CosmosClient(self.account_endpoint, {
                                    'masterKey': self.account_key}, connection_policy, documents.ConsistencyLevel.Session)

Étapes suivantes