Configurar operaciones en conjuntos de réplicas

Precedencia de configuración de lectura y escritura

Puede establecer opciones de preocupación de escritura, preocupación de lectura y preferencia de lectura en los siguientes niveles:

• Cliente, que establece el valor predeterminado 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, la preocupación de lectura y la preocupación de escritura 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 los miembros del conjunto de réplicas secundarias.

• 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 Preocupación de escritura: el miembro principal del conjunto de réplicas y un miembro secundario deben reconocer la operación de escritura.

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 preocupación 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 conjunto 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 establecer la preferencia de lectura, la preocupación de lectura y la preocupación de escritura de una colección llamada test_collection encadenando métodos setter al método getCollection(). El código configura los siguientes ajustes:

• secondaryPreferred preferencia de lectura: las operaciones de lectura recuperan datos de los miembros del conjunto de réplicas secundarias o de los miembros principales si no hay miembros secundarios disponibles.

• 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 Preocupación de escritura: 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.

De forma predeterminada, el controlador de Scala ignora las etiquetas al elegir un miembro para leer. Para indicarle que prefiera ciertas etiquetas, páselas como una lista a su método de configuración de preferencias 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. Miembros 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 los miembros del conjunto de réplicas anterior al método de establecimiento ReadPreference.secondary(). A continuación, 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 conjunto de réplicas coinciden con las preferencias de lectura y los conjuntos de etiquetas que especifique, el controlador de Scala lee desde los miembros del conjunto de réplicas más cercanos, elegidos de acuerdo con su tiempo de ping.

De forma predeterminada, el controlador solo utiliza para las consultas miembros cuyos tiempos de ping se encuentran a menos de 15 milisegundos del miembro más cercano. Para distribuir las lecturas entre miembros con latencias más altas, configure la opción localThreshold en una instancia MongoClientSettings o la opción localThresholdMS en la URI de su 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 Scala distribuye lecturas entre los miembros coincidentes dentro de 35 milisegundos del tiempo de ping del miembro más cercano.