Colocar em Dia uma Réplica PostgreSQL Depois de uma Queda de Rede, pela Linha de Comando

· 10 min de leitura · replicação de banco de dados · sql server para postgresql · sincronização incremental · linha de comando · api de jobs

Colocar em Dia uma Réplica PostgreSQL Depois de uma Queda de Rede, pela Linha de Comando

Uma réplica PostgreSQL guarda a cópia de uma tabela do SQL Server. Um job roda a cada poucos minutos e copia só o que mudou. Aí a rede cai. Quando volta, a réplica está horas atrasada.

São três coisas. Copiar só o que mudou durante a queda, não a tabela inteira. Provar que a réplica voltou a bater. E fazer as duas por script, para rodar no cron ou no CI.

Este texto mostra como fazer, no Linux e no Windows, com o dbSlice by Thinwork. Os mesmos dois arquivos de job rodam nos dois. Todas as saídas abaixo vêm de execuções reais em laboratório.

Os dados de exemplo

Uma tabela genérica, payments, sem dado real. Cada valor é calculado a partir de payment_id. A tabela tem a coluna updated_at, que muda toda vez que a linha muda.

  • Antes da queda, os dois lados têm os mesmos 40.000 pagamentos. Veja 01-baseline.sql (SQL Server) e 02-baseline-postgres.sql (PostgreSQL).
  • Depois a réplica fica cerca de 6 horas sem sincronismo. Nesse tempo a origem segue trabalhando. Veja 03-outage-source.sql:
  • Chegam 2.160 pagamentos novos (um a cada 10 segundos).
  • 400 pagamentos antigos passam de pending para settled, e o updated_at deles avança.

Todos os arquivos estão num download só: replica-catch-up-after-network-outage.zip. Ele traz os três scripts SQL, os dois arquivos de job e um script pronto para Linux (run-linux.sh) e para Windows (run-windows.ps1). Os comentários dos arquivos estão em inglês.

Contagens no laboratório, logo depois da queda:

SQL Server total / last 8 h: 42160 / 2668   PostgreSQL total / last 8 h: 40000 / 120

Os dois arquivos de job

O job é um JSON pequeno com origem, destino, chave e modo. Ele nunca leva senha: só o nome de um perfil de conexão que você salvou no dbSlice.

MASTER e Server-dbPostg são os nomes dos perfis do nosso laboratório. Troque pelos nomes dos seus perfis.

O primeiro job, replica-payments-sync.json, mantém a réplica em dia:

{
  "nome": "replica-payments-sync",
  "tipo": "sync",
  "mode": "Upsert",
  "origem": {
    "environment": "article",
    "db": "MASTER",
    "type": "TABLE",
    "object": "payments",
    "key": "payment_id",
    "watermark": "updated_at"
  },
  "destino": {
    "environment": "article",
    "db": "Server-dbPostg",
    "type": "TABLE",
    "object": "payments",
    "key": "payment_id"
  },
  "pageSize": 10000
}

O Upsert insere as linhas cuja chave falta no destino e atualiza as que já existem. Nunca apaga.

O "watermark": "updated_at" (marca d'água) torna o job incremental. Antes de ler, o dbSlice pega o maior updated_at da origem e guarda como marca. A execução seguinte lê só as linhas com updated_at >= marca. A comparação inclui a própria marca de propósito: uma linha gravada no mesmo segundo da marca não se perde.

O segundo job, replica-payments-check.json, compara e só lê. Ele olha só as últimas 8 horas da origem:

{
  "nome": "replica-payments-check",
  "tipo": "status",
  "origem": {
    ...
    "key": "payment_id",
    "where": "updated_at >= DATEADD(hour, -8, GETDATE())"
  },
  "destino": { ... },
  "pageSize": 10000
}

O where usa o dialeto da origem (SQL Server). Escolha uma janela um pouco maior que a queda.

Também dá para montar a sincronização ou a comparação na tela, salvar e apontar um job para o arquivo salvo.

Como rodar: Linux e Windows

Linux (edição Docker, API de jobs)Windows (CLI)
Precisa de curl e jq. Crie um token na guia API da edição web, com os escopos jobs:run e runs:read, a lista de jobs permitidos e a validade. Salve em um arquivo. Copie os dois arquivos de job para a pasta jobs/ do volume de dados da instância. A API roda o job pelo nome.Salve os dois perfis no dbSlice. Não há mais nada para configurar.
O token vai só no cabeçalho Authorization: Bearer.O job não leva token nem senha.

Linux:

URL=http://127.0.0.1:8098
TOKEN="$(cat ./token)"   # dbs_xxxxxxxx_...
curl -sS -X POST "$URL/api/v1/jobs/replica-payments-sync/run" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"runLabel": "after-outage"}'

A API responde com um runId. Consulte GET /api/v1/runs/<runId> até o status sair de queued e running, e leia GET /api/v1/runs/<runId>/log. O run-linux.sh faz isso em cada passo.

Windows:

dbSlice.exe replica-payments-sync.json sync.log

A CLI imprime o resultado e grava o log no arquivo informado.

Nos dois sistemas o código de saída diz se a execução deu certo. No Windows é 0 em caso de sucesso e diferente de zero se falhar. No Linux, faça o script sair com código diferente de zero quando a execução não terminar em succeeded. É o que o cron ou o CI precisam para perceber uma execução com falha.

Antes da queda: a primeira execução

O job de sincronização já tinha rodado uma vez, com os dois lados iguais. Sem marca salva, a primeira execução lê a tabela inteira. Saída no Linux (a instância do laboratório roda em português):

Concluído: 40.000 lidos, 0 inseridos, 40.000 upsert/update em 1,8s

Nada faltava, por isso 0 inseridos. O que importa é que a execução guardou a marca: o último updated_at que a réplica recebeu.

Depois da queda: conferir a janela

Saída no Linux, resumida:

Comparação concluída em 0,3s: 108 iguais, 2.160 faltando no destino, 39.492 faltando na origem. 400 com valores divergentes.
  Faltando no destino (2.160): 40001, 40002, 40003, ...
  36002: status [settled ≠ pending], updated_at [2026-11-18T03:34:33 ≠ 2026-11-15T04:46:01]
  36011: status [settled ≠ pending], updated_at [2026-11-18T03:34:42 ≠ 2026-11-15T04:55:01]
  ...

No Windows, o mesmo resultado (interface em inglês): 108 matched, 2,160 missing in destination, 39,492 missing in source. 400 with different column values.

Leia em quatro grupos:

  • 2.160 faltando no destino: os pagamentos novos que chegaram durante a queda.
  • 400 com valores divergentes: os pagamentos que foram liquidados. O valor da origem vem primeiro: a origem diz settled, a réplica ainda diz pending.
  • 108 iguais: pagamentos antigos que caem na janela de 8 horas e não mudaram.
  • 39.492 faltando na origem: não é problema. O where filtra só a origem. A réplica continua com todo o histórico, e cada linha com mais de 8 horas aparece aqui. As 40.000 linhas da réplica, menos as 508 que estão na janela (108 + 400), dão 39.492.

Os números que importam são faltando no destino e divergentes.

Colocar em dia: o mesmo job de sincronização

Não há job especial de recuperação. Roda-se o mesmo job de sincronização que roda a cada poucos minutos:

destino: Server-dbPostg [PostgreSQL]  ·  payments  ·  modo: Upsert
impacto: grava no destino (INSERT + UPDATE)
Página 1: 2.561/2.561 processados
Concluído: 2.561 lidos, 2.160 inseridos, 401 upsert/update em 0,2s

Leu 2.561 linhas, não 42.160. Só o que mudou desde a marca salva:

  • 2.160 pagamentos novos, inseridos.
  • 400 pagamentos liquidados, atualizados.
  • 1 linha com updated_at exatamente igual à marca. A condição é >=, então essa linha é lida de novo. Gravá-la outra vez não muda nada.

2.160 + 400 + 1 = 2.561. O Windows deu as mesmas contagens: 2,561 read, 2,160 inserted, 401 upsert/update.

A queda durou 6 horas, mas o job não depende do relógio. Ele parte da marca que guardou. Uma queda mais longa só significa mais linhas nessa execução.

A prova: conferir de novo

Comparação concluída em 0,2s: 2.668 iguais, 0 faltando no destino, 39.492 faltando na origem. 0 com valores divergentes.

Faltando no destino e divergentes estão em 0. Os 39.492 fora da janela continuam lá, pelo mesmo motivo de antes.

Contagens no laboratório depois da execução:

SQL Server total / last 8 h: 42160 / 2668   PostgreSQL total / last 8 h: 42160 / 2668

Quem prova que a réplica voltou a bater é a conferência. Não use só os contadores do próprio job de sincronização para isso.

Rodar a sincronização de novo

Rodamos o job de sincronização mais uma vez:

Página 1: 1/1 processados
Concluído: 1 lidos, 0 inseridos, 1 upsert/update em 0,2s

Nada novo para copiar. A única linha é, de novo, a que está exatamente na marca. É o estado normal de um job incremental: cada execução lê só o que mudou desde a anterior.

O que a marca d'água não faz

Conheça os limites antes de depender dela:

  • Não vê exclusões. Uma linha apagada na origem não é lida, porque não existe mais. Ela fica na réplica. Uma conferência com o where só a mostra como faltando na origem se ela cair na janela, misturada com o histórico. Para achar exclusões, rode a conferência da tabela inteira, sem where: aí cada "faltando na origem" é uma linha que saiu da origem.
  • Linhas que mudam durante a execução. A marca é o maior updated_at lido antes de a execução começar a ler. Uma linha alterada enquanto a execução lê ganha um updated_at mais novo, então a próxima execução a pega.
  • Relógios e transações longas. Se o updated_at vem de relógios diferentes, ou uma transação longa grava com horário antigo, uma linha pode cair um pouco abaixo da marca. O "watermarkLookbackMinutes" na origem faz cada execução reler uma margem antes da marca. O custo: toda execução, mesmo a sem novidade, relê essa margem, e a segunda execução deixa de ler só 1 linha.

Agendar

Linux (cron), a cada 5 minutos. Guarde os passos num script que sai com erro quando falha:

*/5 * * * * /opt/jobs/replica-sync.sh >> /var/log/replica-sync.log 2>&1

Windows (Agendador de Tarefas): crie uma tarefa que roda dbSlice.exe replica-payments-sync.json sync.log com gatilho repetido. O Agendador lê o código de saída, então uma execução com falha aparece como tarefa com falha.

Uma conferência da janela à noite (replica-payments-check.json) diz se a réplica está mesmo em dia.

A série

"dbSlice CLI no dia a dia", quatro casos pela linha de comando:

  1. Conferir e Completar uma Migração Grande do SQL Server para o PostgreSQL pela Linha de Comando
  2. Colocar em Dia uma Réplica PostgreSQL Depois de uma Queda de Rede, pela Linha de Comando (este texto)
  3. Corrigir Chaves Estrangeiras Quebradas Depois de Mensagens Perdidas na Fila, pela Linha de Comando
  4. Monte uma Base de QA Mascarada a partir de uma Amostra da Produção, pela Linha de Comando

Também pela linha de comando: Copiar Só as Linhas que Faltam do SQL Server para o PostgreSQL pela Linha de Comando.

Fechamento

Um job de sincronização com marca d'água mantém a réplica em dia e também a coloca em dia depois de uma queda: ele parte da marca salva e copia só o que mudou. Um job de conferência, limitado a uma janela, prova o resultado. Olhe faltando no destino e divergentes. "Faltando na origem" fora da janela é histórico, não erro. Rodam no terminal, no cron, no Agendador ou pela API. O job nunca leva senha.

O dbSlice é produto da nossa empresa, então leia com isso em mente. Para testar:

Experimente grátis na Microsoft Store ↗ Ver preços

← Voltar ao blog