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 nivel de confirmación de escritura (write concern), nivel de consistencia de lectura y preferencia de lectura permiten personalizar la coherencia causal y la disponibilidad de los datos en tus sets 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, la preocupación por la lectura y el nivel de confirmación de escritura (write concern) de una instancia de MongoClient pasando una instancia de 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 Nivel de consistencia de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos hayan sido escritos en la mayoría de los miembros del grupo 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 los datos del miembro primario del set de réplicas.

• 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 nivel de confirmación de escritura (write concern): El miembro primario del conjunto de réplicas debe acuse de recibo de 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 configurar la preferencia de lectura, el nivel de consistencia de lectura y el nivel de confirmación de escritura (write concern) 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 primario del set de réplicas o de miembros secundarios si el primario no está disponible.

• AVAILABLE Nivel de consistencia de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos hayan sido escritos en la mayoría de los miembros del grupo 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 Nivel de consistencia de lectura: las operaciones de lectura devuelven los datos más recientes de la instancia sin garantizar que los datos hayan sido escritos en la mayoría de los miembros del grupo 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, puedes aplicar etiquetas de clave-valor a los miembros del set de réplicas según cualquier criterio que elijas. A continuación, puedes usar esas etiquetas para dirigir una operación de lectura a uno o más nodos.

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 set de réplicas que contiene nodos alojados en múltiples centros de datos en todo Estados Unidos. Desea que el driver prefiera las lecturas de los miembros secundarios del set de réplicas 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

Cuando se conecta a un set de réplicas con una preferencia de lectura que no es primaria, el driver lee del miembro elegible más cercano del set de réplicas dentro de la ventana de latencia. Al conectarse a un clúster fragmentado, el controlador selecciona entre todas las instancias mongos accesibles dentro de la ventana de latencia. Para aprender sobre los modos de preferencia de lectura, consulte Preferencia de lectura.

Por defecto, el controlador utiliza únicamente los servidores cuyos tiempos de ping se encuentren dentro de 15 milisegundos del servidor elegible más cercano.

Por ejemplo, supongamos que su set de réplicas tiene cinco nodos y el nodo más cercano tiene un tiempo de ping de 5 milisegundos. Con el valor por defecto de localThresholdMS de 15 milisegundos, solo los nodos con un tiempo de ping de 20 milisegundos o menos están dentro de la ventana de latencia, como se muestra en la tabla siguiente:

Para ajustar la ventana de latencia, 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. Selecciona la pestaña MongoClientSettings o Connection URI para ver el código correspondiente a 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.