Depois de tentar com diferentes drivers e clientes, sofremos com o tempo limite do mongodb na consulta de localização.

Mesmo o Profiling registra bem as configurações e os problemas.

       2014-08-13T23:46:43.218+0200 [conn80] query mdb.fcol query: { $query: { 
       unid: "39068119d2924babffedde92ef937bd0" }, $maxTimeMS: 100 } planSummary: 
       IXSCAN { unid: 1 } ntoskip:0 nscanned:1 nscannedObjects:1 keyUpdates:0 
       numYields:1 locks(micros) r:334 nreturned:1 reslen:341 2181ms

Embora $maxTimeMS: 100, a consulta leve 2181ms.

Como forçar o mongodb a respeitar o tempo limite e interromper o processamento se o tempo for excedido?

MongoDB v2.6.4, 64 bits

Em um sistema operacional Debian 6 de 64 bits com 4 núcleos de CPU e 8 GB de RAM, posso reproduzir um problema com mongostat.

Sempre que eu crio um índice, reIndex ou mesmo um índice em segundo plano, de acordo com top, a carga da CPU é de 40-60% e a RAM está preenchendo até 90%. Enquanto a tarefa de índice está em execução, tento mongostatobservar a carga da CPU. Imediatamente, a carga da CPU é quase 100% e bloqueia.

mongostat

conectado a: 127.0.0.1

Nada depois disso, apenas carga da CPU no limite até Ctrl + C para parar o mongostat. Poucos segundos depois, a carga da CPU cai para ~ 50% e tudo está bem novamente.

Tentando mongostatnovamente com o mesmo comportamento...

O mongodb está esperando mais CPUs ou o que há de errado?

Como corro regularmente contra o limite de tamanho de documento do mongodb e também as limitações de grupo da estrutura de agregação > 16M, dependendo da quantidade de dados que preciso processar, procuro uma solução alternativa simples.

A solução também deve ser adequada para nós únicos (e não deve exigir vários mongos).

Dito em poucas palavras, é uma agregação para encontrar

(a) o número (contagem) de únicos em um campo e agrupar o número por outro campo

(b) a frequência ou contagem de quantas vezes um id único apareceu.

Um exemplo pode facilitar o entendimento da tarefa: Digamos que haja uma coleção com 2 campos, o último e o sobrenome.

(ex a) Quantos sobrenomes diferentes existem para cada sobrenome? O resultado pode ser: Existem 1000 sobrenomes únicos (distintos) para o sobrenome "smith", 500 sobrenomes diferentes para pessoas com sobrenome "schulz" etc.

=> isso também pode ser resolvido com contagem distinta e/ou mapreduce etc. nenhuma limitação é excedida. de qualquer forma, parece ser uma varredura de tabela lenta e a estrutura de agregação faz a tarefa muito mais rapidamente.

(ex b) Quão populares são os sobrenomes para cada sobrenome? Resultado: Com o sobrenome "smith" existem 500 sobrenomes diferentes que aparecem apenas uma vez, 200 sobrenomes que aparecem 2 vezes, 45 são listados 3 vezes nossos dados, ...

=> aqui é muito confortável trabalhar com a estrutura de agregação do mongodb, que lida com essa tarefa de forma rápida e adequada. No entanto, ao tentar a tarefa com muitos únicos em uma coleção de 15 GB, ele se preocupa com a limitação de 16 milhões.

A primeira solução alternativa foi bem-sucedida, mas é apenas um truque não escalável rápido e sujo: em vez de processar todos os dados e $grupo posteriormente, eu filtro ($correspondência) para cada $grupo-item. Com o exemplo acima, procuro todos os sobrenomes distintos, executo uma agregação por sobrenome e reduzo os dados do pipeline antes do início da agregação.

Isso evita o problema de limite de 16 milhões se a quantidade de dados para um único item de grupo $ (sobrenome) não for muito. => apenas solução alternativa rápida e suja.

Outra ideia é uma coleção de ajuda para os COUNTs.

Eu poderia iterar cada documento de entrada e escrever em outra coleção os sobrenomes e um campo por sobrenome com o contador.

Por exemplo, sobrenome=John count_with_Lastname.smith=10, count_with_Lastname.brown=2, ...

Construir esta coleção auxiliar é muito lento, não é? Ao incrementar +1, que é 1 atualização/gravação por documento de entrada, temo que isso possa levar uma eternidade :-(

Existe uma prática recomendada ou dicas para resolver esta tarefa (sem vários nós e sem Hadoop ou alternativas)?

Por favor deixe-me saber

Executando um conjunto de réplicas com 1 primário e 2 secundários, me pergunto por que os READs também são feitos no primário. O primário não deveria fazer principalmente os WRITEs e o secundário pode compartilhar o READ-load?!

Estou usando o driver PHP para o mongodb e enviando os detalhes para o conjunto de réplicas. O PHP está rodando dos secundários e no script a conexão inicial vai para o próprio secundário que é localhost lá.

A documentação do php diz que o driver encontrará o primário e os secundários por conta própria assim que se conectar a qualquer membro do conjunto de réplicas, não importa se primário ou secundário.

Depois de verificar a carga e os logs, descobri que atualmente meu pobre primário tem que lidar com todos os READs e os escravos estão entediados.

Existe uma opção para balanceamento de carga com conjuntos de réplicas mongodb? Não estou pedindo um HAProxy ou similar, mas um recurso integrado do mongodb. Não foi possível encontrar dicas para isso nos documentos.

Pensamos em passar de mestre-escravos para MongoDBcom replica-set. Agora eu me pergunto se MongoDBas réplicas também são configuradas como read-only slavesou se cada uma mongosé capaz de escrever e sincronizar as outras como um farm mestre-mestre?

Isso pode reduzir a fonte única de erro ( master down) e também equilibrar o write-loadescalonamento com melhor desempenho (não apenas para leitura, mas também gravação...).

É suficiente ter todo o índice na memória/ram ou o mongodb tenta alocar o máximo de RAM possível para armazenar até os dados para leituras rápidas?

Eu gostaria de executar o mongodb + outros aplicativos e parece que o mongodb é o único que não me permite definir um intervalo de RAM, digamos "max_memory_allocated_or_reserved=8GB".

Se não houver como fazer isso, devo explicar ao oom-killer que mongod é o processo "ruim" que não é a melhor prática na minha opinião ...

Em um mongoDB grande, tenho 2 casos de uso diferentes para leitura e 2 tipos diferentes para gravação/atualização.

• leia 1: encontre por índice -> nenhuma pergunta sobre isso. isso funciona como um encanto - desde que o índice caiba na memória/ram.
• leitura 2: lê linha por linha, como um script em lote que está lendo um arquivo de log um por um.
• write 1: insert - anexa um novo conjunto de dados ou documento.
• gravação 2: dados de atualização, endereços diretamente ou encontrados por índice.

Agora eu me pergunto se o mongoDB é capaz de "priorizar" diferentes tarefas de gravação. Eu tenho uma coleção que não exige que os dados sejam gravados e disponibilizados instantaneamente em "tempo real". Basta usar um queque lento e processar essas tarefas de escrita sem pressa. No entanto, também existem instruções de gravação que devem ser processadas o mais rápido possível e estar disponíveis com um atraso mínimo (se houver).

O mongoDB permite que eu diferencie entre gravação/atualização de alto (asap) e baixo prio (queque)?