Configurar operações em conjuntos de réplicas

Precedência de configurações de leitura e gravação

É possível definir as opções de preocupação de gravação, preocupação de leitura e preferência de leitura nos seguintes níveis:

• Cliente, que define o padrão para todas as execuções de operações, a menos que seja substituído

• transação

• Database

• collection

Esta lista também indica a ordem crescente de precedência das configurações de opção. Por exemplo, se você definir uma preocupação de leitura para uma transação, ela substituirá as configurações de preocupação de leitura herdadas do cliente.

As opções de write concern, preocupação de leitura e preferência de leitura permitem personalizar a consistência causal e a disponibilidade dos dados em seus conjuntos de réplicas. Para ver uma lista completa dessas opções, consulte os seguintes guias no manual do MongoDB Server :

• readPreference

• Preocupação de leitura

• Escreva preocupação

Configuração do cliente

Este exemplo mostra como definir a preferência de leitura, preocupação de leitura e preocupação de gravação de uma instância MongoClient passando uma instância MongoClientSettings para o construtor. O código define as seguintes configurações:

• secondary preferência de leitura: as operações de leitura recuperam dados de nós secundários do conjunto de réplicas.

• LOCAL preocupação de leitura: as operações de leitura retornam os dados mais recentes da instância sem garantir que os dados tenham sido gravados na maioria dos membros do conjunto de réplicas.

• W2 preocupação de gravação: o membro primário do conjunto de réplicas e um membro secundário devem confirmar a operação de gravação.

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

Alternativamente, você pode especificar as configurações de leitura e escrita no URI de conexão, que é passado como um parâmetro para o construtor MongoClients :

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

Configuração da transação

Este exemplo mostra como definir a preferência de leitura, preocupação de leitura e preocupação de gravação de uma transação passando uma instância TransactionOptions para o método startTransaction(). As transações são executadas dentro de sessões, que são agrupamentos de operações de leitura ou escrita relacionadas que você pretende executar sequencialmente. Antes de aplicar as opções de transação, crie uma instância do ClientSession para iniciar uma sessão.

O exemplo define as seguintes configurações:

• primary preferência de leitura: as operações de leitura recuperam dados do membro primário do conjunto de réplicas.

• MAJORITY preocupação de leitura: as operações de leitura retornam os dados mais recentes da instância que foram gravados para a maioria dos membros do conjunto de réplicas.

• W1 preocupação de gravação: o membro primário do conjunto de réplicas deve confirmar a operação de gravação.

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
}

Configuração do Banco de Dados

Este exemplo mostra como definir a preferência de leitura, preocupação de leitura e preocupação de gravação de um banco de dados chamado test_database encadeando métodos de configuração ao método getDatabase(). O código define as seguintes configurações:

• primaryPreferred preferência de leitura: as operações de leitura recuperam dados do membro primário do conjunto de réplicas ou de membros secundários se o principal não estiver disponível.

• AVAILABLE preocupação de leitura: as operações de leitura retornam os dados mais recentes da instância sem garantir que os dados tenham sido gravados na maioria dos membros do conjunto de réplicas.

• MAJORITY preocupação de gravação: A maioria de todos os membros do conjunto de réplicas deve reconhecer a operação de escrita.

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

Configuração da Coleção

Este exemplo mostra como definir a preferência de leitura, preocupação de leitura e preocupação de gravação de uma collection chamada test_collection encadeando métodos setter ao método getCollection() . O código define as seguintes configurações:

• secondaryPreferred preferência de leitura: as operações de leitura recuperam dados de nós secundários do conjunto de réplicas ou dos nós primários se nenhum nó secundário estiver disponível.

• AVAILABLE preocupação de leitura: as operações de leitura retornam os dados mais recentes da instância sem garantir que os dados tenham sido gravados na maioria dos membros do conjunto de réplicas.

• UNACKNOWLEDGED preocupação de gravação: os membros do conjunto de réplicas não precisam confirmar a operação de gravação.

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

Clusters fragmentados

Você pode especificar uma preferência de leitura ao se conectar a um cluster fragmentado. O MongoDB usa fragmentação para dividir conjuntos de dados por intervalos de chaves e distribuir dados em várias instâncias do banco de dados . Um cluster fragmentado, ou o conjunto de nós em um sistema fragmentado, inclui os seguintes componentes:

• Fragmento: um conjunto de réplicas que contém um subconjunto dos dados fragmentados.

• Mongos: um roteador de query que fornece uma interface entre seu aplicação e o cluster fragmentado.

• Servidores de configuração: servidores que armazenam as definições de configuração e metadados do cluster.

Ao ler a partir dos shards do conjunto de réplicas, o mongos aplica sua preferência de leitura especificada. A preferência de leitura é reavaliada para cada operação.

O exemplo a seguir mostra como se conectar a um cluster fragmentado e especificar uma preferência de leitura secondary em sua string de conexão:

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

Conjuntos de tags

No MongoDB Server, você pode aplicar tags de valor-chave a membros do conjunto de réplicas de acordo com qualquer critério que você escolher. Você pode então usar essas tags para direcionar um ou mais nós para uma operação de leitura.

Por padrão, o driver Java ignora as tags ao escolher um membro para ler. Para instruir o driver Java a preferir determinadas tags, passe as tags como uma lista para seu método de configuração de preferência de leitura .

Suponha que você esteja conectado a um conjunto de réplicas que contém membros hospedados em vários data centers nos Estados Unidos. Você deseja que o driver prefira leituras de nós secundários do conjunto de réplicas na seguinte ordem:

1. Membros do centro de dados de Nova York, marcados com ("dc", "ny")

2. Membros do centro de dados de São Francisco, marcados com ("dc", "sf")

3. Quaisquer membros secundários

Este exemplo de código passa uma lista de tags que representam os membros do conjunto de réplicas anteriores para o método de configuração ReadPreference.secondary(). Em seguida, o código passa as informações de preferência de leitura para o método withReadPreference() para definir a ordem de leitura no banco de dados:

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);

Balanceamento de carga

Ao se conectar a um cluster fragmentado ou a um conjunto de réplicas, o driver Java usa o balanceamento de carga para lidar com solicitações de leitura e gravação. O balanceamento de carga permite que o driver distribua essas solicitações em vários servidores, o que evita sobrecarregar qualquer servidor e garante o desempenho ideal.

Ao se conectar a um cluster fragmentado, o driver Java determina a instância de mongos mais próxima calculando qual tem o menor tempo de viagem de ida e volta da rede. Em seguida, o driver determina a janela de latência adicionando o tempo médio de ida e volta desse mongos ao valor localThresholdMS. O driver equilibra a carga das solicitações em até duas instâncias aleatórias do mongos que se enquadram na janela de latência. Para cada solicitação, o driver escolhe o servidor com a menor carga de operação determinando seu valor operationCount.

Ao se conectar a um conjunto de réplicas, o driver Java primeiro seleciona os membros do conjunto de réplicas de acordo com sua preferência de leitura. Em seguida, o driver segue o mesmo processo descrito no número anterior. Após calcular a janela de latência, o driver seleciona até dois membros aleatórios do conjunto de réplicas que se enquadram na janela e escolhe o membro com o menor valor de operationCount para receber a solicitação.

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);