Reshard a Collection

Acerca de esta tarea

• Sólo se puede volver a fragmentar una colección a la vez.

• writeConcernMajorityJournalDefault debe ser true.

• Para volver a fragmentar una colección que tenga una restricción de unicidad, la nueva clave de partición debe satisfacer los requisitos del índice único para cualquier índice único existente.

• Los siguientes comandos y métodos de shell correspondientes no son compatibles con la colección que se está redividiendo durante la operación de redivisión:

  • collMod

  • convertToCapped

  • createIndexes

  • createIndex()

  • drop

  • drop()

  • dropIndexes

  • dropIndex()

  • renameCollection

  • renameCollection()

• Los siguientes comandos y métodos no son compatibles en el clúster mientras la operación de reajuste de particiones está en curso:

  • addShard

  • removeShard

  • db.createCollection()

  • dropDatabase

  Advertencia

  Utilizar cualquiera de los comandos anteriores durante una operación de redistribución de particiones provoca el fallo de la operación de redistribución de particiones.

• Si la colección que se va a reparticionar utiliza Atlas Search, el índice de búsqueda dejará de estar disponible al finalizar la repartición. Deberá reconstruir manualmente el índice de búsqueda una vez finalizada la repartición.

Antes de comenzar

Antes de volver a dividir tu colección, asegúrate de cumplir los siguientes requisitos:

• Tu aplicación puede tolerar un periodo de dos segundos en el que la colección que se está redistribuyendo bloquea los guardados. Durante el período en que las escrituras están bloqueadas, tu aplicación experimenta un aumento en la latencia. Si tu carga de trabajo no puede tolerar este requisito, considera refinando tu clave de partición en su lugar.

• Su base de datos cumple con estos requisitos de recursos:

  • Espacio libre en almacenamiento: Asegúrate de que el espacio de almacenamiento disponible en cada partición en el cual se va a distribuir la colección sea al menos el doble del tamaño de la colección que deseas volver a compartir y su tamaño total de índice, dividido por el número de particiones.

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

    Por ejemplo, considera una colección que contiene 2 TB de datos y tiene un índice de 400 GB distribuido en cuatro particiones. Para realizar una operación de resegmentación en esta colección, cada partición necesitaría 1.2 TB de almacenamiento disponible.

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

    Para cumplir con los requisitos de almacenamiento, es posible que deba actualizar al siguiente nivel de almacenamiento durante la operación de refragmentación. Puede reducir la capacidad una vez finalizada la operación.

  • E/S: Asegúrate de que tu capacidad de E/S esté por debajo del 50%.

  • Carga de la CPU: asegúrese de que la carga de su CPU esté por debajo del 80%.

  Importante

  La base de datos no exige estos requisitos. Si no se asignan suficientes recursos, pueden producirse las siguientes consecuencias:

  • la base de datos se queda sin espacio y se apaga

  • rendimiento reducido

  • La operación de refragmentación está tardando más de lo esperado

  Si tu aplicación tiene períodos de tiempo con menos tráfico, redistribuye tu colección durante ese tiempo si es posible.

• Debe reescribir las queries de su aplicación para utilizar tanto la clave de partición actual como la nueva clave de partición.

  Tip

  Si tu aplicación puede tolerar tiempos de inactividad, puedes realizar estos pasos para evitar reescribir las queries de la aplicación para usar tanto la clave de partición actual como la nueva:

  1. Detén tu aplicación.

  2. Reescriba su aplicación para utilizar la nueva clave de fragmento.

  3. Espere hasta que se complete el nuevo particionamiento. Para supervisar el proceso de redistribución, utilice la etapa de $currentOp pipeline.

  4. Implementa tu aplicación reescrita.

  Antes de que se complete la reorganización de los fragmentos, las siguientes consultas devuelven un error si el filtro de consulta no incluye ni la clave de fragmento actual ni un campo único (como _id):

  • deleteOne()

  • findAndModify()

  • findOneAndDelete()

  • findOneAndReplace()

  • findOneAndUpdate()

  • replaceOne()

  • updateOne()

  Para un rendimiento óptimo, le recomendamos que también reescriba otras consultas para incluir la nueva clave de fragmento.

  Una vez completada la operación de refragmentación, puedes remover la clave de partición anterior de las consultas.

• No existen procesos de creación de índices en curso. Utiliza db.currentOp() para comprobar si hay procesos activos de creación de índices:

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

  En el documento de resultados, si el valor en el campo inprog es un arreglo vacío, no hay creaciones de índices en curso:

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

Pasos

En una operación de refragmentación de una colección, un fragmento puede ser:

• dador, que actualmente almacena los fragmentos para la colección particionada.

• destinatario, que almacena nuevos fragmentos para la colección particionada en función de las claves de partición y zonas.

Una partición puede ser donante y receptor al mismo tiempo. El conjunto de particiones donantes es idéntico a las particiones receptoras, a menos que utilices zonas.

El servidor de configuración principal siempre es el coordinador de re-sharding e inicia cada fase de la operación de re-sharding.

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>"
})

Comportamiento

Casos de error

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