Uma visão geral da replicação cruzada do PostgreSQL e MySQL

Antecedentes de pg_chameleon

Recursos do pg_chameleon

• Vários esquemas MySQL do mesmo cluster podem ser replicados para um único banco de dados PostgreSQL de destino, formando uma configuração de replicação de muitos para um
• Os nomes dos esquemas de origem e destino podem não ser idênticos
• Os dados de replicação podem ser extraídos da réplica em cascata do MySQL
• As tabelas que não conseguem replicar ou gerar erros são excluídas
• Cada funcionalidade de replicação é gerenciada com a ajuda de daemons
• Controlado com a ajuda de parâmetros e arquivos de configuração baseados na construção YAML

Demonstração

$> wget https://www.python.org/ftp/python/3.6.8/Python-3.6.8.tar.xz
$> tar -xJf Python-3.6.8.tar.xz
$> cd Python-3.6.8
$> ./configure --enable-optimizations
$> make altinstall

$> python3.6 -m venv venv
$> source venv/bin/activate
(venv) $> pip install pip --upgrade
(venv) $> pip install pg_chameleon==2.0.9

(venv) $> chameleon set_configuration_files
creating directory /root/.pg_chameleon
creating directory /root/.pg_chameleon/configuration/
creating directory /root/.pg_chameleon/logs/
creating directory /root/.pg_chameleon/pid/
copying configuration  example in /root/.pg_chameleon/configuration//config-example.yml

$> cat default.yml
---
#global settings
pid_dir: '~/.pg_chameleon/pid/'
log_dir: '~/.pg_chameleon/logs/'
log_dest: file
log_level: info
log_days_keep: 10
rollbar_key: ''
rollbar_env: ''

# type_override allows the user to override the default type conversion into a different one.
type_override:
  "tinyint(1)":
    override_to: boolean
    override_tables:
      - "*"

#postgres  destination connection
pg_conn:
  host: "192.168.56.106"
  port: "5433"
  user: "usr_replica"
  password: "pass123"
  database: "db_replica"
  charset: "utf8"

sources:
  mysql:
    db_conn:
      host: "192.168.56.102"
      port: "3306"
      user: "usr_replica"
      password: "pass123"
      charset: 'utf8'
      connect_timeout: 10
    schema_mappings:
      world_x: pgworld_x
    limit_tables:
#      - delphis_mediterranea.foo
    skip_tables:
#      - delphis_mediterranea.bar
    grant_select_to:
      - usr_readonly
    lock_timeout: "120s"
    my_server_id: 100
    replica_batch_size: 10000
    replay_max_rows: 10000
    batch_retention: '1 day'
    copy_max_memory: "300M"
    copy_mode: 'file'
    out_dir: /tmp
    sleep_loop: 1
    on_error_replay: continue
    on_error_read: continue
    auto_maintenance: "disabled"
    gtid_enable: No
    type: mysql
    skip_events:
      insert:
        - delphis_mediterranea.foo #skips inserts on the table delphis_mediterranea.foo
      delete:
        - delphis_mediterranea #skips deletes on schema delphis_mediterranea
      update:

mysql> CREATE USER usr_replica ;
mysql> SET PASSWORD FOR usr_replica='pass123';
mysql> GRANT ALL ON world_x.* TO 'usr_replica';
mysql> GRANT RELOAD ON *.* to 'usr_replica';
mysql> GRANT REPLICATION CLIENT ON *.* to 'usr_replica';
mysql> GRANT REPLICATION SLAVE ON *.* to 'usr_replica';
mysql> FLUSH PRIVILEGES;

postgres=# CREATE USER usr_replica WITH PASSWORD 'pass123';
CREATE ROLE
postgres=# CREATE DATABASE db_replica WITH OWNER usr_replica;
CREATE DATABASE

$> vi /etc/my.cnf
binlog_format= ROW
binlog_row_image=FULL
log-bin = mysql-bin
server-id = 1

$> mysql -u usr_replica -Ap'admin123' -h 192.168.56.102 -D world_x 

$> psql -p 5433 -U usr_replica -h 192.168.56.106 db_replica

$> chameleon create_replica_schema --debug
$> chameleon add_source --config default --source mysql --debug
$> chameleon init_replica --config default --source mysql --debug

$> chameleon start_replica --config default --source mysql 
output: Starting the replica process for source mysql

$> chameleon show_status --source mysql  
OUTPUT: 
  Source id  Source name    Type    Status    Consistent    Read lag    Last read    Replay lag    Last replay
-----------  -------------  ------  --------  ------------  ----------  -----------  ------------  -------------
          1  mysql          mysql   running   No            N/A                      N/A

== Schema mappings ==
Origin schema    Destination schema
---------------  --------------------
world_x          pgworld_x

== Replica status ==
---------------------  ---
Tables not replicated  0
Tables replicated      4
All tables             4
Last maintenance       N/A
Next maintenance       N/A
Replayed rows
Replayed DDL
Skipped rows
---------------------  ---
$> chameleon show_errors --config default 
output: There are no errors in the log

$>  ps -ef|grep chameleon
root       763     1  0 19:20 ?        00:00:00 /u01/media/mysql_samp_dbs/world_x-db/venv/bin/python3.6 /u01/media/mysq l_samp_dbs/world_x-db/venv/bin/chameleon start_replica --config default --source mysql
root       764   763  0 19:20 ?        00:00:01 /u01/media/mysql_samp_dbs/world_x-db/venv/bin/python3.6 /u01/media/mysq l_samp_dbs/world_x-db/venv/bin/chameleon start_replica --config default --source mysql
root       765   763  0 19:20 ?        00:00:00 /u01/media/mysql_samp_dbs/world_x-db/venv/bin/python3.6 /u01/media/mysq l_samp_dbs/world_x-db/venv/bin/chameleon start_replica --config default --source mysql

mysql> create table t1 (n1 int primary key, n2 varchar(10));
Query OK, 0 rows affected (0.01 sec)
mysql> insert into t1 values (1,'one');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t1 values (2,'two');
Query OK, 1 row affected (0.00 sec)

$> chameleon sync_tables --tables world_x.t1 --config default --source mysql
Sync tables process for source mysql started.

$> psql -p 5433 -U usr_replica -d db_replica -c "select * from pgworld_x.t1";
 n1 |  n2
----+-------
  1 | one
  2 | two

$> chameleon stop_replica --config default --source mysql 
$> chameleon detach_replica --config default --source mysql --debug

$> chameleon drop_source --config default --source mysql --debug
$> chameleon drop_replica_schema --config default --source mysql --debug

Prós do uso do pg_chameleon

• Configuração simples e menos complicada
• Solução de problemas e detecção de anomalias sem complicações com saída de erro fácil de entender
• Tabelas ad hoc adicionais podem ser adicionadas à replicação após a inicialização, sem alterar nenhuma outra configuração
• Várias fontes podem ser configuradas para um único banco de dados de destino, o que é útil em projetos de consolidação para mesclar dados de um ou mais bancos de dados MySQL em um único banco de dados PostgreSQL
• As tabelas selecionadas podem ser ignoradas da replicação

Contras do uso do pg_chameleon

• Suportado apenas a partir do MySQL 5.5 como banco de dados de origem e PostgreSQL 9.5 em diante para banco de dados de destino
• Requer que cada tabela tenha uma chave primária ou exclusiva, caso contrário, as tabelas serão inicializadas durante o processo init_replica, mas não serão replicadas
• Replicação unidirecional, ou seja, MySQL para PostgreSQL. Assim, limitando seu uso a apenas uma configuração ativa-passiva
• O banco de dados de origem só pode ser um banco de dados MySQL, enquanto o suporte ao banco de dados PostgreSQL como fonte é experimental com outras limitações (clique aqui para saber mais)

Resumo do pg_chameleon

Uma visão geral do SymmetricDS

Recursos do SymmetricDS

• Independente de plataforma, o que significa que dois ou mais bancos de dados diferentes podem se comunicar entre si, de qualquer banco de dados para qualquer outro banco de dados
• Bancos de dados relacionais obtêm sincronização usando captura de dados alterados, enquanto sistemas baseados em sistema de arquivos utilizam sincronização de arquivos
• Replicação bidirecional usando o método Push and Pull, que é realizado com base em regras definidas
• A transferência de dados também pode ocorrer em redes seguras e de baixa largura de banda
• Recuperação automática durante a retomada de um nó com falha e resolução automática de conflitos
• Pronto para a nuvem e contém APIs de extensão poderosas

Demonstração

• Um nó mestre (pai) que atua como um intermediário centralizado coordenando a replicação de dados entre dois nós escravos (filhos), em que a comunicação entre os dois nós filhos só pode ocorrer por meio do pai.
• Um nó ativo (node1) pode replicar de e para outro nó ativo (node2) sem qualquer intermediário.

corp-000.properties
store-001.properties
store-002.properties

$> cat engines/corp-000.properties
engine.name=corp-000
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://192.168.1.107:3306/replica_db?autoReconnect=true&useSSL=false
db.user=root
db.password=admin123
registration.url=
sync.url=http://192.168.1.107:31415/sync/corp-000
group.id=corp
external.id=000

$> cat engines/store-001.properties
engine.name=store-001
db.driver=org.postgresql.Driver
db.url=jdbc:postgresql://192.168.1.112:5832/pgdb_replica
db.user=postgres
db.password=admin123
registration.url=http://192.168.1.107:31415/sync/corp-000
group.id=store
external.id=001

vm1$> cd /usr/local/symmetric-server-3.9.20/bin
vm1$> ./dbimport --engine corp-000 --format XML create_sample.xml
vm1$> ./symadmin --engine corp-000 create-sym-tables
vm1$> ./dbimport --engine corp-000 insert_sample.sql

vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> ./dbimport --engine store-001 --format XML create_sample.xml

vm1$> cd /usr/local/symmetric-server-3.9.20/bin
vm1$> sym 2>&1 &

vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> sym 2>&1 &

vm1$> ./symadmin --engine corp-000 reload-node 001

mysql> insert into item values ('22000002','Jelly Bean');
Query OK, 1 row affected (0.00 sec)

vm2$> psql -p 5832 -U postgres pgdb_replica -c "select * from item" 
 item_id  |   name
----------+-----------
 11000001 | Yummy Gum
 22000002 | Jelly Bean
(2 rows)

pgdb_replica=# insert into "sale_transaction" ("tran_id", "store_id", "workstation", "day", "seq") values (1000, '001', '3', '2007-11-01', 100);
vm1$> [[email protected] ~]#  mysql -uroot -p'admin123' -D replica_db -e "select * from sale_transaction";
+---------+----------+-------------+------------+-----+
| tran_id | store_id | workstation | day        | seq |
+---------+----------+-------------+------------+-----+
|     900 | 001      | 3           | 2012-12-01 |  90 |
|    1000 | 001      | 3           | 2007-11-01 | 100 |
|    2000 | 002      | 2           | 2007-11-01 | 200 |
+---------+----------+-------------+------------+-----+

mysql> create table  t1 (no integer);
Query OK, 0 rows affected (0.01 sec)

mysql> insert into sym_channel (channel_id,create_time,last_update_time) 
values ('t1',current_timestamp,current_timestamp);
Query OK, 1 row affected (0.01 sec)

mysql> insert into sym_trigger (trigger_id, source_table_name,channel_id,
last_update_time, create_time) values ('t1', 't1', 't1', current_timestamp,
current_timestamp);
Query OK, 1 row affected (0.01 sec)

mysql> insert into sym_trigger_router (trigger_id, router_id,
Initial_load_order, create_time,last_update_time) values ('t1',
'corp-2-store-1', 1, current_timestamp,current_timestamp);
Query OK, 1 row affected (0.01 sec)

vm1$> ./symadmin -e corp-000 --node=001 sync-triggers    
vm1$> ./symadmin send-schema -e corp-000 --node=001 t1

Prós do uso do SymmetricDS

• Instalação e configuração sem esforço, incluindo um conjunto pré-configurado de arquivos de parâmetro para criar uma configuração de 3 ou 2 nós
• Banco de dados multiplataforma habilitado e independente de plataforma, incluindo servidores, laptops e dispositivos móveis
• Replicar qualquer banco de dados para qualquer outro banco de dados, seja local, WAN ou nuvem
• Capaz de manipular de forma otimizada alguns bancos de dados para vários milhares de bancos de dados para replicar dados perfeitamente
• Uma versão comercial do software oferece console de gerenciamento orientado por GUI com um excelente pacote de suporte

Desvantagens do uso do SymmetricDS

• A configuração manual da linha de comando pode envolver a definição de regras e direção de replicação por meio de instruções SQL para carregar tabelas de catálogo, o que pode ser inconveniente para gerenciar
• Configurar um grande número de tabelas para replicação será um esforço exaustivo, a menos que alguma forma de script seja utilizada para gerar as instruções SQL que definem as regras e a direção da replicação
• Muitas informações de log sobrecarregando o arquivo de log, exigindo manutenção periódica do arquivo de log para não permitir que o arquivo de log ocupe o disco

Resumo do SymmetricDS