Refragmentar uma collection

Sobre esta tarefa

• 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.

Antes de começar

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 o espaço de armazenamento disponível em cada shard em que a collection será distribuída seja pelo menos duas vezes o tamanho da collection que você deseja refragmentar e seu tamanho de índice total, dividido pelo número de shards.

    storage_req = ( ( collection_size + index_size ) * 2 ) / shard_count

    Por exemplo, considere uma collection que contém 2 TB de dados e tem um índice 400 GB distribuído em quatro shards. Para realizar uma operação de refragmentação nessa collection, cada shard exigiria 1.2 TB de armazenamento disponível.

    1.2 TB storage = ( ( 2 TB collection + 0.4 TB index ) * 2 ) / 4 shards

    Para atender aos requisitos de armazenamento, talvez seja necessário atualizar para o próximo nível de armazenamento durante a operação de refragmentação. Você pode reduzir assim que a operação for concluída.

  • 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 reescrever as queries do seu aplicativo para usar ambas as chaves de shard, a atual e a nova.

  Dica

  Se o seu aplicação tolerar o tempo de inatividade, você poderá executar estas etapas para evitar reescrever as queries do aplicativo para usar as chaves de shard atuais e as novas:

  1. Pare seu aplicativo.

  2. Reescreva seu aplicação para usar a nova chave de shard.

  3. Aguarde até que a refragmentação seja concluída. Para monitorar o processo de refragmentação, use o estágio de pipeline $currentOp .

  4. Implemente seu aplicação reescrito.

  Antes da conclusão da refragmentação, as seguintes queries retornam um erro se o filtro de query não incluir 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>
  }

Passos

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 fragmento 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: true,
     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

Casos de erro

db.runCommand({
  cleanupReshardCollection: "<database>.<collection>"
})