Menu Docs
Página inicial do Docs
/ /
Referência
Página inicial do Docs
/
Ferramentas
/
mongosync
/
Referência
Página inicial do Docs
/
Ferramentas
/
mongosync
/
Referência

Finalize o processo de transição

Você pode finalizar uma migração e transferir o volume de trabalho do aplicação do cluster de origem para o de destino usando o processo de substituição domongosync .

mongosync deve permanecer ativo até atingir o estado escalado. Isso permite que mongosync sincronize quaisquer gravações adicionais que ocorram durante a migração.

Observação

Antes de mudar o volume de trabalho do aplicação para o cluster de destino, você deve sempre verificar uma sincronização bem-sucedida. Para mais informações, consulte Verificar Transferência de Dados.

Passos

1

Verifique o status do mongosync.

Ligue para o endpoint de progresso para determinar o status de mongosync antes de iniciar o processo de cutover. Certifique-se de que o status do processo mongosync indique os seguintes valores:

  • canCommit é true.

  • lagTimeSeconds é pequeno (perto de 0).

    Se lagTimeSeconds não estiver próximo de 0 quando a transição começar, a transição poderá levar muito tempo.

  • Ao usar o Verificador incorporado, verifique verification.source os verification.destination documentos de devolução e. Os campos lagTimeSeconds em ambos os documentos devem estar próximos de 0 e os campos phase devem mostrar "stream hashing".

    Se o verificador não estiver na fase de hash de fluxo, o processo de corte pode levar muito tempo.

O exemplo a seguir retorna o status do processo de sincronização.

Solicitar

curl localhost:27182/api/v1/progress -XGET

Resposta

{
   "progress":
      {
         "state":"RUNNING",
         "canCommit":true,
         "canWrite":false,
         "info":"change event application",
         "lagTimeSeconds":0,
         "collectionCopy":
            {
               "estimatedTotalBytes":694,
               "estimatedCopiedBytes":694
            },
         "directionMapping":
            {
               "Source":"cluster0: localhost:27017",
               "Destination":"cluster1: localhost:27018"
            },
         "source":
            {
               "pingLatencyMs":250
            },
         "destination":
            {
               "pingLatencyMs":-1
            },
         "verification":
            {
               "source":
                  {
                     "estimatedDocumentCount": 42,
                     "hashedDocumentCount": 42,
                     "lagTimeSeconds": 2,
                     "totalCollectionCount": 42,
                     "scannedCollectionCount": 10,
                     "phase": "stream hashing"
                  },
               "destination": {
                     "estimatedDocumentCount": 42,
                     "hashedDocumentCount": 42,
                     "lagTimeSeconds": 2,
                     "totalCollectionCount": 42,
                     "scannedCollectionCount": 10,
                     "phase": "stream hashing"
               }
            }
      },
   "success": true
}
2

Pare todas as operações de gravação nas coleções sincronizadas na origem.

  • Aguarde todas as transações no cluster de origem confirmarem ou cancelarem.

  • mongosync gerencia o bloqueio de gravação com base em sua configuração de migração. Para saber mais, consulte Bloqueio de escrita.

  • Se o mongosync usar sincronização filtrada, não será necessário desabilitar as gravações em todo o cluster de origem. No entanto, você deve garantir que você interrompa as operações de gravação para as coleções que o filtro inclui.

3

Envie uma solicitação de confirmação para mongosync.

Se você iniciar múltiplas instâncias do mongosync para sua migração, você deverá emitir uma solicitação de confirmação para cada instância do mongosync.

Solicitar

curl localhost:27182/api/v1/commit -XPOST --data '{ }'

Resposta

{"success":true}

Observação

Depois de enviar uma solicitação commit , chame o endpoint progress para garantir que o estado mongosync seja COMMITTING ou COMMITTED.

Se o cluster de origem tiver Configurações de Query Persistentes (PQS), você deverá migrar manualmente o PQS para o cluster de destino.

Na configuração padrão, mongosync bloqueia as gravações no cluster de origem depois de concluir esta etapa.

Se mongosync falhar durante essa etapa, talvez seja necessário desbloquear manualmente as gravações no cluster de origem executando o seguinte comando:

db.adminCommand(
  {
    setUserWriteBlockMode: 1,
    global: false
  }
)
4

Aguarde até que você possa executar gravações no cluster de destino.

Chame o ponto de extremidade progress para determinar se canWrite é true. Se canWrite for false, aguarde até que progress mostre que canWrite é true. Se você estiver executando várias instâncias do mongosync, verifique apenas se canWrite é verdadeiro no primeiro processo mongosync. O status canWrite de qualquer processo mongosync subsequente não é válido.

curl -sS localhost:27182/api/v1/progress -XGET | jq ".progress.canWrite"
true
5

Verifique a transferência de dados.

Verifique a sincronização bem-sucedida de dados da origem para o cluster de destino.

Para obter mais informações, consulte Verificar a fonte de dados.

6

Se você bloqueou manualmente as gravações no cluster de destino setUserWriteBlockMode usando, habilite as gravações do aplicação no cluster de destino.

Para habilitar gravações, atualize setUserWriteBlockMode:

db.adminCommand(
   {
      setUserWriteBlockMode: 1,
      global: false
   }
)

Em seguida, transfira o volume de trabalho do aplicação para o cluster de destino.

7

Chame o ponto de extremidade progress para determinar o status do processo mongosync.

Quando a resposta de progresso do mongosync indicar que o estado do mongosync é COMMITTED, o processo de cutover estará concluído.

curl -sS localhost:27182/api/v1/progress -XGET | jq ".progress.state"
"COMMITTED"

Comportamento

canWrite e Committed

mongosync permite gravações no cluster de destino em um estágio anterior ao estado COMMITTED.

Você pode escrever no destino depois que /progress informa canWrite: true ou quando o estado COMMITTED for. Para saber mais sobre o bloqueio de escrita, consulte Bloqueio de escrita. Se você estiver executando várias instâncias mongosync de, use somente o canWrite status do primeiro mongosync processo.

Na sincronização inicial, o mongosync replica índices únicos no cluster de origem como índices não exclusivos no cluster de destino. Durante o commit, os índices não exclusivos relevantes no cluster de destino são definidos como prepareUnique. Quando isso é feito, o ponto de extremidade /progress começa a retornar canWrite: true. As collections com índices prepareUnique rejeitam novos documentos que violam a restrição de índice único . mongosync então converte os índices prepareUnique em índices únicos. Quando isso é feito, mongosync muda de estado para COMMITTED.

Observação

A conversão de índices prepareUnique em índices únicos pode consumir muitos recursos ao sincronizar grandes collections. Isso pode resultar em um longo tempo entre o endpoint /progress retornando canWrite: true e mongosync atingindo o estado COMMITTED.

Embora os aplicativos possam emitir gravações quando canWrite: true for retornado, as operações que exigem bloqueios exclusivos, como compilações de índice, podem prosseguir somente após a conclusão da conversão do índice. Além disso, as operações de gravação podem sofrer um aumento da latência durante esse período devido à contenção de recursos da concorrência.

Saiba mais

Voltar

Dimensionamento do oplog

Próximo

Migrar configurações de query persistente

Nesta página