Implantar um conjunto de réplicas com alta disponibilidade no MongoDB 3.4 usando o arquivo de chaves para controle de acesso no Ubuntu 16.04

• Sobre o conjunto de réplicas
• Pré-requisitos
• Projetar o conjunto de réplicas
• Instruções de implantação
• Conclusão

Desde sua concepção, em 2009, o MongoDB lidera o setor NoSQL. Um dos principais conceitos do MongoDB é o conjunto de réplicas; portanto, antes de trabalhar com ele, primeiro vamos revisar o conceito.

Sobre o conjunto de réplicas

O modelo mais simples de comunicação usado na replicação de bancos de dados é a arquitetura Master-Slave. Como o nome sugere, este modelo possui 2 funções espalhadas em um mestre único e em muitos escravos, o papel do mestre é processar as operações de leitura e gravação realizadas pelos clientes e os escravos são tratados como uma réplica do mestre.

A vantagem mais importante desse modelo é que o desempenho do mestre não é comprometido pelas operações de backup, as operações de backup são feitas de maneira assíncrona e isso pode se tornar um problema sério quando um nó mestre falha. Os nós escravos são apenas de leitura e precisam ser promovidos manualmente para o nó mestre, portanto, neste momento, há a possibilidade de perda de dados.

Uma opção para resolver o problema de disponibilidade é ter mais de um mestre na arquitetura, mas isso pode levar a outro problema na consistência dos dados entre essas instâncias e na complexidade adicional da configuração.

Agora, considerando o contexto, podemos apresentar a tecnologia Replica Set do MongoDB. Conjunto de réplicas é o nome da arquitetura Master-Slave que possui failover automático; portanto, no momento em que um primarynó mestre (que agora é chamado ) falhar em funcionar adequadamente, um electiongatilho será ativado e um novo nó primário será eleito dos escravos restantes ( referido agora como secondaries).

Nó primário

O nó primário é o único que executa operações de gravação; por padrão, as operações de leitura também são tratadas pelo primário, mas esse comportamento pode ser alterado posteriormente.

As operações são registradas no oplog(log de operações), e os nós secundários atualizam seu conteúdo de forma assíncrona, com base no conteúdo dooplog

Nota: oplogé uma coleção limitada, isso significa que a coleção tem um limite, com local.oplog.rsvocê pode verificar o conteúdo dessa coleção dentro de um shell mongo em qualquer membro do conjunto.

Nó secundário

Além de fazer o backup adequado do banco de dados, um nó secundário possui as seguintes funções:

• Pode aceitar operações de leitura, se necessário.
• Pode desencadear uma eleição se um nó primário falhar.
• Pode votar nas eleições.
• Pode se tornar o novo primário, se necessário.

Graças a essas características, podemos ter diferentes tipos de nós secundários:

• Prioridade 0 : esses nós não podem se tornar um primarye não podem desencadear uma eleição, ainda assim podem votar nas eleições, ter uma réplica completa e aceitar operações de leitura. Isso pode ser útil na implantação de vários centros de dados.
• Oculto : Estes são Priority 0membros, mas, além disso, não podem processar operações de leitura. Eles podem votar se necessário. As tarefas preferidas para esses membros são relatórios e backups.
• Atrasado : esses nós são responsáveis ​​por "dados históricos" por serem atrasados ​​com alguma unidade no tempo. Um membro atrasado deve ser um priority 0nó e é recomendável que ele também seja um hiddenmembro.

Pré-requisitos

• A disponibilidade para executar no mínimo 3 instâncias do Ubuntu 16.04 x64 com o mesmo tamanho de servidor.

Projetar o conjunto de réplicas

Antes de implantar uma infraestrutura, é importante projetá-la e há pontos a serem considerados nesse design.

Escolhendo o número de membros

Lembre-se de que o número mínimo de elementos para criar um conjunto de réplicas é 3. Você pode misturar os três tipos de nós com no mínimo um nó primário e um secundário.

Neste guia, estamos implantando 3 membros, um primário e dois secundários padrão.

Nota: Recomenda-se ter um número máximo de 7 membros votantes com uma mistura de árbitros e membros secundários.

Escolha um nome

O nome é apenas para referência, mas você o está usando na configuração do conjunto. Lembre-se de que você pode ter mais de uma réplica configurada em seu ambiente de produção; portanto, não negligencie o nome do seu conjunto.

Este tutorial incentiva o usuário a selecionar o nome do conjunto.

Distribuição dos membros em diferentes data centers

Este tutorial sugere a implantação no mesmo datacenter para evitar problemas de comunicação.

Nota: No caso de implantar em diferentes data centers, é recomendável envolver seus nós com uma VPN

Instruções de implantação

Etapa 1: implantar os nós mínimos para sua infraestrutura

Inicie 3 nós do Ubuntu 16.04 x64; na mesma região do portal do cliente, se possível. Não esqueça de nomeá-los de acordo com o tipo de projeto com o qual você está lidando e certifique-se de ter o mesmo tamanho de servidor em todos esses nós.

Depois de implantar seus 3 nós, você precisará garantir que todos os nós possam conversar com o resto. Você precisa ssh em dois nós e alcançar os outros usando ping -c 4 EXAMPLE_IP. Mude EXAMPLE_IPpara os IPs reais dos seus nós.

Aqui você pode ver um exemplo de comunicação bem-sucedida entre dois nós.

root@foo_node:~# ping -c 4 EXAMPLE_IP
PING EXAMPLE_IP (EXAMPLE_IP) 56(84) bytes of data.
64 bytes from EXAMPLE_IP: icmp_seq=1 ttl=59 time=0.594 ms
64 bytes from EXAMPLE_IP: icmp_seq=2 ttl=59 time=0.640 ms
64 bytes from EXAMPLE_IP: icmp_seq=3 ttl=59 time=0.477 ms
64 bytes from EXAMPLE_IP: icmp_seq=4 ttl=59 time=0.551 ms

--- EXAMPLE_IP ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3021ms
rtt min/avg/max/mdev = 0.477/0.565/0.640/0.064 ms

Etapa 2: Instale o MongoDB em cada nó da sua infraestrutura

Em geral, você pode usar o pacote MongoDB do Ubuntu, mas é melhor usar o repositório oficial da comunidade, pois ele está sempre atualizado. Este repositório contém estes pacotes:

• mongodb-org , o pacote de grupo que envolve os quatro componentes.
• mongodb-org-server , contém o mongoddaemon (processo primário que lida com solicitações de dados).
• mongodb-org-mongos , contém o mongosdaemon (serviço de roteamento para implantações compartilhadas).
• mongodb-org-shell , esta é a mongo shellinterface JavaScript.
• mongodb-org-tools , algumas ferramentas para atividades administrativas.

Prossiga com a instalação dos pacotes.

Importe a chave pública para o sistema de gerenciamento de pacotes.

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 0C49F3730359A14518585931BC711F9BA15703C6

Crie o arquivo de lista para o MongoDB '/etc/apt/sources.list.d/mongodb-org-3.4.list'.

echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.4.list

Atualize o banco de dados do pacote.

sudo apt-get update

Instale o metapacote do MongoDB.

sudo apt-get install -y mongodb-org

Inicie o serviço MongoDB.

sudo service mongod start

Agora você pode abrir a mongo shellsessão em qualquer bash. Para fazer isso, você precisa usar o mongocomando Você será recebido por algo semelhante a isso.

MongoDB shell version v3.4.7
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 3.4.7
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see http://docs.mongodb.org/
Questions? Try the support group
http://groups.google.com/group/mongodb-user
Server has startup warnings:
*Some extra logs are cut by the way*
>

Não se esqueça de desligar o serviço sudo service mongod stop, pois mais tarde iniciaremos mongodnovamente com alguns parâmetros. Repita esse processo em todos os 3 nós do conjunto.

Etapa 3: configurar o arquivo de chave de acesso

O uso de um arquivo de chave força dois conceitos na administração do Conjunto de Réplicas. O primeiro é Internal Authentication. Por padrão, você pode iniciar uma mongo shellsessão sem usar um usuário e esta sessão terá controle total do banco de dados, mas quando você usa um arquivo de chave para autenticação, sua mongo shellsessão atinge um estado chamado localhost exception. Esse estado permite criar apenas o usuário administrador e o conjunto de réplicas. O segundo conceito é Role-Based Access Control, ou em outras palavras, autorização. Isso é imposto para controlar os níveis administrativos no conjunto de réplicas.

Crie seu arquivo-chave

O arquivo de chave é a senha a ser usada no conjunto; essa senha deve ser a mesma em todos os membros do conjunto. Para aumentar a segurança, é importante usar uma chave aleatória com a ferramenta de sua escolha.

O conteúdo deve ter entre 6 e 1064 caracteres. Além disso, você deve definir a read onlypermissão para o arquivo de chave.

chmod 400 PATH_OF_YOUR_KEYFILE

Coloque o arquivo de chave em cada membro do conjunto

Agora copie seu arquivo-chave para cada membro do conjunto, use uma pasta consistente para referência futura e não armazene-a em uma mídia removível.

Também use uma pasta para o arquivo que mongodpode acessar.

Aplicar usando o arquivo de chave no conjunto de réplicas

Nesta etapa, precisamos iniciar o mongod daemon em cada membro do conjunto . Existem duas maneiras de iniciar o mongodprocesso: usando um arquivo de configuração ou usando a linha de comando. Ambos são métodos bastante fáceis, mas, para simplificar, este tutorial usa a versão da linha de comandos.

Configuração da linha de comando

Use o nome que você escolheu anteriormente neste comando.

mongod --keyFile PATH_OF_YOUR_KEYFILE --replSet "YOUR_SET_NAME"

Por padrão, mongodnão é executado como um daemon. Você precisará usar o --forkparâmetro ou o upstartpara executá-lo completamente como um daemon. Neste tutorial, não recomendamos a execução mongodcomo um daemon, para que você possa ver os logs diretamente no seu terminal.

Nota: Digite com cuidado o nome do conjunto de réplicas porque, uma vez criado, você não poderá alterá-lo.

Etapa 4: Conecte-se à interface localhost de um dos membros do conjunto

Nota: Se você executar mongodcomo um processo não daemon, será necessário abrir outra conexão ssh para continuar trabalhando.

Você deve usar o mongocomando para abrir o arquivo mongo shell. Isso pode ser feito em qualquer membro do conjunto.

Neste momento, estamos em um estado chamado localhost exception. Quando um arquivo de chave é usado para configurar o mongodprocesso, você é obrigado a criar um administrador de banco de dados antes de poder aplicar operações de leitura e gravação, mas entraremos nisso mais tarde.

Etapa 5: iniciando o conjunto de réplicas

Esta é uma parte delicada, estamos usando o comando rs.initiate()dentro mongo shellda Etapa 4. Antes de usar este comando, vamos revisá-lo.

rs.initiate(
  {
    _id : <replicaSetName>,
    members: [
      { _id : 0, host : "example1.net:27017" },
      { _id : 1, host : "example2.net:27017" },
      { _id : 2, host : "example3.net:27017" }
    ]
  }
)

O primeiro _idcampo é uma sequência e deve corresponder ao --replSetque foi passado antes para mongod. Além disso, cada valor de hostdeve ser o ip ou o nome de domínio de cada membro do conjunto de réplicas. Não esqueça de anexar a porta que a instância do mongo está usando em cada membro.

Agora é hora de executar o comando com seus dados, isso acionará um e election, em seguida, um primário será eleito automaticamente.

Aqui você deve observar que o cursor do shell mudou para YOUR_SET_NAME:PRIMARY>ou YOUR_SET_NAME:SECONDARY. Isso significa que a criação de um conjunto foi um sucesso.

Para continuar trabalhando, você precisa encontrar o primary, se não estiver nele, é claro. Use o rs.status()comando para mostrar as informações do conjunto de réplicas e localize o primary. Você está procurando a propriedade "stateStr" : "PRIMARY".

Etapa 6: Criando o Administrador

Depois de localizar o primary, digite mongo shelle execute o próximo comando usando seus dados.

admin = db.getSiblingDB("admin")
admin.createUser(
  {
    user: "YOUR_USER",
    pwd: "YOU_PASSWORD",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
  }
)

A admin = db.getSiblingDB("admin")parte nos permite escrever em adminum banco de dados diferente. Isso cria um alias chamado admin, para que possamos executar comandos usando-o.

Se a operação for bem-sucedida, você receberá uma notificação de que o usuário foi adicionado.

Successfully added user: {
    "user" : "YOUR_USER",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}

Neste ponto, só temos um administrador para todos os servidores, mas ter uma réplica definida nos obriga a ter um usuário com a clusterAdminfunção. Criaremos outro usuário com apenas essa função para separar preocupações.

Etapa 7: Autenticando como Administrador

Atingimos o limite de localhost exception, e é por isso que precisamos alterar a autenticação para o usuário criado uma etapa antes.

Você pode alterar os usuários dentro do mongo shellcom o seguinte.

db.getSiblingDB("admin").auth("YOUR_ADMIN", "YOUR_PASSWORD" )

Se você ainda não se conectou ao mongo shelluse este comando.

mongo -u "YOUR_ADMIN" -p "YOUR_PASSWORD" --authenticationDatabase "admin"

Você será notificado sobre a alteração de um usuário e poderá seguir o próximo passo.

Etapa 8: Criando o Principal do Cluster

A clusterAdminfunção fornece ao usuário controle total do conjunto de réplicas. Criá-lo é tão fácil quanto criar o usuário administrador.

db.getSiblingDB("admin").createUser(
  {
    "user" : "YOUR_USER",
    "pwd" : "YOUR_PASSWORD",
    roles: [ { "role" : "clusterAdmin", "db" : "admin" } ]
  }
)

Observe que desta vez a função é alterada paraclusterAdmin .

Etapa 9: Inserir dados no conjunto de réplicas

Neste momento, temos 2 usuários administrativos: um com controle total sobre o servidor e outro com acesso a tarefas administrativas no nível do conjunto de réplicas. No entanto, não temos um usuário que tenha acesso para "usar" um banco de dados. Portanto, criaremos esse usuário agora.

admin = db.getSiblingDB("admin")
admin.createUser(
  {
    user: "YOUR_USER",
    pwd: "YOUR_PASSWORD",
    roles: [ { role: "userAdminAnyDatabase", db: "cars" } ]
  }
)

Observe que desta vez estamos alterando a dbparte, lá estamos colocando o banco de dados acessível ao usuário, neste caso, estamos usando um banco de dados chamado cars.

O banco de dados ainda não foi criado. Para fazer isso, você precisará digitar alguns comandos para criá-lo implicitamente. Alterne para o carsbanco de dados.

use cars

Você receberá uma notificação: switched to db cars.

O banco de dados ainda não foi criado; para isso, você precisa escrever algo nele. Estamos usando o exemplo a seguir.

db.models.insert({ make: "Dodge", model: "Viper", year: 2010 })

Desta vez, você será notificado com WriteResult({ "nInserted" : 1 }).

Se desejar, você pode recuperar todos os objetos no banco de dados, com o find()método:

db.models.find()
{ "_id" : ObjectId("59acd8b55334882863541ff4"), "make" : "Dodge", "model" : "Viper", "year" : 2010 }

Observe que _ida saída será diferente, mas os outros dados devem ser os mesmos. Com tempo suficiente, esses dados serão replicados para os outros membros.

Conclusão

A criação de um conjunto de réplicas pode ser desafiadora a princípio, porque há muitas informações para entender, mas depois que você tiver a ideia por trás disso, poderá implantá-la rapidamente, portanto, não desista se não puder entendê-la pela primeira vez. Lembre-se de que o conjunto de réplicas é importante na administração do MongoDB, pois abre a possibilidade de adicionar recursos avançados, como o balanceamento de carga.