Guia Passo a Passo: Implantando um Cluster Sharded Básico do MongoDB

O MongoDB, um popular banco de dados de documentos NoSQL, se destaca no manuseio de grandes volumes de dados com alta performance 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 sharding entra em jogo, permitindo escalabilidade horizontal ao distribuir dados por vários servidores, ou shards.

Este guia orienta você na criação de um cluster sharded básico do MongoDB no localhost para aprendizado. Você configurará servidores de configuração, conjuntos de réplicas de shard e um roteador mongos, e então habilitará o sharding para uma coleção.

Entendendo Clusters Sharded do MongoDB

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

• Conjuntos de Réplicas de Shard: Estes são os nós reais que armazenam dados. 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): Eles armazenam os metadados do cluster, incluindo o mapeamento de chunks 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: Eles atuam como roteadores de consulta, fornecendo uma interface para 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, não diretamente aos shards.

Diagrama conceitual de um cluster sharded do MongoDB (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 sharded 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 de 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: Instale uma versão suportada do MongoDB Server em cada máquina que hospedará mongod ou mongos. Use mongosh para comandos de shell.
3. Rede: Certifique-se de que todas as máquinas possam se comunicar entre si 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

Etapas de Implantação

Etapa 1: Configurar Servidores de Configuração (Conjunto de Réplicas de Config)

Os servidores de configuração armazenam metadados para o cluster sharded. 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.

   # 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 Config: Conecte-se a uma das instâncias do servidor de configuração e inicialize o conjunto de réplicas.

   mongosh --port 27019
   

   Dentro do shell mongo:

   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:

   rs.status();
   

Etapa 2: Configurar Conjuntos de Réplicas de Shard

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

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

   # Membro 1 do Shard 1
   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs01 --port 27030 --bind_ip localhost --logpath /data/log/shard01/shard01-rs01.log --fork
   
   # Membro 2 do Shard 1
   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs02 --port 27031 --bind_ip localhost --logpath /data/log/shard01/shard01-rs02.log --fork
   
   # Membro 3 do Shard 1
   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.

   mongosh --port 27030
   

   Dentro do shell mongo:

   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 membros do Shard 2 (repita para shards adicionais):

   # Membro 1 do Shard 2
   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs01 --port 27040 --bind_ip localhost --logpath /data/log/shard02/shard02-rs01.log --fork
   
   # Membro 2 do Shard 2
   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs02 --port 27041 --bind_ip localhost --logpath /data/log/shard02/shard02-rs02.log --fork
   
   # Membro 3 do Shard 2
   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.

   mongosh --port 27040
   

   Dentro do shell mongo:

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

Etapa 3: Configurar Roteadores mongos

As instâncias mongos são os pontos de entrada para 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.

   # 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 várias instâncias mongos para balanceamento de carga e alta disponibilidade. Todas se conectam aos mesmos servidores de configuração.

Etapa 4: Conectar 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 ao mongos: Use a porta padrão do MongoDB 27017 ou a porta personalizada que você especificou para mongos.

   mongosh --port 27017
   

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

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

Etapa 5: Habilitar Sharding para um Banco de Dados e Coleção

Depois que os shards são adicionados, você precisa habilitar o sharding 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.

1. Habilitar Sharding para um Banco de Dados: Mude para o banco de dados que você deseja shardear e execute sh.enableSharding().

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

2. Shardear 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 ou consultas ineficientes. Estratégias comuns incluem chaves hash, chaves por intervalo ou chaves compostas.

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

   sh.shardCollection("mydatabase.mycollection", { _id: "hashed" });
   

   Uma chave de shard hash _id é simples para um tutorial porque distribui inserções entre shards melhor do que uma chave _id por intervalo monotonicamente crescente. Para uma aplicação real, escolha a chave de shard com base em seus padrões de consulta e distribuição de escrita, não apenas por conveniência.

Etapa 6: Verificar o Cluster

Execute estes comandos a partir do mongosh conectado ao mongos:

sh.status();
db.adminCommand({ listShards: 1 });

Em seguida, insira documentos de amostra e verifique se a coleção shardeada existe:

use mydatabase;
db.mycollection.insertMany([
  { _id: 1, name: "alpha" },
  { _id: 2, name: "beta" },
  { _id: 3, name: "gamma" }
]);

db.mycollection.getShardDistribution();

Conjuntos de dados de teste pequenos podem não ser divididos imediatamente, portanto, não espere uma distribuição perfeita após apenas alguns documentos. A primeira verificação importante é que sh.status() liste ambos os shards e mostre mydatabase.mycollection como shardeado.

Notas de Produção

Esta configuração localhost é útil para aprender as partes móveis, mas a produção requer mais cuidado:

• Use nomes de host reais, não localhost, porque os nomes dos membros do conjunto de réplicas são armazenados nos metadados do cluster.
• Execute servidores de configuração como um conjunto de réplicas de três membros.
• Execute cada shard como um conjunto de réplicas com membros espalhados por domínios de falha.
• Habilite a autenticação e autenticação interna por keyfile ou x.509 antes de expor o cluster.
• Faça backup dos metadados do servidor de configuração e dos dados do shard como parte de um plano de backup ciente do cluster.
• Monitore a distribuição de chunks, atividade do balanceador, lag de replicação e crescimento do disco.

Conclusão Final

Um cluster sharded do MongoDB tem três funções: servidores de configuração rastreiam metadados, conjuntos de réplicas de shard armazenam dados e mongos roteia o tráfego do cliente. Faça esses papéis funcionarem primeiro, depois gaste a maior parte do seu tempo de design na chave de shard, porque essa escolha determina se seu cluster distribui a carga de forma limpa ou cria shards quentes.