🚀 A CloudSEK se torna a primeira empresa de segurança cibernĂ©tica de origem indiana a receber investimentos da Estado dos EUA fundo
🚀 CloudSEK se torna a primeira empresa indiana de segurança cibernĂ©tica a fazer parceria com o The Private Office
🚀 O CloudSEK aumentou Rodada da SĂ©rie B1 de $19 milhĂ”es — Potencializando o futuro da cibersegurança preditiva
Voltar
Engineering

MongoDB Sharding 101: Criando um cluster fragmentado

MongoDB Sharding 101: Criando um cluster fragmentado
November 6, 2020
min
Tabela de conteĂșdo
Exemplo H2
Exemplo H2

O que é fragmentação?

A fragmentação é um processo no MongoDB, que divide grandes conjuntos de dados em volumes menores de dados e os distribui em vårias instùncias do MongoDB. Quando os dados no MongoDB são enormes, as consultas executadas em conjuntos de dados tão grandes podem levar ao alto uso da CPU. O MongoDB usa o recurso de fragmentação para resolver isso. Durante esse processo, o grande banco de dados é dividido em fragmentos (subconjuntos de dados) que funcionam logicamente como uma coleção. Os fragmentos são implementados por meio de clusters que consistem em:

  1. Fragmentos: sĂŁo instĂąncias do MongoDB que hospedam subconjuntos de dados. Na produção, todos os fragmentos precisam fazer parte de conjuntos de rĂ©plicas que mantĂȘm os mesmos conjuntos de dados. Os conjuntos de rĂ©plicas oferecem redundĂąncia, alta disponibilidade e sĂŁo a base para todas as implantaçÔes de produção.Sharding - Shards in parts
  2. Servidor de configuração: é uma instùncia mongod que contém metadados sobre vårias instùncias do MongoDB. Um servidor de configuração executa pequenos processos mongod. Em um ambiente de produção, geralmente, existem 3 servidores de configuração, em que cada servidor consiste em uma cópia dos metadados, que são mantidos em sincronia. E enquanto um servidor de configuração estiver ativo, o cluster permanecerå ativo.
  3. Roteador de consulta: Essa Ă© uma instĂąncia do MongoDB responsĂĄvel por redirecionar os comandos do cliente para determinados servidores. NĂŁo tem um estado persistente. Ele atua como uma interface entre o aplicativo cliente e o fragmento relevante. O roteador de consulta reĂșne as informaçÔes necessĂĄrias para responder a uma consulta, reduz os falsos positivos e falsos negativos nos dados e encaminha a consulta para as fontes de informaçÔes mais precisas.

MongoDB Sharding explained

Em uma série de duas partes sobre fragmentação no MongoDB, explicamos:

  • Como criar um cluster fragmentado
  • Como selecionar uma chave fragmentada

Na primeira parte, fornecemos um tutorial sobre como criar um cluster fragmentado, explicando todas as noçÔes båsicas sobre fragmentação.

Tutorial de cluster compartilhado

Para criar um cluster, precisamos esclarecer:

  1. O nĂșmero de fragmentos necessĂĄrios inicialmente
  2. Fator de replicação e outros parùmetros para o conjunto de réplicas

mondeus e mongos são dois processos diferentes no MongoDB. Embora o mongod seja o principal daemon que lida com solicitaçÔes de dados, acesse dados e execute operaçÔes de gerenciamento em segundo plano, o mongos é um utilitårio de fragmentação que processa e encaminha as consultas dos usuårios e determina a localização dos dados no cluster fragmentado. Os fragmentos e servidores de configuração executam o processo mongod, enquanto o servidor do roteador de consulta executa o processo mongos.

Para nossa ilustração, vamos pegar 4 fragmentos (a saber, a, b, c e d) e um fator de replicação de 3. Portanto, no total, haverå 12 servidores fragmentados (processos mongod). Também executaremos 4 roteadores de consulta (processos mongos) e 3 servidores de configuração (pequenos processos mongod) como se faria em um ambiente de produção; executando tudo isso em um servidor simulando um cluster.

Na verdade, esses fragmentos, juntamente com seus conjuntos de rĂ©plicas, sĂŁo executados em 12 mĂĄquinas diferentes. No entanto, os servidores de configuração sĂŁo processos leves e com apenas 4 fragmentos. Portanto, a carga serĂĄ consideravelmente baixa. Isso significa que vocĂȘ pode executar servidores de configuração em qualquer um dos servidores fragmentados. Os processos mongos podem ser executados em um servidor fragmentado ou diretamente em uma mĂĄquina de aplicativos cliente.

A vantagem de executar o mongos em uma mĂĄquina de aplicativo cliente Ă© que ele Ă© executado em uma interface local sem precisar sair da rede. No entanto, vocĂȘ deve se lembrar de ativar as opçÔes de segurança corretas. Por outro lado, se vocĂȘ executĂĄ-lo no servidor fragmentado ou em qualquer outro servidor, o cliente nĂŁo precisarĂĄ passar pelo processo de configuração do cluster.

 

  • DiretĂłrios de dados

A primeira etapa do processo é criar diretórios de dados para nossos servidores fragmentados, servidores de configuração e registros.

Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/a0 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/a1 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/a2 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/b0 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/b1 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/b2 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/c0 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/c1 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/c2 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/d0 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/d1 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p dados/d2 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p config/cfg0 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p config/cfg1 Ter, 27 de outubro piyushgoyal tutorial mongo $ mkdir -p config/cfg2 Ter, 27 de outubro piyushgoyal tutorial mongo $ registros do mkdir

 

  • Servidor de configuração e servidor Shard

Use o comando mongod, conforme mostrado abaixo, para iniciar o servidor de configuração. Portanto, passamos o parùmetro configsvr que declara o servidor de configuração desse cluster.

Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --configsvr --replSet cfg --dbpath config/cfg0 --port 26050 --fork --logpath logs/log.cfg0 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --configsvr --replSet cfg --dbpath config/cfg1 --port 26051 --fork --logpath logs/log.cfg1 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --configsvr --replSet cfg --dbpath config/cfg2 --port 26052 --fork --logpath logs/log.cfg2 --logappend

Agora vamos continuar com nossos servidores fragmentados. Aqui, executamos o comando mongod para passar o parùmetro shardsvr que, por sua vez, declara que faz parte de um cluster fragmentado. Em seguida, renomeamos o conjunto de réplicas com o nome do fragmento.

 

Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replDefine um --dbpath data/a0 --port 27000 --fork --logpath logs/log.a0 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replDefine um --dbpath data/a1 --port 27001 --fork --logpath logs/log.a1 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replDefine um --dbpath data/a2 --port 27002 --fork --logpath logs/log.a2 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet b --dbpath data/b0 --port 27100 --fork --logpath logs/log.b0 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet b --dbpath data/b1 --port 27101 --fork --logpath logs/log.b1 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet b --dbpath data/b2 --port 27102 --fork --logpath logs/log.b2 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet c --dbpath data/c0 --port 27200 --fork --logpath logs/log.b0 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet c --dbpath data/c1 --port 27201 --fork --logpath logs/log.b1 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet c --dbpath data/c2 --port 27202 --fork --logpath logs/log.b2 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet d --dbpath data/d0 --port 27300 --fork --logpath logs/log.c0 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet d --dbpath data/d1 --port 27301 --fork --logpath logs/log.c1 --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongod --shardsvr --replSet d --dbpath data/d2 --port 27302 --fork --logpath logs/log.c2 --logappend

 

  • Servidor Mongos

Na prĂłxima etapa, executamos o comando mongos para iniciar os processos do mongos. Para saber onde estĂŁo os servidores de configuração, passamos IP dos servidores de configuração usando o parĂąmetro —configdb. Executaremos um Ășnico processo mongos em uma porta TCP mongo padrĂŁo para aderir Ă s melhores prĂĄticas.

Ter, 27 de outubro piyushgoyal tutorial mongo $ mongos --configdb cfg/127.0.0. 1:26050.127.0.0. 1:26051.127 .0.0. 1:26052 --logpath logs/log.mongos0 --port 27017 --bind_ip 0.0.0.0 --fork --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongos --configdb cfg/127.0.0. 1:26050.127.0.0. 1:26051.127 .0.0. 1:26052 --logpath logs/log.mongos1 --port 26061 --bind_ip 0.0.0.0 --fork --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongos --configdb cfg/127.0.0. 1:26050.127.0.0. 1:26051.127 .0.0. 1:26052 --logpath logs/log.mongos2 --port 26062 --bind_ip 0.0.0.0 --fork --logappend Ter, 27 de outubro piyushgoyal tutorial mongo $ mongos --configdb cfg/127.0.0. 1:26050.127.0.0. 1:26051.127 .0.0. 1:26052 --logpath logs/log.mongos3 --port 26063 --bind_ip 0.0.0.0 --fork --logappend

 

Observe que nunca executamos o servidor de configuração e o servidor fragmentado na mesma porta TCP padrão.

Agora, verifique se todos os processos estĂŁo funcionando sem problemas.

Ter, 27 de outubro piyushgoyal tutorial mongo $ ps -A | grep mongo 26745?? 0:00.95 mongod --configsvr --replSet cfg --dbpath config/cfg0 --port 26050 --fork --logpath logs/log.cfg0 --logappend 26748?? 0:00.90 mongod --configsvr --replSet cfg --dbpath config/cfg1 --port 26051 --fork --logpath logs/log.cfg1 --logappend 26754?? 0:00.90 mongod --configsvr --replSet cfg --dbpath config/cfg2 --port 26052 --fork --logpath logs/log.cfg2 --logappend 26757?? 0:00.77 mongod --shardsvr --replDefina um --dbpath data/a0 --port 27000 --fork --logpath logs/log.a0 --logappend 26760? 0:00.77 mongod --shardsvr --replDefina um --dbpath data/a1 --port 27001 --fork --logpath logs/log.a1 --logappend 26763?? 0:00.76 mongod --shardsvr --replDefina um --dbpath data/a2 --port 27002 --fork --logpath logs/log.a2 --logappend 26766?? 0:00.76 mongod --shardsvr --replSet b --dbpath data/b0 --port 27100 --fork --logpath logs/log.b0 --logappend 26769?? 0:00.77 mongod --shardsvr --replSet b --dbpath data/b1 --port 27101 --fork --logpath logs/log.b1 --logappend 26772?? 0:00.75 mongod --shardsvr --replSet b --dbpath data/b2 --port 27102 --fork --logpath logs/log.b2 --logappend 2675?? 0:00.73 mongod --shardsvr --replSet c --dbpath data/c0 --port 27200 --fork --logpath logs/log.b0 --logappend 26784?? 0:00.75 mongod --shardsvr --replSet c --dbpath data/c1 --port 27201 --fork --logpath logs/log.b1 --logappend 26791?? 0:00.74 mongod --shardsvr --replSet c --dbpath data/c2 --port 27202 --fork --logpath logs/log.b2 --logappend 26794?? 0:00.77 mongod --shardsvr --replSet d --dbpath data/d0 --port 27300 --fork --logpath logs/log.c0 --logappend 26797?? 0:00.75 mongod --shardsvr --replSet d --dbpath data/d1 --port 27301 --fork --logpath logs/log.c1 --logappend 26800?? 0:00.71 mongod --shardsvr --replSet d --dbpath data/d2 --port 27302 --fork --logpath logs/log.c2 --logappend 26803?? 0:00.00 mongos --configdb cfg/127.0.0. 1:26050.127 .0.0. 1:26051.127.0.0. 1:26052 --logpath logs/log.mongos0 --port 27017 --bind_ip 0.0.0.0 --fork --logappend 26804?? 0:00.24 mongos --configdb cfg/127.0.0. 1:26050.127 .0.0. 1:26051.127.0.0. 1:26052 --logpath logs/log.mongos0 --port 27017 --bind_ip 0.0.0.0 --fork --logappend 76826?? 8:58,30 /usr/local/opt/mongodb-community/bin/mongod --config /usr/local/etc/mongod.conf 26817 ttys009 0:00.00 grep mongo 26801 ttys016 0:00.01 mongos --configdb cfg/127.0.0. 1:26050,127 .0.0. 1:26051,127.0.0. 1:26052 --logpath logs/log.mongos0 --port 27017 --bind_ip 0.0.0.0 --fork --logappend

 

  • Status e inĂ­cio dos conjuntos de rĂ©plicas

Conecte-se a um dos servidores fragmentados. Por exemplo, vamos nos conectar a 0 fragmento

Ter, 27 de outubro piyushgoyal tutorial mongo $ mongo --porta 27000

 

Execute o comando a seguir para verificar o status do conjunto de réplicas

> rs.status () { “OperationTime”: Timestamp (0, 0), “ok”: 0, “errmsg”: “nenhuma configuração de replset foi recebida”, “código”: 94, “codeName”: “Ainda não inicializado”, “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (0, 0), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } }

 

O que se segue Ă© uma caixa de diĂĄlogo que diz “run rs.initiate () ainda nĂŁo estĂĄ pronto para o conjunto”. Para iniciar o conjunto de rĂ©plicas, execute o seguinte comando:

> rs.initiate () { “info2": “nenhuma configuração especificada. Usando uma configuração padrão para o conjunto”, “eu”: “localhost: 27000", “ok”: 1, “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604637446, 1), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } }, “Tempo de operação”: Timestamp (1604637446, 1) }

 

Se vocĂȘ correr rs.status () mas uma vez, vocĂȘ verĂĄ que um Ășnico membro foi adicionado. Agora, vamos adicionar outros tambĂ©m a esse conjunto de rĂ©plicas.

R: Primário > rs.add (“127.0.0. 1:27001 “) { “ok”: 1, “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604637486, 1), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } }, “Tempo de operação”: Timestamp (1604637486, 1) } R: Primário > rs.add (“127.0.0. 1:27002 “) { “ok”: 1, “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604637491, 1), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } }, “Tempo de operação”: Timestamp (1604637491, 1) }

 

Execute rs.status () para verificar o status da inicialização. Depois de iniciado, repita o mesmo processo para outros fragmentos e para o servidor de configuração.

 

  • Adicionar fragmentos

Conecte-se ao processo mongos para adicionar fragmentos ao cluster.

Ter, 27 de outubro piyushgoyal tutorial mongo $ mongo --porta 27017

 

Execute o comando abaixo para adicionar fragmentos:

mongos> sh.addShard (“a/127.0.0. 1:27.000 “) { “ShardAdded”: “a”, “ok”: 1, “Tempo de operação”: Timestamp (1604637907, 8), “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604637907, 8), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } } mongos> sh.addShard (“b/127.0.0. 1:27100 “) { “ShardAdded”: “b”, “ok”: 1, “Tempo de operação”: Timestamp (1604638045, 6), “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604638045, 6), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } } mongos> sh.addShard (“c/127.0.0. 1:27200 “) { “ShardAdded”: “c”, “ok”: 1, “Tempo de operação”: Timestamp (1604638065, 4), “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604638065, 4), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } } mongos> sh.addShard (“d/127.0.0. 1:27300 “) { “ShardAdded”: “d”, “ok”: 1, “Tempo de operação”: Timestamp (1604638086, 6), “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604638086, 6), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } }

Nota: Quando vocĂȘ corre sh.addShard ('a/127.0.0. 1:27000'), se vocĂȘ obtiver uma saĂ­da conforme mostrado abaixo, tente correr sh.addShard ('a/127.0.0. 1:27001 ') ou sh.addShard ('a/127.0.0. 1:27002').

{ “EstĂĄ bem” : 0, “errmsg” : “na lista de sementes a/127.0.0. 1:27000, host 127.0.0. 1:27000 nĂŁo pertence ao conjunto de rĂ©plicas a; found {hosts: [\” localhost:27000\”,\ “127.0.0. 1:27001\”,\ “127.0.0. 1:27002\”], setName:\ “a\”, setVersion: 3, ismaster: true, secondary: false, primary:\ “localhost:27000\”, me:\ “localhost:27000\”, electionId: objectId ('7fffffff0000000000000001'), lastWrite: {opTime: {ts: Timestamp (1604637886, 1), t: 1}, lastWriteDate: nova data (1604637886, 1), t: 1}, lastWriteDate: nova data (1604637886, 1) 6000), majorityOpTime: {ts: Timestamp (1604637886, 1), t: 1}, majorityWriteDate: nova data (1604637886000)}, MaxBSONObjectSize: 16777216, MaxMessageSizeBytes: 48000000, MaxWriteBatchSize: 100000, LocalTime: nova data (1604637894239), LogicalSessionTimeoutMinutes: 30, ConnectionID: 21, MinWireVersion: 0, MaxWireVersion: 8, ReadOnly: false, compressĂŁo: [\ “snappy\”,\ “zstd\”,\ “zstd\”,\ “zstd\”,\ “zstd\”,\ “zstd\”,\ “zstd lib\”], ok: 1.0, $clusterTime: {clusterTime: Timestamp (1604637886, 1), assinatura: {hash: binData (0, 0000000000000000000000000000000000) 000000000000), ID da chave: 0}}, Hora da operação: Timestamp (1604637886, 1)}”, “cĂłdigo” : 96, “Nome do cĂłdigo” : “Falha na operação”, “Tempo de operação” : Carimbo de data/hora (1604637888, 1), “$ ClusterTime” : { “Hora do cluster” : Carimbo de data/hora (1604637888, 1), “assinatura” : { “haxixe” : Dados binĂĄrios (0,“AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave” : NĂșmero longo (0) } } }

 

Fragmentando uma coleção
Corra sh.status () para verificar se os fragmentos foram adicionados.
Agora que configuramos o cluster, vamos testĂĄ-lo.

Ao fragmentar uma coleção, vocĂȘ deve escolher uma especĂ­fica chave fragmentada. Sem o qual a fragmentação Ă© impossĂ­vel. Isso ajuda a distribuir documentos entre os membros do cluster.
Os dados armazenados pela chave são chamados de pedaço. O tamanho do bloco só pode estar entre 1 e 1024 megabytes.
Por exemplo, vamos apoiar uma coleção dos seguintes documentos:

{ “_ID”: ID do objeto (“5f97d97eb7a0a940f157ebc8"), “x”: 1 }

 

E usamos a tecla x para fragmentar a coleção. Os dados são distribuídos conforme mostrado abaixo:

fragmento x_low x_high 0 1000 S2 ----> pedaço 1000 2000 S0 ----> pedaço 2000 3000 S1 ----> pedaço

 

Os documentos da coleção são distribuídos com base na chave de fragmento atribuída. Os documentos de uma chave de fragmento específica pertencem ao mesmo fragmento.

O processo de fragmentação pode ser dividido em dois:

  1. Fragmentação baseada em intervalos
  2. Fragmentação com hash

Para manter este tutorial simples, preferimos a fragmentação baseada em intervalos. A fragmentação baseada em intervalo Ă© Ăștil para consultas que envolve um intervalo. No contexto desses processos, o sistema tambĂ©m realiza essas duas operaçÔes principais:

  • Dividir
  • Migração (Ă© gerenciada pelo cluster) balanceador)

Por exemplo, se o tamanho de um bloco exceder o tamanho prescrito, o sistema, sozinho, tentarĂĄ descobrir a chave mediana apropriada para dividir o bloco em 2 ou mais partes. Isso Ă© conhecido como divisĂŁo, que Ă© uma alteração barata de metadados. No entanto, a migração Ă© responsĂĄvel por manter o equilĂ­brio, por exemplo, mover um pedaço de um fragmento para outro. Essa Ă© uma operação cara que geralmente envolve a transferĂȘncia de dados no valor de ~ 1024 MB.
VocĂȘ ainda pode ler e gravar no banco de dados enquanto a migração estiver em andamento. HĂĄ uma propriedade de vivacidade nessas migraçÔes que mantĂ©m o banco de dados ativo para operaçÔes, portanto, um grande bloqueio nĂŁo ocorre.
Para nosso exemplo, estamos criando um banco de dados chamado tutorial com coleção foo e vão inserir alguns documentos.

Ter, 27 de outubro piyushgoyal tutorial mongo $ mongo --porta 27017 mongos> tutorial de uso mongos> para (var i=0; i<999999; i++) {db.foo.insert ({x:i})}

 

Para permitir a fragmentação do banco de dados, precisamos habilitá-lo manualmente. Conecte-se à instñncia mongo e execute <dbname>sh. habilitar fragmentação (“”).

mongos > sh.enableSharding (“tutorial”) { “ok”: 1, “Tempo de operação”: Timestamp (1604638168, 21), “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604638168, 21), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: numberLong (0) } } }

 

Se vocĂȘ executar sh.status () no banco de dados, ele retornarĂĄ “partitioned = True” no banco de dados do tutorial.

Agora, compartilhamos nossa coleção usando tecla x. Para fragmentar uma coleção, precisamos primeiro criar um índice na chave e depois executar <db_name>Coleção Sh.Shard (”. <collection_name>”,<key>).

mongos> db.foo.ensureIndex ({x: 1}) { “cru”: { “b/127.0.0. 1:27101,127.0.0. 1:27102, localhost:27100": { “Coleção criada automaticamente”: falso, “numIndexesBefore”: 1, “numIndexesAfter”: 2, “ok”: 1 } }, “ok”: 1, “Tempo de operação”: Timestamp (1604638185, 9), “$ clusterTime”: { “ClusterTime”: Timestamp (1604638185, 9), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } } mongos> Coleção Sh.Shard (“tutorial.foo”, {x: 1}) { “collectionsharded”: “tutorial.foo”, “UUID de coleção”: UUID (“b6506a90-dc0f-48d2-ba22-c15bbc94c0d6"), “ok”: 1, “Tempo de operação”: Timestamp (1604638203, 39), “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604638203, 39), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } }

 

A coleção agora estĂĄ fragmentada. Para verificar a distribuição do fragmento, o nĂșmero de blocos (nchunks), execute o seguinte comando:

Mongos > tutorial de uso mongĂłlia > db.foo.stats ()

 

Para saber a distribuição dos blocos em todos os bancos de dados, execute o comando abaixo:

mongos> sh.status ()

 

Vamos fazer algumas consultas.

Mongos > tutorial de uso mongos> db.foo.find ({x: 55})

Para visualizar o plano de consulta ou entender como o cluster consulta diferentes servidores para obter o documento, acrescente .explain () ao final da consulta.

mongos> db.foo.find ({x: 55}) .explain () { “Planejador de consultas”: { “VersĂŁo do Mongos Planner”: 1, “Plano vencedor”: { “estĂĄgio”: “SINGLE_SHARD”, “fragmentos”: [ { “ShardName”: “b”, “ConnectionString”: “b/127.0.0. 1:27101.127.0.0. 1:27102, localhost: 27100", “InformaçÔes do servidor”: { “host”: “Piyushs-macbook-pro.local”, “porta”: 27100, “versĂŁo”: “4.2.8", “VersĂŁo Git”: “43d25964249164d76d5e04dd6cf38f6111e21f5f” }, “PlannerVersion”: 1, “namespace”: “tutorial.foo”, “IndexFilterSet”: falso, “Consulta analisada”: { “x”: { “$ eq”: 55 } }, “queryHash”: “716F281A”, “PlanCacheKey”: “0FA0E5FD”, “Plano vencedor”: { “estĂĄgio”: “PESQUISAR”, “InputStage”: { “estĂĄgio”: “FILTRO DE COMPARTILHAMENTO”, “InputStage”: { “estĂĄgio”: “IXSCAN”, “Chave padrĂŁo”: { “x”: 1 }, “Nome do Ă­ndice”: “x_1", “isMultiKey”: falso, “Caminhos de vĂĄrias chaves”: { “x”: [] }, “isUnique”: falso, “isSparse”: falso, “isPartial”: falso, “VersĂŁo do Ă­ndice”: 2, “direção”: “para frente”, “IndexBounds”: { “x”: [ “[55,0, 55,0]” ] } } } }, “Planos rejeitados”: [] } ] } }, “InformaçÔes do servidor”: { “host”: “Piyushs-macbook-pro.local”, “porta”: 27017, “versĂŁo”: “4.2.8", “VersĂŁo Git”: “43d25964249164d76d5e04dd6cf38f6111e21f5f” }, “ok”: 1, “Tempo de operação”: Timestamp (1604638250, 30), “$ clusterTime”: { “ClusterTime”: Carregamento de dados/hora (1604638255, 27), “assinatura”: { “hash”: binData (0, “AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=”), “ID da chave”: NumberLong (0) } } }

 

Na segunda parte desta série de duas partes, exploraremos vårios métodos pelos quais podemos selecionar uma chave fragmentada.

Nenhum item encontrado.

Blogs relacionados

Este Ă© um texto dentro de um bloco div.
Engineering
March 12, 2021
min
Helm: Abrindo o caminho para implantaçÔes sensíveis ao meio ambiente
Leia mais
Este Ă© um texto dentro de um bloco div.
Engineering
October 6, 2020
min
Como o xVigil do CloudSEK detecta aplicativos falsos e desonestos
Leia mais
Este Ă© um texto dentro de um bloco div.
Engineering
June 24, 2020
min
Uma olhada na caixa preta: depurando redes neurais profundas para melhores previsÔes
Leia mais