Configurar operaciones en conjuntos de réplicas

Prioridad de configuración de lectura y guardado

Puedes establecer las opciones de nivel de confirmación de escritura (write concern), nivel de consistencia de lectura y preferencia de lectura en los siguientes niveles:

• Cliente, que establece el por defecto para todas las ejecuciones de operaciones, a menos que se anule

• transacción

• Database

• Colección

Esta lista también indica el orden creciente de precedencia de la configuración de opciones. Por ejemplo, si estableces un nivel de consistencia de lectura para una transacción, este anulará un nivel de consistencia de lectura heredado del cliente.

Las opciones de escritura, lectura y preferencia de lectura permiten personalizar la consistencia causal y la disponibilidad de los datos en los conjuntos de réplicas. Para ver una lista completa de estas opciones, consulte las siguientes guías en el manual de MongoDB Server:

• preferencia de lectura

• readConcern

• Nivel de confirmación de escritura

Configuración del cliente

Este ejemplo muestra cómo establecer la preferencia de lectura, el nivel de consistencia de lectura y el nivel de confirmación de escritura (write concern) de un MongoClient instancia pasando una instancia MongoClientSettings al constructor. El código configura los siguientes ajustes:

• secondary preferencia de lectura: las operaciones de lectura recuperan datos de miembros secundarios del set de réplicas.

• LOCAL Preocupación de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos se hayan escrito en la mayoría de los miembros del conjunto de réplicas.

• W2 nivel de confirmación de escritura (write concern): El primario del set de réplicas y un secundario deben reconocer la operación de grabación.

val mongoClient = MongoClient(MongoClientSettings.builder()
    .applyConnectionString(ConnectionString("mongodb://localhost:27017/"))
    .readPreference(ReadPreference.secondary())
    .readConcern(ReadConcern.LOCAL)
    .writeConcern(WriteConcern.W2)
    .build())

Alternativamente, se pueden especificar los ajustes de lectura y guardado en el URI de conexión, que se pasa como un parámetro al constructor MongoClient:

val uriClient = MongoClient("mongodb://localhost:27017/?readPreference=secondary&w=2&readConcernLevel=local")

Configuración de transacciones

Este ejemplo muestra cómo establecer la preferencia de lectura, el nivel de consistencia de lectura y el nivel de confirmación de escritura (write concern) de una transacción pasando una instancia de TransactionOptions al método startTransaction(). Las transacciones se ejecutan dentro de sesiones, que son agrupaciones de operaciones de lectura o escritura relacionadas que planeas ejecutar secuencialmente. Antes de configurar las opciones de transacción, crea una instancia ClientSession para iniciar una sesión.

El ejemplo configura los siguientes ajustes:

• primary preferencia de lectura: las operaciones de lectura recuperan datos del miembro del conjunto de réplicas principal.

• MAJORITY nivel de consistencia de lectura: Las operaciones de lectura devuelven los datos más recientes de la instancia que se han escrito en la mayoría de los miembros del set de réplicas.

• W1 Preocupación de escritura: el miembro principal del conjunto de réplicas debe reconocer la operación de escritura.

val clientSessionFuture = mongoClient.startSession().toFuture()
val clientSession = Await.result(clientSessionFuture, Duration(10, TimeUnit.SECONDS))
val tOptions: TransactionOptions = TransactionOptions.builder()
    .readPreference(ReadPreference.primary())
    .readConcern(ReadConcern.MAJORITY)
    .writeConcern(WriteConcern.W1)
    .build()
clientSession.startTransaction(tOptions)

Configuración de la base de datos

Este ejemplo muestra cómo establecer la preferencia de lectura, la preocupación de lectura y la preocupación de escritura de una base de datos llamada test_database encadenando métodos setter al método getDatabase(). El código configura los siguientes ajustes:

• primaryPreferred preferencia de lectura: las operaciones de lectura recuperan datos del miembro del conjunto de réplicas principal o de miembros secundarios si el principal no está disponible.

• AVAILABLE Preocupación de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos se hayan escrito en la mayoría de los miembros del conjunto de réplicas.

• MAJORITY nivel de confirmación de escritura (write concern): La mayoría de todos los miembros del set de réplicas deben reconocer la operación de escritura.

val database = mongoClient.getDatabase("test_database")
    .withReadPreference(ReadPreference.primaryPreferred())
    .withReadConcern(ReadConcern.AVAILABLE)
    .withWriteConcern(WriteConcern.MAJORITY)

Configuración de la colección

Este ejemplo muestra cómo configurar la preferencia de lectura, el nivel de consistencia de lectura y el nivel de confirmación de escritura (write concern) de una colección llamada test_collection, encadenando métodos setters al método getCollection(). El código configura la siguiente configuración:

• secondaryPreferred preferencia de lectura: Las operaciones de lectura recuperan datos de los miembros secundarios del set de réplicas, o de los miembros primarios si no se dispone de miembros secundarios.

• AVAILABLE Preocupación de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos se hayan escrito en la mayoría de los miembros del conjunto de réplicas.

• UNACKNOWLEDGED nivel de confirmación de escritura (write concern): Los miembros del conjunto de réplicas no necesitan reconocer la operación de escritura.

val collection = database.getCollection("test_collection")
    .withReadPreference(ReadPreference.secondaryPreferred())
    .withReadConcern(ReadConcern.AVAILABLE)
    .withWriteConcern(WriteConcern.UNACKNOWLEDGED)

Conjuntos de etiquetas

En MongoDB Server, puede aplicar etiquetas clave-valor a los miembros del conjunto de réplicas según el criterio que elija. Después, puede usar esas etiquetas para seleccionar uno o más miembros para una operación de lectura.

Por defecto, el driver de Scala ignora las etiquetas al elegir un nodo del que leer. Para indicar al driver de Scala que prefiera ciertas etiquetas, pasa las etiquetas como una lista a tu método setter de preferencia de lectura.

Supongamos que está conectado a un conjunto de réplicas que contiene miembros alojados en varios centros de datos en Estados Unidos. Quiere que el controlador prefiera las lecturas de los miembros del conjunto de réplicas secundario en el siguiente orden:

1. Miembros del centro de datos de Nueva York, etiquetados con ("dc", "ny")

2. Nodos del centro de datos de San Francisco, etiquetados con ("dc", "sf")

3. Cualquier miembro secundario

Este ejemplo de código pasa una lista de etiquetas que representan a los miembros anteriores del set de réplicas al método setter ReadPreference.secondary(). Luego, el código pasa la información de preferencia de lectura al método withReadPreference() para establecer el orden de lectura en la base de datos:

val tag1 = new TagSet(new Tag("dc", "ny"))
val tag2 = new TagSet(new Tag("dc", "sf"))
val tag3 = new TagSet()
val readPreference = ReadPreference.secondary(List(tag1, tag2, tag3).asJava)
val database = mongoClient.getDatabase("test_database")
                          .withReadPreference(readPreference)

Umbral local

Si varios miembros del set de réplicas coinciden con la preferencia de lectura y los conjuntos de etiquetas que especificas, el driver de Scala lee de los miembros más cercanos del set de réplicas, elegidos según su tiempo de ping.

Por defecto, el driver utiliza solo nodos cuyos tiempos de ping estén dentro de 15 milisegundos del nodo más cercano para las queries. Para distribuir las lecturas entre miembros com mayores latencias, configura la opción localThreshold en una instancia MongoClientSettings o la opción localThresholdMS en tu URI de conexión.

El siguiente ejemplo especifica un umbral local de 35 milisegundos. Seleccione el MongoClientSettings o la pestaña Connection URI para ver el código correspondiente para cada enfoque:

val client = MongoClient(MongoClientSettings.builder()
    .applyConnectionString(ConnectionString("mongodb://localhost:27017/"))
    .applyToClusterSettings(builder => builder
        .localThreshold(35, TimeUnit.MILLISECONDS)
    )
    .build())

val connectionString = "mongodb://localhost:27017/?replicaSet=repl0&localThresholdMS=35"
val client = MongoClient(connectionString)

En el ejemplo anterior, el controlador de Scala distribuye las lecturas entre los nodos coincidentes dentro de 35 milisegundos del tiempo de ping del nodo más cercano.