Início / dba / Perguntas / 52416
Accepted
Adam C
Asked: 2013-10-30 06:27:57 +0800 CST

Como determinar a distribuição de blocos (dados e número de documentos) em um cluster MongoDB fragmentado?

  • 772

Depois de fazer todas as coisas certas - escolher uma chave de fragmento apropriada, dimensionar horizontalmente, distribuir meus dados em vários fragmentos, acho que agora não tenho uma maneira real de determinar o quão bem equilibrados estão os dados em termos de contagem de documentos e tamanho dos dados. O sh.status()comando me dirá como os pedaços são distribuídos em termos de contagem, mas não o que compõe esses pedaços.

Existem muitas maneiras de inferir essas coisas - mas todas elas têm um lado negativo. Os caprichos de como o tamanho do banco de dados é calculado significa que, se houver exclusões significativas em um banco de dados, as estatísticas podem não ser um reflexo preciso da distribuição de dados. Se eu observar o tráfego que atinge cada fragmento, isso pode me dar alguma pista, mas apenas se meu tráfego for bom e previsível.

Então, como determino a distribuição de documentos em cada bloco, os tamanhos relativos de cada bloco e (claro) onde esses blocos residem atualmente?

mongodb sharding

2 respostas

  1. Best Answer

    Atualmente, não há uma maneira integrada de fazer isso, portanto, uma pequena função é necessária. Para os fins desta resposta, criei um cluster de 2 estilhaços com aproximadamente 1 milhão de documentos de acordo com estas instruções . Em seguida, usei esta função para examinar esses documentos:

    AllChunkInfo = function(ns, est){
    var chunks = db.getSiblingDB("config").chunks.find({"ns" : ns}).sort({min:1}); //this will return all chunks for the ns ordered by min
    //some counters for overall stats at the end
    var totalChunks = 0;
    var totalSize = 0;
    var totalEmpty = 0;
    print("ChunkID,Shard,ChunkSize,ObjectsInChunk"); // header row
    // iterate over all the chunks, print out info for each 
    chunks.forEach( 
        function printChunkInfo(chunk) { 

        var db1 = db.getSiblingDB(chunk.ns.split(".")[0]); // get the database we will be running the command against later
        var key = db.getSiblingDB("config").collections.findOne({_id:chunk.ns}).key; // will need this for the dataSize call
        // dataSize returns the info we need on the data, but using the estimate option to use counts is less intensive
        var dataSizeResult = db1.runCommand({datasize:chunk.ns, keyPattern:key, min:chunk.min, max:chunk.max, estimate:est});
        // printjson(dataSizeResult); // uncomment to see how long it takes to run and status           
        print(chunk._id+","+chunk.shard+","+dataSizeResult.size+","+dataSizeResult.numObjects); 
        totalSize += dataSizeResult.size;
        totalChunks++;
        if (dataSizeResult.size == 0) { totalEmpty++ }; //count empty chunks for summary
        }
    )
    print("***********Summary Chunk Information***********");
    print("Total Chunks: "+totalChunks);
    print("Average Chunk Size (bytes): "+(totalSize/totalChunks));
    print("Empty Chunks: "+totalEmpty);
    print("Average Chunk Size (non-empty): "+(totalSize/(totalChunks-totalEmpty)));
}

    É bastante básico no momento, mas faz o trabalho. Eu também adicionei no github e posso expandi-lo ainda mais lá. Por enquanto, porém, ele fará o que for necessário. No conjunto de dados de teste descrito no início, a saída se parece com isso (alguns dados foram removidos para brevidade):

    mongos> AllChunkInfo("chunkTest.foo", true);
ChunkID,Shard,ChunkSize,ObjectsInChunk
chunkTest.foo-_id_MinKey,shard0000,0,0
chunkTest.foo-_id_0.0,shard0000,599592,10707
chunkTest.foo-_id_10707.0,shard0000,1147832,20497
chunkTest.foo-_id_31204.0,shard0000,771568,13778
chunkTest.foo-_id_44982.0,shard0000,771624,13779
// omitted some data for brevity
chunkTest.foo-_id_940816.0,shard0000,1134224,20254
chunkTest.foo-_id_961070.0,shard0000,1145032,20447
chunkTest.foo-_id_981517.0,shard0000,1035104,18484
***********Summary Chunk Information***********
Total Chunks: 41
Average Chunk Size (bytes): 1365855.024390244
Empty Chunks: 1
Average Chunk Size (non-empty): 1400001.4

    Para explicar os argumentos passados ​​para a função:

    O primeiro argumento é o namespace a ser examinado (uma string) e o segundo (um booleano) é se deve ou não usar a opção de estimativa ou não. Para qualquer ambiente de produção é recomendável usar estimate:true- se não for usado, todos os dados precisarão ser examinados, e isso significa puxá-los para a memória, o que será caro.

    Embora a estimate:trueversão não seja gratuita (ela usa contagens e tamanhos médios de objetos), é pelo menos razoável executá-la mesmo em um grande conjunto de dados. A versão estimada também pode estar um pouco errada se o tamanho do objeto estiver distorcido em alguns fragmentos e, portanto, o tamanho médio não for representativo (isso geralmente é bastante raro).

    • 11 
  2. db.collection.getShardDistribution()

    Esse é um comando muito bom que uso frequentemente para coisas como esta. Ele mostrará o total de blocos, o tamanho médio do bloco, a contagem de documentos, tudo por fragmento. Ele não fornece os dados de cada bloco como a resposta acima, mas é bastante rápido e fornece uma boa visão geral do que você está procurando.

    • 3

relate perguntas