Um guia do desenvolvedor para conjuntos de réplicas do MongoDB

Replicação no MongoDB

Replicação mestre-escravo

mongod --master --port portNumber

mongod --slave --source <masterhostname><:<port>>

Conjuntos de réplicas

Árbitros

1. Ele não tem uma cópia do conjunto de dados, portanto, não requer hardware tão poderoso quanto os nós de suporte de dados.
2. Não pode ser promovido a principal.
3. Eles sempre têm 1 voto eleitoral para permitir que o conjunto de réplicas tenha um número ímpar de membros votantes sem a sobrecarga de um membro adicional que replica os dados. Seu papel crucial é, portanto, selecionar um nó primário quando não estiver disponível.
4. Permanece inalterado.

Replicação assíncrona

Na sincronização inicial, os dados são copiados de um membro do conjunto de réplicas para outro. Quando o processo é concluído, o membro faz a transição para o nó secundário.

Failover automático do MongoDB

Membros do conjunto de réplicas com prioridade zero

Membros do conjunto de réplicas ocultas do MongoDB

Membros do conjunto de réplicas atrasadas do MongoDB

1. A duração deve ser menor que a capacidade do log de operação, que para os mecanismos de armazenamento WiredTiger, MMAPv1 e In-Memory é de 50 GB. Caso contrário, o membro atrasado não poderá replicar operações com êxito.
2. A duração do atraso deve ser igual ou ligeiramente maior do que as durações esperadas da janela de manutenção.

Configuração

{
    “_id”: <num>, 
    “Host”: <hostname: port>,
    “Priority”: 0,
    “slaveDelay”: <seconds>,
    “Hidden”: true
} 

cfg = rs.conf()
cfg.members[0].priority = 0
cfg.members[0].hidden = true
cfg.members[0].slaveDelay = 3600
rs.reconfig(cfg)

Como iniciar um conjunto de réplicas

1. Digamos que você tenha 3 mongodb que deseja replicar e eles estão configurados da seguinte forma:
   1. Mongod1.conf em execução na porta 27017
   2. Mongod2.conf em execução na porta 27018
   3. Mongod3.conf em execução na porta 27019
   
   Certifique-se de adicionar o nome do conjunto de réplicas que não será alterado em cada arquivo. Você pode fazer isso adicionando ou alterando o valor da opção replSet para um nome de sua escolha.
   
2. 
   Podemos iniciar a primeira instância executando
   

   sudo mongod --config /etc/mongo/mongod1.conf

   
   Isto é, se você não tiver nenhuma instância em execução do mongod. Em seguida, faça o mesmo para as outras instâncias. Para verificar se há instâncias em execução em sua máquina, execute
   

   ps -ax | grep mongo

   
   Você obterá uma lista como esta:
   

   4328 ttys000    0:06.15 mongod
   4950 ttys001    0:00.00 grep mongo

   Isso significa que a primeira instância no MongoDB por padrão é executada na porta 27017, portanto, a temos como a primeira da lista. Se você iniciou os outros, eles também serão descritos na lista com seus URLs de caminho correspondentes. Para se conectar a uma instância no shell do mongo, execute este comando:

   mongo  --port port_number i.e mongo  --port 27017.

   No entanto, em nosso caso, precisamos nos conectar com um nome de conjunto de réplicas, então temos que adicionar o nome ao comando:

   mongod --replSet replicaSetName --dbpath /usr/local/var/mongo/mongod --port 27017

   Neste caso, nosso replicaSetName =“testrep”
3. 
   Vamos verificar se há algum conjunto de réplicas habilitado executando rs.status()
   
   Se você obtiver um resultado como:
   

   {
       "ok" : 0,
       "errmsg" : "not running with --replSet",
       "code" : 76,
       "codeName" : "NoReplicationEnabled"
   }

   
   Isso significa que não há nenhum conjunto de réplicas habilitado. Caso contrário, se você obtiver o resultado como
   

   {
       "operationTime" : Timestamp(0, 0),
       "ok" : 0,
       "errmsg" : "no replset config has been received",
       "code" : 94,
       "codeName" : "NotYetInitialized",
       "$clusterTime" : {
           "clusterTime" : Timestamp(0, 0),
           "signature" : {
               "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
               "keyId" : NumberLong(0)
           }
       }
   }

   
   significa que a réplica ainda não foi iniciada.
   
4. 
   O método rs.initiate() nos ajudará a iniciar um novo conjunto de réplicas e a instância na qual ele é iniciado se tornará nosso nó principal. Assim, podemos iniciar um em nossa instância executando o método start. rs.initiate().
   
5. 
   Verifique o status do conjunto de réplicas novamente executando rs.status().members. Agora você deve ver algo como
   

   "members" : [
           {
               "_id" : 0,
               "name" : "localhost:27018",
               "health" : 1,
               "state" : 1,
               "stateStr" : "PRIMARY",
               "uptime" : 577,
               "optime" : {
                   "ts" : Timestamp(1535301271, 1),
                   "t" : NumberLong(1)
               },
               "optimeDate" : ISODate("2018-08-26T16:34:31Z"),
               "syncingTo" : "",
               "syncSourceHost" : "",
               "syncSourceId" : -1,
               "infoMessage" : "could not find member to sync from",
               "electionTime" : Timestamp(1535301265, 1),
               "electionDate" : ISODate("2018-08-26T16:34:25Z"),
               "configVersion" : 1,
               "self" : true,
               "lastHeartbeatMessage" : ""
           }
       ]

   
   Bem, bom para ir. Nosso interesse será a opção de membros, pois podemos ver que é n array com 1 membro nele. Verificando a opção stateStr do primeiro membro, neste caso, ele está definido como Primário, o que significa que isso funcionará como nosso nó principal.
   
6. 
   Adicione um novo membro ao conjunto de réplicas usando seu nome de host. Para verificar o nome do host da instância conectada que você deseja adicionar, execute
   

   db.serverStatus().host

   
   Você obterá algo como
   

   ervername.local:27019

   
   Portanto, a partir do PRIMARY, você pode adicionar outro membro executando este comando no shell do mongo:
   

   rs.add("servername.local:27019");

7. 
   Execute o comando de status
   

   rs.status().members

   
   Para verificar se as alterações foram feitas.
   
   Agora você deve ter algo parecido com isso:
   

   [
       {
           "_id" : 0,
           "name" : "localhost:27018",
           "health" : 1,
           "state" : 1,
           "stateStr" : "PRIMARY",
           "uptime" : 11479,
           "optime" : {
               "ts" : Timestamp(1535312183, 1),
               "t" : NumberLong(1)
           },
           "optimeDate" : ISODate("2018-08-26T19:36:23Z"),
           "syncingTo" : "",
           "syncSourceHost" : "",
           "syncSourceId" : -1,
           "infoMessage" : "",
           "electionTime" : Timestamp(1535301265, 1),
           "electionDate" : ISODate("2018-08-26T16:34:25Z"),
           "configVersion" : 2,
           "self" : true,
           "lastHeartbeatMessage" : ""
       },
       {
           "_id" : 1,
           "name" : "127.0.0.1:27019",
           "health" : 1,
           "state" : 2,
           "stateStr" : "SECONDARY",
           "uptime" : 15,
           "optime" : {
               "ts" : Timestamp(1535312183, 1),
               "t" : NumberLong(1)
           },
           "optimeDurable" : {
               "ts" : Timestamp(1535312183, 1),
               "t" : NumberLong(1)
           },
           "optimeDate" : ISODate("2018-08-26T19:36:23Z"),
           "optimeDurableDate" : ISODate("2018-08-26T19:36:23Z"),
           "lastHeartbeat" : ISODate("2018-08-26T19:36:26.302Z"),
           "lastHeartbeatRecv" : ISODate("2018-08-26T19:36:27.936Z"),
           "pingMs" : NumberLong(0),
           "lastHeartbeatMessage" : "",
           "syncingTo" : "localhost:27018",
           "syncSourceHost" : "localhost:27018",
           "syncSourceId" : 0,
           "infoMessage" : "",
           "configVersion" : 2
       }
   ]

   
   Agora temos 2 membros, um é um nó PRIMARY e o outro é um nó SECONDARY. Você pode adicionar mais membros, mas não excedendo 50. Agora vamos criar um banco de dados na instância na porta 27018 como principal.
   
   Se desconectarmos o primário, ocorrerá um failover e, como temos apenas 1 primário, ele será automaticamente transferido para um secundário. Agora, se nos conectarmos à porta 27019, você deverá obter os mesmos bancos de dados e coleções com seus documentos.
   
   Agora, se o nó primário desconectado for reconectado, ele será adicionado como secundário, pois copia as operações do oplog do primário existente.
   

Preocupação de gravação do conjunto de réplicas do MongoDB

db.books.insert({name: “James”,place: “Beijing”},{writeConcern: {w: 3, wtimeout: 3600}})

Configurando a preocupação de gravação para o MongoDB

cfg = rs.conf()
cfg.settings = {},
cfg.settings.getLastErrorDefaults = {w: “majority”, wtimeout: 3600}
rs.reconfig(cfg)

Bloqueio de replicação

db.runCommand({getLastError: 1, w: N, “wtimeout”: 5000});

Preferência de leitura no MongoDB

1. Manter a disponibilidade de dados durante o failover.
2. Para aplicativos distribuídos geograficamente, o primário fornecerá leituras locais para clientes no mesmo datacenter.
3. Para não afetar os aplicativos front-end, especialmente aqueles que executam operações do sistema.

Mongo.setReadPref() Método

db.getMongo().setReadPref('primaryPreferred',
                          [ { "dc": "east", "use": "production" },
                            { "dc": "east", "use": "reporting" },
                            { "dc": "east" },
                            {}
                          ] )

Modos de preferência de leitura

• Primário:define que todas as operações de leitura lidas de um determinado conjunto de réplicas são primárias e é o modo de leitura de preferência padrão.
• PrimaryPreferred:se apenas o primário não estiver disponível, as operações de leitura poderão ser feitas a partir dos secundários.
• Secundário:todas as operações de leitura são feitas a partir dos membros secundários do conjunto de réplicas.
• SecondaryPreferred:se apenas não houver secundário disponível, as operações de leitura podem ser feitas a partir do primário.
• Mais próximo:o membro com menor latência de rede é selecionado para a operação de leitura, independentemente de seu tipo.

Conjuntos de tags e suas configurações

[
    {
        "_id" : 0,
        "host" : "localhost:27018",
        "arbiterOnly" : false,
        "buildIndexes" : true,
        "hidden" : false,
        "priority" : 1,
        "tags" : {
            
        },
        "slaveDelay" : NumberLong(0),
        "votes" : 1
    },
    {
        "_id" : 1,
        "host" : "127.0.0.1:27019",
        "arbiterOnly" : false,
        "buildIndexes" : true,
        "hidden" : false,
        "priority" : 1,
        "tags" : {
            
        },
        "slaveDelay" : NumberLong(0),
        "votes" : 1
    }
]

{ "disk": "ssd", "use": "reporting" }

{ "disk": "ssd", "use": "reporting", "rack": "a" }

{ "disk": "ssd", "use": "production", "rack": "k" }

Adicionando tags a uma réplica definida

conf = rs.conf()
conf.members[0].tags = { "dc": "NYK", "use": "production"  }
conf.members[1].tags = { "dc": "LON", "use": "reporting"  }
conf.members[2].tags = { "use": "production"  }
rs.reconfig(conf)

Padrões de implantação para o conjunto de réplicas do MongoDB

1. Conjunto de réplicas geograficamente distribuído - Melhora a redundância de dados, além de proteger os dados contra falhas, como perda de energia. As instâncias em execução estão localizadas em vários locais.
2. Conjunto de réplicas de três membros - a arquitetura padrão básica para um conjunto de réplicas.
3. Conjunto de réplicas de quatro ou mais membros - permite uma redundância mais ampla de dados e também oferece suporte a uma distribuição mais ampla de operações de leitura no conjunto de réplicas.

Técnicas de ajuste de implantação do conjunto de réplicas do MongoDB

1. Use membros atrasados ​​e ocultos para oferecer suporte a funções dedicadas, como relatórios e backup.
2. Sempre faça com que o número de membros implantados seja ímpar. Como discutimos acima, um número ímpar de membros será necessário para eleger uma primária. Portanto, certifique-se de ter um número ímpar e, se não, você sempre pode adicionar um árbitro.
3. Para implantações de leitura intensa, você precisará equilibrar a carga. Portanto, você precisará distribuir leituras para o secundário para melhorar o desempenho de leitura. Além disso, quando os dados crescem com o tempo, você pode adicionar mais membros e distribuí-los, mas lembre-se de que você deve configurá-los de tal forma que o design primordial seja eleger o principal.
4. Sempre considere a tolerância a falhas. Isso basicamente determina quantos membros podem estar indisponíveis em um determinado momento e quantos permanecerão para sustentar o processo de eleição de uma primária. Se você não tiver um primário, infelizmente o conjunto de réplicas não aceitará nenhuma operação de gravação.
5. Adicione novos membros ao conjunto de réplicas existente antes que surja a demanda.
6. Use conjuntos de tags de conjunto de réplicas para garantir que todas as operações sejam replicadas em data centers específicos. Você também pode usar essas tags no roteamento para as operações de leitura para máquinas de implantação específicas.
7. Implante a maioria de seus membros em um local para evitar o contratempo que surgirá do particionamento de rede. O particionamento de rede pode ser resultado de comunicação desconectada entre data centers, consequentemente dificultando o processo de replicação e o processo de eleição de um primário.
8. Por motivos de segurança, distribua seus membros geograficamente além de fazer alguns escondidos. Você pode definir a prioridade de pelo menos 2 ou 3 membros como zero para evitar torná-los primários.
9. Empregue o registro no diário para proteger a perda de dados que pode resultar em algo como uma falha de energia. Isso garante que os dados sejam gravados no disco em caso de desligamento repentino.

O Registro de Operação (Oplog)

db.database({replSetResizeOplog:1, size: 16384})

Padrões de carga de trabalho que exigiriam um tamanho grande de oplog

1. Atualize para vários documentos de uma só vez. As várias operações de atualização devem ser convertidas em uma operação individual para melhorar os resultados nos nós. Esta operação usará um vasto espaço do espaço oplog.
2. Número significativo de atualizações no local. Isso geralmente acontece ao atualizar dados de documentos não necessariamente aumentando o tamanho deste documento. O banco de dados registrará um grande número de operações no oplog, aumentando seu tamanho.
3. As exclusões equivalem à mesma quantidade de dados que as inserções. Isso acontece quando você tenta excluir uma quantidade de dados (quase) igual à quantidade de dados inserida. Esta operação tenderá a aumentar o tamanho do oplog.

Conclusão