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 de precedencia creciente de la configuración de las opciones. Por ejemplo, si se configura una preocupación de lectura para una transacción, esta anulará la configuración de preocupación de lectura heredada 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.

MongoClient mongoClient = MongoClients.create(MongoClientSettings.builder()
        .applyConnectionString(new 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 MongoClients:

MongoClient uriClient = MongoClients.create("mongodb://localhost:27017/?readPreference=secondary&w=2&readConcernLevel=local");

Configuración de transacciones

Este ejemplo muestra cómo configurar la preferencia de lectura, la preocupación de lectura y la preocupación de escritura de una transacción pasando una TransactionOptions instancia al método.startTransaction() Las transacciones se ejecutan dentro de sesiones, que son agrupaciones de operaciones de lectura o escritura relacionadas que se ejecutan secuencialmente. Antes de aplicar las opciones de transacción, cree una ClientSession instancia 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.

TransactionOptions tOptions = TransactionOptions.builder()
        .readPreference(ReadPreference.primary())
        .readConcern(ReadConcern.MAJORITY)
        .writeConcern(WriteConcern.W1)
        .build();
        
try (ClientSession clientSession = client.startSession()) {
    clientSession.startTransaction(tOptions);
    // Specify transaction operations here
}

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.

MongoDatabase 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.

MongoCollection<Document> collection = database.getCollection("test_collection")
        .withReadPreference(ReadPreference.secondaryPreferred())
        .withReadConcern(ReadConcern.AVAILABLE)
        .withWriteConcern(WriteConcern.UNACKNOWLEDGED);

Clústeres fragmentados

Puede especificar una preferencia de lectura al conectarse a un clúster fragmentado. MongoDB utiliza la fragmentación para dividir los conjuntos de datos por rangos de claves y distribuir los datos entre varias instancias de base de datos. Un clúster fragmentado, o el conjunto de nodos en una implementación fragmentada, incluye los siguientes componentes:

• Fragmento: un conjunto de réplicas que contiene un subconjunto de los datos fragmentados.

• Mongos: un enrutador de consultas que proporciona una interfaz entre su aplicación y el clúster fragmentado.

• Servidores de configuración: servidores que almacenan la configuración y los metadatos del clúster.

Al leer desde los fragmentos del conjunto de réplicas, Mongos aplica la preferencia de lectura especificada. Esta preferencia se reevalúa en cada operación.

El siguiente ejemplo muestra cómo conectarse a un clúster fragmentado y especificar una preferencia de lectura secondary en su cadena de conexión:

MongoClient uriClient = MongoClients.create("mongodb://user:password@mongos1.example.com,mongos2.example.com/?readPreference=secondary");

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 Java 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:

TagSet tag1 = new TagSet(new Tag("dc", "ny"));
TagSet tag2 = new TagSet(new Tag("dc", "sf"));
TagSet tag3 = new TagSet();
ReadPreference readPref= ReadPreference.secondary(Arrays.asList(tag1, tag2, tag3));
MongoDatabase database = mongoClient.getDatabase("test_database")
                      .withReadPreference(readPref);

Equilibrio de carga

Al conectarse a un clúster fragmentado o a un conjunto de réplicas, el controlador de Java utiliza el equilibrio de carga para gestionar las solicitudes de lectura. El equilibrio de carga permite al controlador distribuir estas solicitudes entre varios servidores, lo que evita la sobrecarga de un servidor y garantiza un rendimiento óptimo.

Al conectarse a un clúster fragmentado, el controlador de Java determina la instancia de Mongos más cercana calculando cuál tiene el menor tiempo de ida y vuelta en la red. A continuación, el controlador determina la ventana de latencia sumando el tiempo de ida y vuelta promedio de Mongos al valor de localThresholdMS. El controlador distribuye la carga de las solicitudes entre hasta dos instancias aleatorias de Mongos dentro de la ventana de latencia. Para cada solicitud, el controlador elige el servidor con la menor carga operativa determinando su operationCount valor.

Al conectarse a un conjunto de réplicas, el controlador de Java selecciona primero los miembros del conjunto según sus preferencias de lectura. A continuación, sigue el mismo proceso descrito en el párrafo anterior. Tras calcular la ventana de latencia, selecciona hasta dos miembros aleatorios del conjunto de réplicas que se encuentren dentro de la ventana y elige el miembro con el valor operationCount más bajo para recibir la solicitud.

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

String connectionString = "mongodb://localhost:27017/?replicaSet=repl0&localThresholdMS=35";
MongoClient client = MongoClients.create(connectionString);