Configurar operações CRUD

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 método MongoClient.create(). 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 settings = MongoClientSettings.builder()
    .applyConnectionString(ConnectionString("mongodb://localhost:27017/"))
    .readPreference(ReadPreference.secondary())
    .readConcern(ReadConcern.LOCAL)
    .writeConcern(WriteConcern.W2)
    .build()
val mongoClient = MongoClient.create(settings)

Alternativamente, você pode especificar as configurações de leitura e escrita no URI de conexão, que é passado como um parâmetro para o método MongoClient.create():

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

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 withTransaction(). 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, utilize o método startSession() 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.

mongoClient.startSession().use { session ->
    try {
        // Sets transaction read and write settings
        val txnOptions = TransactionOptions.builder()
            .readPreference(ReadPreference.primary())
            .readConcern(ReadConcern.MAJORITY)
            .writeConcern(WriteConcern.W1)
            .build()
        session.withTransaction({
            // Specify transaction operations here
        }, txnOptions)
    } catch (e: Exception) {
        println("Transaction failed: ${e.message}")
    }
}

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<Document>("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, 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:

val shardedClient = MongoClient.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 do Kotlin Sync ignora as tags ao escolher um membro para ler. Para instruir o driver Kotlin Sync 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 = TagSet(Tag("dc", "ny"))
val tag2 = TagSet(Tag("dc", "sf"))
val tag3 = TagSet() // Empty tag set as fallback
val readPref = ReadPreference.secondary(listOf(tag1, tag2, tag3))
val taggedDb = 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 Kotlin Sync 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 do Kotlin Sync determina a instância 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 deste mongos ao valor localThresholdMS. O driver equilibra as solicitações em até duas instâncias aleatórias 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 Kotlin Sync 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.

val latencySettings = MongoClientSettings.builder()
    .applyConnectionString(ConnectionString("mongodb://localhost:27017/"))
    .applyToClusterSettings { builder ->
        builder.localThreshold(35, TimeUnit.MILLISECONDS)
    }
    .build()
val latencyClient2 = MongoClient.create(latencySettings)

val latencyClient1 = MongoClient.create(
    "mongodb://localhost:27017/?replicaSet=repl0&localThresholdMS=35"
)