Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/
Fragmentação
/
Administração

Limpar jumbo bandeira

Nesta página

  • Procedimentos

Se o MongoDB não puder divisão um chunk que exceda o tamanho do intervalo especificado, o MongoDB o chunk como jumbo.

Os procedimentos a seguir descrevem as etapas para limpar manualmente a bandeira jumbo .

Procedimentos

Blocos Divisíveis

A maneira manual preferencial de limpar o sinalizador jumbo de um bloco é tentar dividir o bloco. Se a parte for divisível, o MongoDB removerá a bandeira após a divisão bem-sucedida da parte.

1

Conecte-se mongos a.

Conecte mongosh a um mongos.

2

Encontre o jumbo bloco.

Execute sh.status(true) para encontrar o chunk rotulado jumbo .

sh.status(true)

Por exemplo, a saída a seguir de sh.status(true) mostra que a parte com faixa de chave de shard { "x" : 2 } -->> { "x" : 4 } é jumbo.

 --- Sharding Status ---
   sharding version: {
      ...
   }
   shards:
      ...
   databases:
      ...
         test.foo
            shard key: { "x" : 1 }
         chunks:
              shard-b  2
              shard-a  2
         { "x" : { "$minKey" : 1 } } -->> { "x" : 1 } on : shard-b Timestamp(2, 0)
         { "x" : 1 } -->> { "x" : 2 } on : shard-a Timestamp(3, 1)
         { "x" : 2 } -->> { "x" : 4 } on : shard-a Timestamp(2, 2) jumbo
         { "x" : 4 } -->> { "x" : { "$maxKey" : 1 } } on : shard-b Timestamp(3, 0)
3

Divida o jumbo chunk .

Use sh.splitAt() ou sh.splitFind() para fazer a divisão da parte jumbo .

sh.splitAt( "test.foo", { x: 3 })

O MongoDB remove a bandeira jumbo após a divisão bem-sucedida do chunk.

Blocos Indivisíveis

Em alguns casos, o MongoDB não pode fazer a divisão da parte que não é mais jumbo, como uma parte com uma faixa de valor de chave de shard único. Dessa forma, não é possível dividir o chunk para limpar a bandeira.

Nesses casos, você pode alterar a chave do fragmento para que a parte se torne divisível ou limpar manualmente o sinalizador.

Refinar a chave de fragmento

O MongoDB fornece o comando refineCollectionShardKey . Usando o comando refineCollectionShardKey , você pode refinar a chave de shard de uma collection adicionando um ou mais campo de sufixo à chave existente. Ao adicionar novo(s) campo(s) à chave de shard, chunks jumbo indivisíveis podem se tornar divisíveis.

1
Conecte-se mongos a.

Conecte mongosh a um mongos.

2
Encontre o jumbo bloco.

Execute sh.status(true) para encontrar o chunk rotulado jumbo .

sh.status(true)

Por exemplo, a seguinte saída de sh.status(true) mostra que, para a collection fragmentada test.orders, tanto a parte com intervalo de chaves de fragmento { "status" : "A" } -->> { "status" : "D" } quanto a parte com intervalo { "status" : "D" } -->> { "status" : "P" } são jumbo.

 --- Sharding Status ---
   sharding version: {
     ...
   }
   shards:
     ...
   databases:
     ...
     test.orders
        shard key: { "status" : 1 }
        unique: false
        balancing: true
        chunks:
                shardA       2
                shardB       2
        { "status" : { "$minKey" : 1 } } -->> { "status" : "A" } on : shardB Timestamp(3, 0)
        { "status" : "A" } -->> { "status" : "D" } on : shardA Timestamp(5, 1) jumbo
        { "status" : "D" } -->> { "status" : "P" } on : shardA Timestamp(4, 2) jumbo
        { "status" : "P" } -->> { "status" : { "$maxKey" : 1 } } on : shardB Timestamp(5, 0)
3
Refine a chave de test.orders fragmento para a coleção.

Para resolver a baixa cardinalidade da chave status , refine a chave para a coleção test.orders . Por exemplo, adicione os campos order_id e customer_id como um sufixo à chave de fragmento atual; ou seja, a chave de fragmento será { status: 1, order_id: 1, customer_id: 1 } após o refinamento.

  1. Primeiro, create the index para suportar a chave de shard { status: 1, order_id: 1, customer_id: 1 } se o índice ainda não existir.

    db.orders.createIndex( { status: 1, order_id: 1, customer_id: 1 } )

    Para obter considerações de índice adicionais para refinar a chave de shard, consulte Considerações de índice.

  2. No reconhecimento de data center do admin , execute o comando refineCollectionShardKey para adicionar o campo order_id e customer_id como um sufixo para a chave existente:

    db.adminCommand( {
       refineCollectionShardKey: "test.orders",
       key: { status: 1, order_id: 1, customer_id: 1 }
    } )

O comando refineCollectionShardKey atualiza as faixas de partes e as faixas de zona para incorporar os novos campo sem modificar os valores de faixa dos campos-chave existentes. Ou seja, o refinamento da chave de fragmento não afeta imediatamente a distribuição de partes entre fragmentos ou zona. Qualquer futura divisão ou migração de chunk ocorre como parte das operações de fragmentação de rotina.

Dica

Depois de refinar a chave de fragmento, talvez nem todos os documentos da coleção tenham o(s) campo(s) de sufixo. Para preencher o(s) campo(s) de chave de fragmento ausente(s), consulte Campos de chave de fragmento ausentes.

Antes de refinar a chave de fragmento, certifique-se de que todos ou a maioria dos documentos na coleção tenham os campos de sufixo, se possível, para evitar a necessidade de preencher o campo posteriormente.

Limpar manualmente o jumbo sinalizador de um chunk indivisível

Para limpar manualmente o sinalizador jumbo , você pode usar o comando clearJumboFlag . Se você limpar o sinalizador jumbo de um chunk que ainda exceda o tamanho do chunk, o MongoDB rotulará novamente o chunk como jumbo quando o MongoDB tentar mover o chunk.

Importante

Use este método apenas se o método preferido não for aplicável.

Para limpar manualmente o sinalizador, use as seguintes etapas:

1
Conecte-se mongos a.

Conecte mongosh a um mongos.

2
Encontre o jumbo bloco.

Execute sh.status(true) para encontrar o chunk rotulado jumbo .

sh.status(true)

Por exemplo, a saída a seguir de sh.status(true) mostra que a parte com faixa de chave de shard { "x" : 2 } -->> { "x" : 3 } é jumbo.

 --- Sharding Status ---
   sharding version: {
      ...
   }
   shards:
      ...
   databases:
      ...
         test.foo
            shard key: { "x" : 1 }
         chunks:
              shard-b  2
              shard-a  2
         { "x" : { "$minKey" : 1 } } -->> { "x" : 1 } on : shard-b Timestamp(2, 0)
         { "x" : 1 } -->> { "x" : 2 } on : shard-a Timestamp(3, 1)
         { "x" : 2 } -->> { "x" : 3 } on : shard-a Timestamp(2, 2) jumbo
         { "x" : 3 } -->> { "x" : { "$maxKey" : 1 } } on : shard-b Timestamp(3, 0)
3
Execute o clearJumboFlag comando.

Do reconhecimento de data center do admin, execute o clearJumboFlag, passando no namespace da collection fragmentada e:

  • os limites da parte jumbo :

    db.adminCommand( {
       clearJumboFlag: "test.foo",
       bounds: [{ "x" : 2 }, { "x" : 3 }]
    })

  • o documento de localização com uma chave de shard e um valor contido na parte jumbo :

    db.adminCommand( {
       clearJumboFlag: "test.foo",
       find: { "x" : 2 }
    })

    Observação

    Se a collection usar uma chave de fragmento com hash, não use o campo find com clearJumboFlag. Para chaves de fragmento com hash, use o campo bounds .

Dica

Veja também:

refineCollectionShardKey

Voltar

Parar de desfragmentar uma coleção

Próximo

Descartar o índice de hashed shard key

Nesta página