@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.
① 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.
Comentários
Comente só assim vamos crescer juntos!