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 um nível de preocupação de leitura para uma transação, ela substituirá um nível de preocupação de leitura herdado 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.

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

val uriClient = MongoClient("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 configurar 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.

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)

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.

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

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

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 Scala ignora as tags ao escolher um membro para ler. Para instruir o driver Scala 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:

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)

LocalThreshold

Se vários membros do conjunto de réplicas corresponderem à preferência de leitura e aos conjuntos de tags que você especificar, o driver Scala lerá a partir dos membros do conjunto de réplicas mais próximos, escolhidos de acordo com o tempo de ping .

Por padrão, o driver usa somente membros cujos tempos de ping estão dentro de 15 milissegundos do membro mais próximo para queries. Para distribuir leituras entre membros com latências mais altas, defina a opção localThreshold em uma instância MongoClientSettings ou a opção localThresholdMS em seu URI de conexão.

O exemplo a seguir especifica um limite local de 35 milissegundos. Selecione a aba MongoClientSettings ou Connection URI para ver o código correspondente para cada abordagem:

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)

No exemplo anterior, o driver Scala distribui leituras entre membros correspondentes dentro de 35 milissegundos do tempo de ping do membro mais próximo.