Guia Passo a Passo: Implantando um Cluster MongoDB Fragmentado Básico

O MongoDB, um popular banco de dados de documentos NoSQL, se destaca no manuseio de grandes volumes de dados com alto desempenho e flexibilidade. No entanto, à medida que os dados crescem, um único servidor ou conjunto de réplicas pode atingir seus limites de escalabilidade. É aqui que o fragmentação (sharding) entra em ação, permitindo a escalabilidade horizontal ao distribuir dados por vários servidores, ou shards.

Este guia abrangente o guiará por todo o processo de configuração de um cluster MongoDB fragmentado funcional. Você aprenderá a configurar os componentes essenciais: servidores de configuração (config servers), roteadores mongos e conjuntos de réplicas de shard. Ao final deste tutorial, você terá uma compreensão fundamental e experiência prática na implantação de um cluster fragmentado projetado para alta escalabilidade horizontal e disponibilidade.

Entendendo Clusters MongoDB Fragmentados

Um cluster MongoDB fragmentado consiste em três componentes principais que trabalham juntos para distribuir e rotear dados:

• Conjuntos de Réplicas de Shard (Shard Replica Sets): Estes são os nós que contêm os dados reais. Cada shard é um conjunto de réplicas para fornecer alta disponibilidade e redundância de dados. Os dados são particionados entre esses shards.
• Servidores de Configuração (Config Servers): Estes armazenam os metadados do cluster, incluindo o mapeamento de blocos de dados para shards. A partir do MongoDB 3.2, os servidores de configuração devem ser implantados como um conjunto de réplicas (CSRS - Config Server Replica Set) para alta disponibilidade e consistência.
• Roteadores mongos: Estes atuam como roteadores de consulta, fornecendo uma interface para as aplicações cliente. Uma instância mongos direciona as operações do cliente para o(s) shard(s) apropriado(s) com base nos metadados do cluster. As aplicações se conectam ao mongos, e não diretamente aos shards.

Diagrama conceitual de um cluster MongoDB fragmentado (crédito da imagem: documentação oficial do MongoDB)

Pré-requisitos

Antes de começar, certifique-se de ter o seguinte:

1. Múltiplas Máquinas/VMs: Para um cluster fragmentado verdadeiramente distribuído, você precisará de pelo menos 6-9 máquinas/VMs/contêineres Docker. Para este tutorial básico, podemos simular isso em uma única máquina usando portas diferentes, mas lembre-se que uma configuração de produção requer recursos dedicados.
   • 3 para Servidores de Configuração (configSrv01, configSrv02, configSrv03)
   • Mínimo de 2-3 para cada Shard (ex: Shard01-RS01, Shard01-RS02, Shard01-RS03; Shard02-RS01, ...)
   • 1+ para Roteadores mongos
2. Instalação do MongoDB: MongoDB 4.2+ instalado em todas as máquinas que hospedarão instâncias mongod ou mongos. Você pode encontrar instruções de instalação na Documentação do MongoDB.
3. Rede: Garanta que todas as máquinas possam se comunicar umas com as outras nas portas necessárias (padrão 27017, 27018, 27019, 27020 para servidores de configuração, shards e mongos, respectivamente, ou portas personalizadas).
4. Estrutura de Diretórios: Crie diretórios de dados e logs dedicados para cada instância mongod e mongos.

Para simplificar neste guia, usaremos localhost com portas e diretórios diferentes. Em um ambiente de produção, você usaria nomes de host ou endereços IP reais.

Estrutura de Diretórios Recomendada (Exemplo para configuração localhost)

mkdir -p /data/db/configdb01 /data/db/configdb02 /data/db/configdb03
mkdir -p /data/db/shard01-rs01 /data/db/shard01-rs02 /data/db/shard01-rs03
mkdir -p /data/db/shard02-rs01 /data/db/shard02-rs02 /data/db/shard02-rs03
mkdir -p /data/log/config /data/log/shard01 /data/log/shard02 /data/log/mongos

Passos de Implantação

Passo 1: Configurar Servidores de Configuração (Config Replica Set)

Os servidores de configuração armazenam metadados para o cluster fragmentado. Eles devem ser executados como um conjunto de réplicas.

1. Iniciar instâncias mongod para servidores de configuração: Cada instância precisa das opções --configsvr e --replSet.

   ```bash

   Servidor de Configuração 1

   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb01 --port 27019 --bind_ip localhost --logpath /data/log/config/configdb01.log --fork

   Servidor de Configuração 2

   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb02 --port 27020 --bind_ip localhost --logpath /data/log/config/configdb02.log --fork

   Servidor de Configuração 3

   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb03 --port 27021 --bind_ip localhost --logpath /data/log/config/configdb03.log --fork
   ```

   Dica: Para produção, substitua localhost por endereços IP ou nomes de host reais.

2. Inicializar o Conjunto de Réplicas de Configuração: Conecte-se a uma das instâncias do servidor de configuração e inicialize o conjunto de réplicas.

   bash mongo --port 27019

   Dentro do shell mongo:

   javascript rs.initiate({ _id: "cfgReplSet", configsvr: true, members: [ { _id : 0, host : "localhost:27019" }, { _id : 1, host : "localhost:27020" }, { _id : 2, host : "localhost:27021" } ] });

   Verifique o status:

   javascript rs.status();

Passo 2: Configurar Conjuntos de Réplicas de Shard

Cada shard no cluster é um conjunto de réplicas. Configuraremos dois shards (shard01 e shard02), cada um com três membros.

1. Iniciar instâncias mongod para os membros do Shard 1: Cada instância precisa das opções --shardsvr e --replSet.

   ```bash

   Membro do Shard 1, 1

   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs01 --port 27030 --bind_ip localhost --logpath /data/log/shard01/shard01-rs01.log --fork

   Membro do Shard 1, 2

   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs02 --port 27031 --bind_ip localhost --logpath /data/log/shard01/shard01-rs02.log --fork

   Membro do Shard 1, 3

   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs03 --port 27032 --bind_ip localhost --logpath /data/log/shard01/shard01-rs03.log --fork
   ```

2. Inicializar o Conjunto de Réplicas do Shard 1: Conecte-se a uma das instâncias do Shard 1.

   bash mongo --port 27030

   Dentro do shell mongo:

   javascript rs.initiate({ _id : "shard01", members: [ { _id : 0, host : "localhost:27030" }, { _id : 1, host : "localhost:27031" }, { _id : 2, host : "localhost:27032" } ] });

3. Iniciar instâncias mongod para os membros do Shard 2 (repetir para shards adicionais):

   ```bash

   Membro do Shard 2, 1

   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs01 --port 27040 --bind_ip localhost --logpath /data/log/shard02/shard02-rs01.log --fork

   Membro do Shard 2, 2

   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs02 --port 27041 --bind_ip localhost --logpath /data/log/shard02/shard02-rs02.log --fork

   Membro do Shard 2, 3

   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs03 --port 27042 --bind_ip localhost --logpath /data/log/shard02/shard02-rs03.log --fork
   ```

4. Inicializar o Conjunto de Réplicas do Shard 2: Conecte-se a uma das instâncias do Shard 2.

   bash mongo --port 27040

   Dentro do shell mongo:

   javascript rs.initiate({ _id : "shard02", members: [ { _id : 0, host : "localhost:27040" }, { _id : 1, host : "localhost:27041" }, { _id : 2, host : "localhost:27042" } ] });

Passo 3: Configurar Roteadores mongos

As instâncias mongos são os pontos de entrada para as aplicações cliente. Elas precisam saber onde estão os servidores de configuração.

1. Iniciar instâncias mongos: Forneça a opção --configdb, listando os membros do conjunto de réplicas de configuração.

   ```bash

   Roteador Mongos 1

   mongos --configdb cfgReplSet/localhost:27019,localhost:27020,localhost:27021 --port 27017 --bind_ip localhost --logpath /data/log/mongos/mongos01.log --fork
   ```

   Nota: Você pode iniciar múltiplas instâncias mongos para balanceamento de carga e alta disponibilidade. Todas elas se conectam aos mesmos servidores de configuração.

Passo 4: Conectar-se ao mongos e Adicionar Shards

Agora, conecte-se a uma instância mongos e adicione os conjuntos de réplicas de shard ao cluster.

1. Conectar-se ao mongos: Use a porta padrão do MongoDB 27017 ou a porta personalizada que você especificou para o mongos.

   bash mongo --port 27017

2. Adicionar Shards: Use o comando sh.addShard(), especificando o nome do conjunto de réplicas e um de seus membros.

   javascript sh.addShard("shard01/localhost:27030"); sh.addShard("shard02/localhost:27040");

Passo 5: Habilitar Fragmentação para um Banco de Dados e Coleção

Depois que os shards são adicionados, você precisa habilitar a fragmentação para bancos de dados específicos e, em seguida, para coleções específicas dentro desses bancos de dados. Isso requer a escolha de uma chave de shard (shard key).

1. Habilitar Fragmentação para um Banco de Dados: Mude para o banco de dados que deseja fragmentar e execute sh.enableSharding().

   javascript use mydatabase; sh.enableSharding("mydatabase");

2. Fragmentar uma Coleção: Escolha uma chave de shard e use sh.shardCollection().

   Aviso: Escolher uma chave de shard eficaz é crucial para o desempenho e distribuição uniforme. Uma chave de shard ruim pode levar a pontos de acesso (hot spots) ou consultas ineficientes. Estratégias comuns incluem chaves com hash, chaves baseadas em intervalo ou chaves compostas.

   Para este exemplo, vamos supor uma coleção mycollection com um campo _id.

   ```javascript
   sh.shardCollection("mydatabase.mycollection"