Refragmentar uma collection

Requisitos

Antes de refragmentar sua collection, certifique-se de atender aos seguintes requisitos:

• Seu aplicativo pode tolerar um período de dois segundos em que a collection que está sendo refragmentada bloqueia as gravações. Durante o período em que as gravações são bloqueadas, seu aplicativo experimenta um aumento na latência. Se seu volume de trabalho não tolerar esse requisito, considere ajustar sua chave de shard.

• Seu banco de dados atende aos seguintes requisitos de recursos:

  • Espaço de armazenamento disponível: certifique-se de que seu cluster tenha espaço em disco suficiente disponível para refragmentação. Se os documentos na collection refragmentada forem distribuídos uniformemente em todo o cluster, cada fragmento (shard) consumirá cerca de 1,2 vezes o tamanho total da collection dividido pelo número de fragmentos para armazenamento em disco.

    Observação

    A refragmentação requer espaço em disco adicional porque o processo cria uma nova coleção com dados distribuídos entre fragmentos de acordo com a nova chave do fragmento. Consulte Processo de refragmentação para obter mais informações.

  • E/S: certifique-se de que sua capacidade de E/S esteja abaixo de 50%.

  • Carga da CPU: certifique-se de que a carga da CPU esteja abaixo de 80%.

  Importante

  Esses requisitos não são exigidos pelo banco de dados. Uma falha na alocação de recursos suficientes pode resultar em:

  • o banco de dados ficar sem espaço e desligando

  • redução do desempenho

  • a operação de refragmentação demora mais que o esperado

  Se o seu aplicativo tiver períodos com menos tráfego, refaça a fragmentação da sua collection durante esse período, se possível.

• Você deve executar uma destas tarefas:

  • reescreva as queries do seu aplicativo para usar ambas as chaves de shard, a atual e a nova

  • interrompa seu aplicativo e, em seguida:

    • reescreva as queries do aplicativo para usar a nova chave de shard

    • esperar até que o refragmentação da coleção seja concluído (para monitorar o processo de refragmentação, use um estágio de pipeline $currentOp )

    • distribua seu aplicativo reescrito

  As seguintes queries retornam um erro se o filtro de query não incluir ambos a chave de shard atual ou um campo exclusivo (como _id):

  • deleteOne()

  • findAndModify()

  • findOneAndDelete()

  • findOneAndReplace()

  • findOneAndUpdate()

  • replaceOne()

  • updateOne()

  Para um desempenho ideal, recomendamos que você também reescreva outras queries para incluir a nova chave de shard.

  Quando a operação de refragmentação for concluída, você poderá remover a chave de shard antiga das consultas.

• Nenhuma construção de índice está em andamento. Use db.currentOp() para verificar qualquer construção de índice está em execução:

   db.adminCommand(
      {
        currentOp: true,
        $or: [
          { op: "command", "command.createIndexes": { $exists: true }  },
          { op: "none", "msg" : /^Index Build/ }
        ]
      }
  )

  No documento de resultado, se o valor do campo inprog for uma array vazia, não haverá nenhuma construção de índice em andamento:

  {
     inprog: [],
     ok: 1,
     '$clusterTime': { ... },
     operationTime: <timestamp>
  }

Limitações

• Somente uma coleção pode ser refragmentada de cada vez.

• writeConcernMajorityJournalDefault deve ser true.

• Para refragmentar uma collection que tenha uma restrição de exclusividade, a nova chave de shard deve satisfazer os requisitos de índice únicos para quaisquer índices únicos existentes.

• Os comandos a seguir e os métodos de shell correspondentes não são compatíveis com a collection que está sendo refragmentada enquanto a operação de refragmentação está em andamento:

  • collMod

  • convertToCapped

  • createIndexes

  • createIndex()

  • drop

  • drop()

  • dropIndexes

  • dropIndex()

  • renameCollection

  • renameCollection()

• Os seguintes comandos e métodos não são suportados no cluster enquanto a operação de refragmentação está em andamento:

  • addShard

  • removeShard

  • db.createCollection()

  • dropDatabase

  Aviso

  Usar qualquer um dos comandos anteriores durante uma operação de refragmentação faz com que a operação de refragmentação falhe.

• Se a collection a ser refragmentada usar Atlas Search, o índice de pesquisa ficará indisponível quando a operação de refragmentação for concluída. Você precisa refragmentar manualmente o índice de pesquisa assim que a operação de refragmentação for concluída.

• Você não pode refragmentar uma collection de séries temporais fragmentada.

Processo de refragmentação

Em uma operação de refragmentação de collection, um fragmento (shard) pode ser um:

• doador, que atualmente armazena chunks para a coleção fragmentada.

• receptor, que armazena novos chunks para a coleção fragmentada com base nas chaves de Shard e nas zonas.

Um shard pode ser doador e um receptor ao mesmo tempo. O conjunto de shards do doador é idêntico aos shards do receptor, a menos que você use zonas.

O servidor de configuração primário é sempre o gerenciador de refragmentação e inicia cada fase da operação de refragmentação.

db.adminCommand({
  reshardCollection: "<database>.<collection>",
  key: <shardkey>
})

db.getSiblingDB("admin").aggregate([
  { $currentOp: { allUsers: true, localOps: false } },
  {
    $match: {
      type: "op",
      "originatingCommand.reshardCollection": "<database>.<collection>"
    }
  }
])

[
  {
    shard: '<shard>',
    type: 'op',
    desc: 'ReshardingRecipientService | ReshardingDonorService | ReshardingCoordinatorService <reshardingUUID>',
    op: 'command',
    ns: '<database>.<collection>',
    originatingCommand: {
      reshardCollection: '<database>.<collection>',
      key: <shardkey>,
      unique: <boolean>,
      collation: { locale: 'simple' }
    },
    totalOperationTimeElapsedSecs: <number>,
    remainingOperationTimeEstimatedSecs: <number>,
    ...
  },
  ...
]

{
  ok: 1,
  '$clusterTime': {
    clusterTime: <timestamp>,
    signature: {
      hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
      keyId: <number>
    }
  },
  operationTime: <timestamp>
}

sh.status()

databases
[
  {
     database: {
     _id: '<database>',
     primary: '<shard>',
     partitioned: false,
     version: {
       uuid: <uuid>,
       timestamp: <timestamp>,
       lastMod: <number>
     }
   },
   collections: {
     '<database>.<collection>': {
       shardKey: <shardkey>,
       unique: <boolean>,
       balancing: <boolean>,
       chunks: [],
       tags: []
     }
   }
  }
  ...
]

db.adminCommand({
  commitReshardCollection: "<database>.<collection>"
})

db.adminCommand({
  abortReshardCollection: "<database>.<collection>"
})

Comportamento

Erro de Case