---

@CanalQb no YouTube

---

Leitura: ~9 min | Atualizado: July 2026

Sincronizar MySQL XAMPP em Rede Local (Guia Completo)

TL;DR - Resumo Executivo

• Conteudo preservado com expansao contextual sobre o tema original.
• Verificacoes praticas adicionadas para reduzir retrabalho.
• Fontes registradas nos metadados para rastreabilidade.

Sincronizar MySQL XAMPP em Rede Local (Guia Completo) - ponto de partida

Abertura direta ao problema: muitos comecam pelo obvio e repetem o erro ja documentado no backup. Este guia modernizado preserva a base original do @CanalQb e adiciona verificacao pratica.

Se seu foco for aplicar este roteiro rapido, mantenha este conteudo como base e compare endpoints, duvidas ou datas com fontes atuais. O que realmente importa e o metodo, nao apenas a documentacao.

---

@CanalQb no YouTube

---

Como Sincronizar MySQL XAMPP Entre Dois Computadores na Rede Local

---

ℹ️ Este tutorial é educativo. Adapte as configurações ao seu ambiente de produção com as devidas medidas de segurança antes de usar em sistemas críticos.

---

Você tem dois computadores na mesma rede e quer que o banco de dados MySQL fique sincronizado entre eles? Neste guia completo você vai aprender todos os métodos — do mais simples ao mais profissional —, cobrindo cenários com Windows e Ubuntu, replicação Master→Slave, Master↔Master bidirecional, scripts automáticos e até sincronização via triggers nativas do MySQL.

Ao longo do tutorial usamos os IPs 192.168.0.19 (Servidor/Master) e 192.168.0.18 (Cliente/Slave) como exemplo. Adapte para os IPs da sua rede.

📋 Índice Rápido ① Replicação Master → Slave (Windows → Windows) ② Replicação Master → Slave (Ubuntu → Windows) ③ Replicação Master → Slave (Windows → Ubuntu) ④ Replicação Master ↔ Master (Bidirecional) ⑤ Sincronização por Script (Dump Automático) ⑥ Sincronização com Node.js (Básico) ⑦ Sincronização com Node.js (Profissional) ⑧ CDC com SymmetricDS ⑨ Triggers + Federated Tables ⑩ MySQL Central Compartilhado (Mais Simples) 🔍 Comparativo Final

---

① Replicação Master → Slave: Windows → Windows

Este é o método mais clássico e documentado. O Master recebe todas as gravações e o Slave replica automaticamente. Qualquer criação de tabela, inserção, atualização ou exclusão feita no Master é propagada para o Slave sem intervenção manual.

MASTER (192.168.0.19 — Windows XAMPP)
↓ binary log
SLAVE (192.168.0.18 — Windows XAMPP)
Sentido único: gravações somente no Master

Passo 1 — Configurar o Master (192.168.0.19)

Abra o arquivo de configuração do MySQL do XAMPP:

C:\xampp\mysql\bin\my.ini

Adicione ou altere estas linhas na seção [mysqld]:

server-id = 1 log-bin = mysql-bin binlog_format = ROW binlog_do_db = meubanco bind-address = 0.0.0.0

Reinicie o MySQL no painel do XAMPP.

Passo 2 — Criar usuário de replicação no Master

Abra o phpMyAdmin ou o console MySQL e execute:

CREATE USER 'replica'@'192.168.0.%' IDENTIFIED BY 'senha123'; GRANT REPLICATION SLAVE ON *.* TO 'replica'@'192.168.0.%'; FLUSH PRIVILEGES;

Passo 3 — Anotar status do Master

SHOW MASTER STATUS;

Você verá algo como:

File: mysql-bin.000001 Position: 154

⚠️ Guarde os valores de File e Position — você vai precisar deles no Slave.

Passo 4 — Exportar e importar banco inicial

No Master, abra o terminal e execute:

C:\xampp\mysql\bin\mysqldump.exe -u root -p meubanco > C:\dump.sql

Copie o arquivo dump.sql para o Slave (192.168.0.18), por exemplo via pendrive ou pasta compartilhada. No Slave, importe:

C:\xampp\mysql\bin\mysql.exe -u root -p meubanco < C:\dump.sql

💡 Este dump é necessário apenas uma vez, para igualar o estado inicial. Depois, tudo é automático.

Passo 5 — Configurar o Slave (192.168.0.18)

Edite C:\xampp\mysql\bin\my.ini do segundo PC:

server-id = 2 bind-address = 0.0.0.0

Reinicie o MySQL do Slave.

Passo 6 — Conectar Slave ao Master

No console MySQL do Slave, execute usando os valores do Passo 3:

CHANGE MASTER TO MASTER_HOST = '192.168.0.19', MASTER_USER = 'replica', MASTER_PASSWORD = 'senha123', MASTER_LOG_FILE = 'mysql-bin.000001', MASTER_LOG_POS = 154; START SLAVE;

Passo 7 — Verificar replicação

SHOW SLAVE STATUS\G

Sucesso quando aparecer:

Slave_IO_Running: Yes Slave_SQL_Running: Yes

Passo 8 — Liberar o Firewall do Windows

Nos dois PCs: Painel de Controle → Firewall do Windows → Regras de Entrada → Nova Regra → Porta TCP 3306. Ou via PowerShell (execute como Administrador):

New-NetFirewallRule -DisplayName "MySQL 3306" -Direction Inbound -Protocol TCP -LocalPort 3306 -Action Allow

---

② Replicação Master → Slave: Ubuntu → Windows

Neste cenário o Master roda em Ubuntu (com MySQL ou MariaDB) e o Slave roda em Windows com XAMPP. A lógica é a mesma, mas os caminhos de arquivo e comandos são diferentes.

MASTER (192.168.0.19 — Ubuntu + MySQL)
↓ binary log via rede
SLAVE (192.168.0.18 — Windows XAMPP)

No Master Ubuntu — Editar configuração

Abra o arquivo de configuração:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Adicione ou ajuste:

[mysqld] server-id = 1 log-bin = mysql-bin binlog_format = ROW binlog_do_db = meubanco bind-address = 0.0.0.0

sudo systemctl restart mysql

Criar usuário de replicação no Ubuntu

mysql -u root -p CREATE USER 'replica'@'192.168.0.%' IDENTIFIED BY 'senha123'; GRANT REPLICATION SLAVE ON *.* TO 'replica'@'192.168.0.%'; FLUSH PRIVILEGES; SHOW MASTER STATUS;

Liberar firewall do Ubuntu

sudo ufw allow 3306/tcp sudo ufw reload

Exportar banco do Ubuntu

mysqldump -u root -p meubanco > ~/dump.sql

Transfira o arquivo para o Windows via SCP, pendrive ou pasta de rede. No Windows (XAMPP), importe:

C:\xampp\mysql\bin\mysql.exe -u root meubanco < C:\dump.sql

Configurar o Slave Windows

Em C:\xampp\mysql\bin\my.ini:

server-id = 2 bind-address = 0.0.0.0

Reinicie o MySQL do XAMPP. Depois, no console MySQL do Windows:

CHANGE MASTER TO MASTER_HOST = '192.168.0.19', MASTER_USER = 'replica', MASTER_PASSWORD = 'senha123', MASTER_LOG_FILE = 'mysql-bin.000001', MASTER_LOG_POS = 154; START SLAVE; SHOW SLAVE STATUS\G

💡 Verifique que as versões do MySQL são compatíveis. O Slave pode ter versão igual ou superior ao Master.

---

③ Replicação Master → Slave: Windows → Ubuntu

Aqui o Master fica no Windows com XAMPP e o Slave fica num servidor Ubuntu. Muito comum quando você desenvolve no Windows e quer replicar para um servidor Linux.

MASTER (192.168.0.19 — Windows XAMPP)
↓ binary log via rede
SLAVE (192.168.0.18 — Ubuntu + MySQL)

No Master Windows — Configurar XAMPP

Edite C:\xampp\mysql\bin\my.ini:

[mysqld] server-id = 1 log-bin = mysql-bin binlog_format = ROW binlog_do_db = meubanco bind-address = 0.0.0.0

Reinicie o MySQL no XAMPP, crie o usuário de replicação e anote o SHOW MASTER STATUS (igual ao Método 1, Passos 2 e 3).

Exportar banco do Windows para o Ubuntu

C:\xampp\mysql\bin\mysqldump.exe -u root meubanco > C:\dump.sql

Copie o dump para o Ubuntu via SCP:

scp C:\dump.sql usuario@192.168.0.18:~/dump.sql

No Ubuntu, importe:

mysql -u root -p meubanco < ~/dump.sql

Configurar o Slave Ubuntu

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

[mysqld] server-id = 2 bind-address = 0.0.0.0

sudo systemctl restart mysql

Conectar o Slave Ubuntu ao Master Windows

mysql -u root -p CHANGE MASTER TO MASTER_HOST = '192.168.0.19', MASTER_USER = 'replica', MASTER_PASSWORD = 'senha123', MASTER_LOG_FILE = 'mysql-bin.000001', MASTER_LOG_POS = 154; START SLAVE; SHOW SLAVE STATUS\G

Firewall Ubuntu

sudo ufw allow from 192.168.0.19 to any port 3306 sudo ufw reload

⚠️ No Windows, libere a porta 3306 no Firewall (conforme Passo 8 do Método 1).

---

④ Replicação Bidirecional: Master ↔ Master

Neste modo os dois PCs podem gravar ao mesmo tempo e as mudanças se propagam nos dois sentidos. É o mais poderoso dos métodos nativos do MySQL. Ele usa um truque simples de auto_increment para evitar conflito de IDs.

PC1 (192.168.0.19) ⇄ PC2 (192.168.0.18)
PC1 gera IDs: 1, 3, 5, 7 ...
PC2 gera IDs: 2, 4, 6, 8 ...

Configurar PC1 (my.ini)

server-id = 1 log-bin = mysql-bin binlog_format = ROW auto-increment-increment = 2 auto-increment-offset = 1 bind-address = 0.0.0.0

Configurar PC2 (my.ini)

server-id = 2 log-bin = mysql-bin binlog_format = ROW auto-increment-increment = 2 auto-increment-offset = 2 bind-address = 0.0.0.0

Reinicie o MySQL nos dois PCs.

Criar usuário de replicação nos dois PCs

CREATE USER 'replica'@'%' IDENTIFIED BY '123456'; GRANT REPLICATION SLAVE ON *.* TO 'replica'@'%'; FLUSH PRIVILEGES;

Verificar status nos dois

-- Execute em cada PC e guarde os valores: SHOW MASTER STATUS;

PC1 aponta para PC2

-- No console MySQL do PC1: CHANGE MASTER TO MASTER_HOST = '192.168.0.18', MASTER_USER = 'replica', MASTER_PASSWORD = '123456', MASTER_LOG_FILE = 'mysql-bin.000001', -- valor do PC2 MASTER_LOG_POS = 157; -- valor do PC2 START SLAVE;

PC2 aponta para PC1

-- No console MySQL do PC2: CHANGE MASTER TO MASTER_HOST = '192.168.0.19', MASTER_USER = 'replica', MASTER_PASSWORD = '123456', MASTER_LOG_FILE = 'mysql-bin.000001', -- valor do PC1 MASTER_LOG_POS = 157; -- valor do PC1 START SLAVE;

Verificar nos dois

SHOW SLAVE STATUS\G -- Deve mostrar: -- Slave_IO_Running: Yes -- Slave_SQL_Running: Yes

Testar bidirecionalidade

-- No PC1: CREATE TABLE teste ( id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(50) ); -- Verifique que a tabela aparece no PC2 também. -- No PC2 insira algo e veja no PC1.

💡 Para Ubuntu ↔ Windows bidirecional, basta aplicar a lógica acima mesclando os comandos dos Métodos 2 e 3: configure o my.ini de cada sistema operacional conforme seu padrão e execute os CHANGE MASTER TO de cada lado apontando para o outro.

---

⑤ Sincronização por Dump Automático (Script .bat)

Não quer mexer na replicação nativa? Este método usa dump e importação automáticos agendados. É simples, funciona bem para sistemas pequenos e não exige configuração complexa.

Estrutura

PC1 exporta banco a cada X minutos → pasta compartilhada na rede
PC2 lê a pasta e importa automaticamente

1. Criar pasta de sincronização

Nos dois PCs crie:

C:\mysql_sync

No PC1, compartilhe esta pasta na rede: clique com botão direito → Propriedades → Compartilhamento → Compartilhar → Everyone com permissão de leitura.

2. Script de exportação (PC1)

Crie C:\mysql_sync\exportar.bat:

@echo off "C:\xampp\mysql\bin\mysqldump.exe" -u root --databases meubanco > C:\mysql_sync\dump.sql echo [%DATE% %TIME%] Dump gerado >> C:\mysql_sync\log.txt

3. Script de importação (PC2)

Crie C:\mysql_sync\importar.bat:

@echo off copy \\192.168.0.19\mysql_sync\dump.sql C:\mysql_sync\dump.sql /Y "C:\xampp\mysql\bin\mysql.exe" -u root < C:\mysql_sync\dump.sql echo [%DATE% %TIME%] Import concluido >> C:\mysql_sync\log.txt

4. Agendar automaticamente

No Windows: Pesquisar → Agendador de Tarefas → Criar Tarefa Básica. Defina o gatilho como "A cada 1 minuto" e a ação como executar o arquivo .bat correspondente.

⚠️ Este método sobrescreve o banco no destino a cada execução. Não é bidirecional. Ideal para desenvolvimento, não para produção com dois usuários gravando ao mesmo tempo.

---

⑥ Sincronização com Node.js (Versão Básica)

Um script simples em Node.js que lê todos os registros de uma tabela no PC1 e os replica no PC2 a cada 5 segundos. Ótimo ponto de partida para quem prefere código a configurações de banco.

1. Instalar Node.js

Baixe em nodejs.org e instale. Depois, no terminal:

mkdir mysql-sync cd mysql-sync npm install mysql2

2. Script sync.js (básico)

const mysql = require('mysql2/promise'); const db1 = mysql.createPool({ host:'192.168.0.19', user:'root', password:'', database:'meubanco' }); const db2 = mysql.createPool({ host:'192.168.0.18', user:'root', password:'', database:'meubanco' }); async function sync() { const [rows] = await db1.query("SELECT * FROM clientes"); for (const row of rows) { await db2.query( "REPLACE INTO clientes (id, nome) VALUES (?, ?)", [row.id, row.nome] ); } console.log(`[${new Date().toLocaleTimeString()}] Sincronizado: ${rows.length} registros`); } setInterval(sync, 5000);

3. Executar

node sync.js

💡 O REPLACE INTO substitui o registro se a chave primária já existir, ou insere um novo caso contrário.

---

⑦ Sincronização com Node.js (Versão Profissional)

Versão avançada que detecta INSERT, UPDATE e DELETE usando o campo updated_at. Trabalha bidirecional e compara timestamps para decidir qual versão do registro é mais recente.

Pré-requisito: campo updated_at nas tabelas

CREATE TABLE clientes ( id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(100), updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP );

Script completo sync_pro.js

const mysql = require('mysql2/promise'); const cfgA = { host:'192.168.0.19', user:'root', password:'', database:'meubanco' }; const cfgB = { host:'192.168.0.18', user:'root', password:'', database:'meubanco' }; async function syncTable(srcPool, dstPool, table) { const [srcRows] = await srcPool.query(`SELECT * FROM ${table}`); const [dstRows] = await dstPool.query(`SELECT * FROM ${table}`); const dstMap = {}; dstRows.forEach(r => dstMap[r.id] = r); let inserted = 0, updated = 0; for (const row of srcRows) { if (!dstMap[row.id]) { await dstPool.query(`INSERT INTO ${table} SET ?`, row); inserted++; } else if (row.updated_at > dstMap[row.id].updated_at) { await dstPool.query(`REPLACE INTO ${table} SET ?`, row); updated++; } } console.log(`[${table}] Insert:${inserted} | Update:${updated}`); } async function run() { const poolA = await mysql.createPool(cfgA); const poolB = await mysql.createPool(cfgB); const tables = ['clientes', 'produtos', 'pedidos']; // liste suas tabelas try { console.log('\n-- A → B --'); for (const t of tables) await syncTable(poolA, poolB, t); console.log('\n-- B → A --'); for (const t of tables) await syncTable(poolB, poolA, t); } catch(e) { console.error('Erro:', e.message); } } setInterval(run, 3000);

Detectar DELETEs (opcional)

Para detectar exclusões, adicione uma coluna de soft-delete:

ALTER TABLE clientes ADD COLUMN deletado TINYINT(1) DEFAULT 0;

Em vez de DELETE FROM clientes WHERE id=?, use:

UPDATE clientes SET deletado = 1 WHERE id = ?;

O script já vai sincronizar esse campo. No front-end, filtre sempre com WHERE deletado = 0.

---

⑧ CDC com SymmetricDS (Quase Tempo Real)

O SymmetricDS é uma ferramenta open-source que lê o binary log do MySQL (Change Data Capture) e replica as mudanças em menos de 2 segundos. Funciona bidirecional, resolve conflitos e até sincroniza offline (quando a rede volta, envia o que acumulou).

192.168.0.19 → MySQL → binlog → SymmetricDS ⇄ SymmetricDS ← MySQL ← 192.168.0.18
Latência típica: 0.5 a 2 segundos

1. Ativar binlog no MySQL (ambos os PCs)

[mysqld] server-id = 1 ; use 2 no segundo PC log-bin = mysql-bin binlog_format = ROW

2. Baixar e extrair o SymmetricDS

Acesse symmetricds.org/download e extraia em C:\symmetricds (Windows) ou /opt/symmetricds (Ubuntu).

3. Criar banco interno do SymmetricDS

CREATE DATABASE symmetricds;

4. Arquivo de nó — PC1 (node1.properties)

engine.name = node1 db.driver = com.mysql.jdbc.Driver db.url = jdbc:mysql://localhost:3306/symmetricds db.user = root db.password = group.id = server external.id = 001 sync.url = http://192.168.0.19:31415/sync registration.url = http://192.168.0.19:31415/sync

5. Arquivo de nó — PC2 (node2.properties)

engine.name = node2 db.driver = com.mysql.jdbc.Driver db.url = jdbc:mysql://localhost:3306/symmetricds db.user = root db.password = group.id = client external.id = 002 sync.url = http://192.168.0.18:31415/sync registration.url = http://192.168.0.19:31415/sync

6. Iniciar o serviço

-- Windows (cmd como Administrador): bin\sym_service install bin\sym_service start -- Ubuntu: sudo ./bin/sym_service install sudo ./bin/sym_service start

💡 O SymmetricDS é amplamente usado em redes de franquias, filiais e PDVs que precisam de sincronização robusta com operação offline.

---

⑨ Triggers + Federated Tables (Dentro do MySQL)

Este método usa apenas recursos nativos do MySQL, sem scripts externos. Uma Federated Table é uma tabela local que aponta diretamente para um banco em outro servidor. Com uma Trigger, qualquer insert/update/delete propaga automaticamente.

1. Ativar o engine Federated

Em my.ini de ambos os PCs, na seção [mysqld]:

federated

Reinicie o MySQL.

2. Criar usuário remoto no PC2

-- No MySQL do PC2 (192.168.0.18): CREATE USER 'sync'@'192.168.0.%' IDENTIFIED BY '123456'; GRANT ALL PRIVILEGES ON meubanco.* TO 'sync'@'192.168.0.%'; FLUSH PRIVILEGES;

3. Criar Federated Table no PC1

-- No MySQL do PC1 (192.168.0.19): CREATE TABLE clientes_remote ( id INT, nome VARCHAR(100) ) ENGINE=FEDERATED CONNECTION='mysql://sync:123456@192.168.0.18:3306/meubanco/clientes';

Esta tabela reflete diretamente os dados do PC2.

4. Criar Triggers no PC1

DELIMITER $$ -- AFTER INSERT CREATE TRIGGER clientes_ai AFTER INSERT ON clientes FOR EACH ROW BEGIN INSERT INTO clientes_remote (id, nome) VALUES (NEW.id, NEW.nome); END$$ -- AFTER UPDATE CREATE TRIGGER clientes_au AFTER UPDATE ON clientes FOR EACH ROW BEGIN UPDATE clientes_remote SET nome = NEW.nome WHERE id = NEW.id; END$$ -- AFTER DELETE CREATE TRIGGER clientes_ad AFTER DELETE ON clientes FOR EACH ROW BEGIN DELETE FROM clientes_remote WHERE id = OLD.id; END$$ DELIMITER ;

5. Replicação bidirecional

Repita os passos acima no PC2, criando a Federated Table apontando para o PC1 e as triggers correspondentes. Atenção: você precisa evitar que as triggers criem loops de replicação. Uma forma é checar se o dado já existe antes de inserir, ou usar uma variável de sessão para indicar que a escrita veio de replicação.

⚠️ O engine Federated não é habilitado por padrão em todas as instalações. Verifique com SHOW ENGINES; se aparece "FEDERATED" com suporte "YES".

---

⑩ MySQL Central Compartilhado (A Opção Mais Simples)

Na maioria dos cenários de desenvolvimento ou sistemas internos pequenos, a solução mais inteligente é a mais simples: um único MySQL acessado pelos dois computadores via rede. Sem replicação, sem script, sem conflito.

PC1 192.168.0.19 → MySQL Server ← PC2 192.168.0.18
app1 ↗ banco único ↖ app2
Dados sempre consistentes, zero sincronização

1. Liberar acesso remoto no MySQL do PC1

Edite C:\xampp\mysql\bin\my.ini (ou /etc/mysql/mysql.conf.d/mysqld.cnf no Ubuntu):

bind-address = 0.0.0.0

Reinicie o MySQL.

2. Criar usuário com acesso de rede

-- Opção segura: usuário específico para a rede local CREATE USER 'app'@'192.168.0.%' IDENTIFIED BY '123456'; GRANT ALL PRIVILEGES ON meubanco.* TO 'app'@'192.168.0.%'; FLUSH PRIVILEGES;

3. Liberar firewall

Windows: Painel de Controle → Firewall → Regras de Entrada → Porta TCP 3306.

-- Ubuntu: sudo ufw allow from 192.168.0.0/24 to any port 3306 sudo ufw reload

4. Conectar do PC2

No terminal do PC2, teste:

mysql -h 192.168.0.19 -u app -p

Na sua aplicação (PHP, Node, Python etc.), a string de conexão fica assim:

host: 192.168.0.19 port: 3306 user: app password: 123456 database: meubanco

5. Otimizar para múltiplas conexões (bônus)

Se vários PCs vão usar o banco ao mesmo tempo, ajuste estas 5 linhas no my.ini do servidor:

max_connections = 50 innodb_buffer_pool_size = 256M query_cache_size = 32M query_cache_type = 1 wait_timeout = 600

💡 Esta arquitetura é exatamente como 90% dos sistemas internos de empresas funcionam. Se o objetivo é desenvolvimento ou um sistema de uso interno, comece por aqui antes de considerar replicação.

---

🔍 Comparativo: Qual Método Usar?

🖥️ MySQL Central

Complexidade: Mínima

Bidirecional: ✅

Tempo real: ✅

Use quando: desenvolvimento ou sistema interno simples

🔁 Master → Slave

Complexidade: Média

Bidirecional: ❌

Tempo real: ✅

Use quando: leitura distribuída, backup em tempo real

⇄ Master ↔ Master

Complexidade: Média-Alta

Bidirecional: ✅

Tempo real: ✅

Use quando: dois pontos de venda gravando ao mesmo tempo

🟢 Node.js Pro

Complexidade: Média

Bidirecional: ✅

Tempo real: ~3 seg

Use quando: quer controle total do código de sync

⚡ SymmetricDS

Complexidade: Alta

Bidirecional: ✅

Tempo real: ~1 seg

Use quando: sistema em produção com operação offline

🔧 Triggers + Federated

Complexidade: Alta

Bidirecional: ✅

Tempo real: ✅

Use quando: não quer dependências externas e domina SQL

---

🛠️ Problemas Comuns e Soluções

❌ Slave_IO_Running: No

Geralmente é problema de conectividade ou credencial. Verifique:

-- Teste de conexão do Slave ao Master: mysql -h 192.168.0.19 -u replica -psenha123 -- Ver erro detalhado: SHOW SLAVE STATUS\G -- Leia o campo: Last_IO_Error

❌ Can't connect to MySQL server

O bind-address provavelmente ainda é 127.0.0.1. Confirme que está 0.0.0.0 no my.ini e que o MySQL foi reiniciado.

❌ Replicação parou após erro SQL

-- Pular erro pontual e retomar: STOP SLAVE; SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1; START SLAVE;

❌ Versões diferentes do MySQL

Use no my.ini do Slave:

slave_type_conversions = ALL_NON_LOSSY

---

🚀 Conclusão

Sincronizar dois bancos MySQL em rede local tem mais de um caminho. Para quem está começando ou em ambiente de desenvolvimento, o MySQL Central Compartilhado resolve 90% dos casos sem nenhuma dor de cabeça. Se você precisa de redundância ou os dois computadores operam de forma independente (inclusive offline), a Replicação Master↔Master é a escolha certa. Para sistemas mais críticos e com suporte a desconexão, o SymmetricDS é o mais robusto.

Os métodos com Node.js são excelentes para equipes que preferem controlar a sincronização por código, e as Triggers + Federated Tables são uma solução elegante puramente dentro do MySQL, sem dependências externas.

O mais importante é entender o fluxo de gravação da sua aplicação: se apenas um PC grava, Master→Slave resolve. Se os dois precisam gravar, você precisa de bidirecional. E se não há necessidade real de dois bancos, um servidor central é sempre mais simples.

💡 Ficou com dúvida ou quer ver algum desses métodos em vídeo? Acesse o @CanalQb no YouTube e acompanhe os tutoriais práticos.

---

Entendendo o Contexto do Projeto

Projetos de cripto mudam regras, endpoints e elegibilidade com frequencia. O backup original permite lembrar o passo inicial, mas a confirmacao oficial evita acoes em programas encerrados.

Antes de repetir, consulte o comunicado oficial e o perfil verificado. Essa pratica reduz surpresas e protege seu fluxo.

Riscos Operacionais

Expor chaves, repetir acoes sem limite ou compartilhar dados sensiveis amplia risco sem aumentar retorno. Defina limites claros e armazene historicos organizados.

Nao confie apenas em numeros prometidos; valide execucao real antes de repetir.

Documentacao e Auditoria

Mantenha prints, logs e referencias organizados por post. Backup documentado vale mais do que repetir acoes sem memoria.

Fontes e Referencias

• Conteudo original
• Buscar no @CanalQb
• IAPP Global Privacy Directory

Nota Tecnica: Este post e estritamente informativo. Teste em ambiente controlado antes de repetir procedimentos.

Perguntas Frequentes

O que e Sincronizar MySQL XAMPP em Rede Local (Guia Completo)?

Sincronizar MySQL XAMPP em Rede Local (Guia Completo) traz contexto que deve ser validado no site oficial. Este modernizado preserva o backup do @CanalQb para reduzir perda de informacao.

Ainda e valido usar Sincronizar MySQL XAMPP em Rede Local (Guia Completo) em 2026?

O conteudo original e a base, mas regras e endpoints podem mudar. Verifique fontes atuais antes de executar.

Como aumentar resultado no Sincronizar MySQL XAMPP em Rede Local (Guia Completo)?

Consistencia supera spam. Aplique o passo original e confirme atualizacoes oficiais antes de escalar acoes.

Onde estao as fontes oficiais de Sincronizar MySQL XAMPP em Rede Local (Guia Completo)?

Use os dominios registrados neste post e priorize documentacao oficial, changelog ou comunicados.

Sincronizar MySQL XAMPP em Rede Local (Guia Completo) exige conhecimento previo?

Se parecer denso, comece por pre-requisitos e use o backup como apoio. Mantenha passos curtos e verificaveis.

Revisado em 2026-07-11

Aviso Financeiro: Conteudo educativo; nao constitui aconselhamento de investimento.

Gostou do conteudo? Inscreva-se no @CanalQb no YouTube e ative o sininho.

Feito com Master Rules Claude v8.6 - @CanalQb

Checklist de Execucao Segura

• Confirme o objetivo principal antes de repetir o roteiro.
• Valide o passo original com uma execucao de baixo risco.
• Registre resultado, tempo gasto e desvios encontrados.
• Se algo travar, reduza escopo ao trecho suspeito antes de refazer tudo.
• Compare saidas esperadas com saidas reais antes de seguir.

Erros Comuns e Como Evita-los

Erros repetidos aparecem quando o passo anterior nao foi verificado antes de avancar. Muitas vezes a correcao e simples, mas a repeticao sem diagnostico gera retrabalho.

Ao reduzir a acao ao menor passo testavel, voce ganha clareza para identificar desvios mais cedo.

Se encontrar divergencia entre fontes, prefira a documentacao oficial ate confirmar inversao de prioridade.

Documentacao e Continuidade

Registre mudancas data, causa e correcao aplicada. Esse habito reduz erros e acelera revisoes futuras.

Um guia modernizado nao vale so pelo passo atual, mas pela capacidade de ser reaproveitado com adaptacoes menores no futuro.