Cross replication sa pagitan ng PostgreSQL at MySQL

Magbabalangkas ako ng cross-replication sa pagitan ng PostgreSQL at MySQL, pati na rin ang mga pamamaraan para sa pag-set up ng cross-replication sa pagitan ng dalawang database server. Karaniwan, ang mga cross-replicated database ay tinatawag na homogenous, at ito ay isang maginhawang paraan ng paglipat mula sa isang RDBMS server patungo sa isa pa.

Ang mga database ng PostgreSQL at MySQL ay karaniwang itinuturing na relational, ngunit may mga karagdagang extension na nag-aalok sila ng mga kakayahan sa NoSQL. Dito tatalakayin natin ang pagtitiklop sa pagitan ng PostgreSQL at MySQL mula sa isang relational na pananaw ng DBMS.

Hindi namin ilalarawan ang buong panloob na gawain, ang mga pangunahing prinsipyo lamang upang makakuha ka ng ideya ng pag-configure ng pagtitiklop sa pagitan ng mga server ng database, mga pakinabang, limitasyon at mga kaso ng paggamit.

Karaniwan, ang pagtitiklop sa pagitan ng dalawang magkatulad na server ng database ay ginagawa sa binary mode o gumagamit ng mga query sa pagitan ng master (a.k.a. publisher, master, o active) at isang slave (subscriber, standby, o passive). Ang layunin ng pagtitiklop ay magbigay ng real-time na kopya ng master database sa slave side. Sa kasong ito, ang data ay inililipat mula sa master hanggang sa alipin, iyon ay, mula sa aktibo hanggang sa passive, dahil ang pagtitiklop ay ginagawa lamang sa isang direksyon. Ngunit maaari kang mag-set up ng pagtitiklop sa pagitan ng dalawang database sa magkabilang direksyon, upang mailipat ang data mula sa alipin patungo sa master sa isang aktibong-aktibong pagsasaayos. Ang lahat ng ito, kabilang ang cascading replication, ay posible sa pagitan ng dalawa o higit pang magkatulad na mga server ng database. Ang aktibong-aktibo o aktibong-passive na configuration ay nakasalalay sa pangangailangan, pagkakaroon ng mga ganoong kakayahan sa paunang pagsasaayos o paggamit ng mga panlabas na solusyon sa pagsasaayos at umiiral na mga trade-off .

Ang inilarawan na pagsasaayos ay posible sa pagitan ng iba't ibang mga server ng database. Maaaring i-configure ang server upang tanggapin ang kinopya na data mula sa isa pang database server at mapanatili pa rin ang mga real-time na snapshot ng kinopya na data. Ang MySQL at PostgreSQL ay nag-aalok ng karamihan sa mga pagsasaayos na ito sa loob o sa pamamagitan ng mga extension ng third-party, kabilang ang mga binary log method, disk locking, at statement- at row-based na mga pamamaraan.

Ang cross replication sa pagitan ng MySQL at PostgreSQL ay kailangan para sa isang beses na paglipat mula sa isang database server patungo sa isa pa. Gumagamit ang mga database na ito ng iba't ibang protocol, kaya hindi posibleng direktang i-link ang mga ito. Upang magtatag ng palitan ng data, maaari kang gumamit ng panlabas na open source na tool, halimbawa pg_chameleon.

Ano ang pg_chameleon

Ang pg_chameleon ay isang replication system mula sa MySQL hanggang sa PostgreSQL sa Python 3. Ginagamit nito ang open source mysql-replication library, pati na rin sa Python. Ang mga larawan ng hilera ay kinukuha mula sa mga talahanayan ng MySQL at iniimbak bilang mga bagay na JSONB sa database ng PostgreSQL, at pagkatapos ay i-decrypt ng pl/pgsql function at muling ginawa sa database ng PostgreSQL.

Mga tampok ng pg_chameleon

Maramihang MySQL schema mula sa parehong cluster ay maaaring kopyahin sa isang solong target na PostgreSQL database sa isang one-to-many configuration
Ang mga pangalan ng pinagmulan at target na schema ay hindi maaaring magkapareho.
Maaaring makuha ang data ng pagtitiklop mula sa isang cascaded MySQL replica.
Ang mga talahanayan na hindi maaaring kopyahin o makagawa ng mga error ay hindi kasama.
Ang bawat replication function ay kinokontrol ng mga daemon.
Kontrol sa pamamagitan ng YAML-based na mga parameter at configuration file.

Halimbawa

Host
vm1
vm2

bersyon ng OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

Bersyon ng DB server
MySQL 5.7.26
PostgreSQL 10.5

DB port
3306
5433

IP address
192.168.56.102
192.168.56.106

Upang magsimula, ihanda ang lahat ng kinakailangang sangkap upang mai-install ang pg_chameleon. Ang halimbawang ito ay nag-i-install ng Python 3.6.8, na lumilikha at nagpapagana sa virtual na kapaligiran.

$> 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

Pagkatapos ng matagumpay na pag-install ng Python3.6, kailangan mong kumpletuhin ang natitirang mga kinakailangan, tulad ng paggawa at pag-activate ng virtual na kapaligiran. Bukod pa rito, ang pip module ay ina-update sa pinakabagong bersyon at ginagamit upang i-install ang pg_chameleon. Ang mga utos sa ibaba ay sadyang nag-install ng pg_chameleon 2.0.9, bagama't ang pinakabagong bersyon ay 2.0.10. Ito ay kinakailangan upang maiwasan ang mga bagong bug sa na-update na bersyon.

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

Pagkatapos ay tinawag namin ang pg_chameleon (ang chameleon ay isang command) gamit ang set_configuration_files argument upang paganahin ang pg_chameleon at lumikha ng mga default na direktoryo at configuration file.

(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

Ngayon gumawa kami ng kopya ng config-example.yml bilang default.yml upang ito ay maging default na configuration file. Ang isang sample na configuration file para sa halimbawang ito ay ibinigay sa ibaba.

$> 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:

Ang configuration file sa halimbawang ito ay isang sample na pg_chameleon file na may maliliit na pagbabago upang umangkop sa pinagmulan at target na kapaligiran, at sa ibaba ay isang pangkalahatang-ideya ng iba't ibang mga seksyon ng configuration file.

Sa default.yml configuration file mayroong isang seksyon ng mga pandaigdigang setting, kung saan maaari mong pamahalaan ang mga setting tulad ng lokasyon ng lock file, ang lokasyon ng mga log, ang panahon ng imbakan para sa mga log, atbp. Susunod ay ang type override section, kung saan isang hanay ng mga panuntunan para sa mga overriding na uri sa panahon ng pagtitiklop. Nagde-default ang halimbawa sa isang uri ng overriding na panuntunan na nagko-convert ng tinyint(1) sa isang boolean na halaga. Sa susunod na seksyon, tinukoy namin ang mga detalye ng koneksyon sa target na database. Sa aming kaso, ito ay isang database ng PostgreSQL, na itinalagang pg_conn. Sa huling seksyon, ipinapahiwatig namin ang source data, iyon ay, ang mga parameter ng koneksyon ng source database, ang mapping scheme sa pagitan ng source at target na database, mga talahanayan na kailangang laktawan, oras ng paghihintay, memorya, laki ng package. Tandaan na ang "sources" ay maramihan, ibig sabihin, maaari tayong magdagdag ng maramihang source database sa iisang target na database para mag-set up ng marami-sa-isang configuration.

Ang halimbawang database world_x ay naglalaman ng 4 na talahanayan na may mga hilera na inaalok ng komunidad ng MySQL bilang mga halimbawa. Maaari itong i-download dito. Ang sample na database ay dumating bilang isang tar at naka-compress na archive na may mga tagubilin para sa paggawa at pag-import ng mga row.

Sa MySQL at PostgreSQL database, isang espesyal na user ang nilikha na may parehong pangalan na usr_replica. Sa MySQL, binibigyan ito ng karagdagang mga karapatan sa pagbabasa sa lahat ng mga replicated na talahanayan.

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;

Sa panig ng PostgreSQL, isang db_replica database ang nilikha na tatanggap ng mga pagbabago mula sa MySQL database. Ang user na usr_replica sa PostgreSQL ay awtomatikong na-configure bilang may-ari ng dalawang schema, pgworld_x at sch_chameleon, na naglalaman ng aktwal na mga replicated na talahanayan at ang mga replication directory table, ayon sa pagkakabanggit. Ang argument na create_replica_schema ay responsable para sa awtomatikong pagsasaayos, tulad ng makikita mo sa ibaba.

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

Ang MySQL database ay na-configure na may ilang mga pagbabago sa parameter upang ihanda ito para sa pagtitiklop tulad ng ipinapakita sa ibaba. Kakailanganin mong i-restart ang database server para magkabisa ang mga pagbabago.

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

Ngayon ay mahalaga na suriin ang koneksyon sa parehong mga server ng database upang walang mga problema kapag pinapatakbo ang mga pg_chameleon command.

Sa PostgreSQL node:

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

Sa MySQL node:

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

Ang susunod na tatlong pg_chameleon (chameleon) na utos ay naghahanda ng kapaligiran, idagdag ang pinagmulan, at simulan ang replica. Ang create_replica_schema argument sa pg_chameleon ay lumilikha ng default na schema (sch_chameleon) at isang replication schema (pgworld_x) sa PostgreSQL database, gaya ng napag-usapan na natin. Ang add_source argument ay nagdaragdag ng source database sa configuration sa pamamagitan ng pagbabasa ng configuration file (default.yml), at sa aming kaso ito ay mysql, at init_replica ang nagpapasimula ng configuration batay sa mga parameter sa configuration file.

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

Ang output ng tatlong utos na ito ay malinaw na nagpapahiwatig na sila ay matagumpay na naisakatuparan. Ang anumang mga pag-crash o mga error sa syntax ay iniuulat sa simple, malinaw na mga mensahe na may mga pahiwatig kung paano ayusin ang problema.

Sa wakas, sinisimulan namin ang pagtitiklop gamit ang start_replica at tumanggap ng mensahe ng tagumpay.

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

Maaaring i-query ang status ng pagtitiklop gamit ang argumento ng show_status, at maaaring tingnan ang mga error gamit ang argumento ng show_errors.

Resulta.

Gaya ng nasabi na natin, ang bawat replication function ay kinokontrol ng mga daemon. Upang tingnan ang mga ito, itatanong namin ang talahanayan ng proseso gamit ang Linux ps command, tulad ng ipinapakita sa ibaba.

Resulta.

Ang pagtitiklop ay hindi itinuturing na na-configure hanggang sa masubukan namin ito sa real time, tulad ng ipinapakita sa ibaba. Gumagawa kami ng table, nagpasok ng ilang record sa MySQL database, at tumawag sa sync_tables argument sa pg_chameleon para i-update ang mga daemon at kopyahin ang table na may mga record sa PostgreSQL database.

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.

Upang kumpirmahin ang mga resulta ng pagsubok, itatanong namin ang talahanayan mula sa database ng PostgreSQL at i-output ang mga hilera.

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

Kung gagawa tayo ng migration, ang mga sumusunod na pg_chameleon command ang magiging katapusan nito. Ang mga utos ay kailangang maisakatuparan pagkatapos nating matiyak na ang mga hilera ng lahat ng mga target na talahanayan ay na-replicate, at ang resulta ay isang maayos na inilipat na PostgreSQL database nang walang mga sanggunian sa source database o replication scheme (sch_chameleon).

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

Kung nais, maaari mong gamitin ang sumusunod na mga utos upang tanggalin ang orihinal na pagsasaayos at pamamaraan ng pagtitiklop.

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

Mga kalamangan ng pg_chameleon

Madaling pag-setup at pagsasaayos.
Madaling i-troubleshoot at tukuyin ang mga anomalya na may malinaw na mga mensahe ng error.
Maaaring magdagdag ng mga karagdagang espesyal na talahanayan sa pagtitiklop pagkatapos ng pagsisimula nang hindi binabago ang natitirang configuration.
Posibleng i-configure ang maramihang source database para sa isang target na database, at ito ay lubhang kapaki-pakinabang kung pinagsasama-sama mo ang data mula sa isa o higit pang MySQL database sa iisang PostgreSQL database.
Hindi mo kailangang kopyahin ang mga napiling talahanayan.

Mga disadvantages ng pg_chameleon

Sinusuportahan lamang ng MySQL 5.5 at mas mataas bilang source at PostgreSQL 9.5 at mas mataas bilang target na database.
Ang bawat talahanayan ay dapat na may pangunahin o natatanging susi, kung hindi, ang mga talahanayan ay sinisimulan sa panahon ng proseso ng init_replica ngunit hindi ginagaya.
One-way replication - mula lamang sa MySQL hanggang PostgreSQL. Samakatuwid, ito ay angkop lamang para sa "aktibong-passive" na circuit.
Ang pinagmulan ay maaari lamang maging isang database ng MySQL, at ang suporta para sa isang database ng PostgreSQL bilang isang mapagkukunan ay pang-eksperimento lamang at may mga limitasyon (matuto nang higit pa dito)

Mga resulta para sa pg_chameleon

Ang paraan ng pagtitiklop sa pg_chameleon ay mahusay para sa paglipat ng isang database mula sa MySQL patungo sa PostgreSQL. Ang makabuluhang downside ay ang pagtitiklop ay isang paraan lamang, kaya ang mga propesyonal sa database ay malamang na hindi nais na gamitin ito para sa anumang bagay maliban sa paglipat. Ngunit ang problema ng one-way na pagtitiklop ay maaaring malutas sa isa pang open source tool - SymmetricDS.

Magbasa nang higit pa sa opisyal na dokumentasyon dito. Matatagpuan ang tulong sa command line dito.

Pangkalahatang-ideya ng SymmetricDS

Ang SymmetricDS ay isang open source tool na kinokopya ang anumang database sa anumang iba pang karaniwang database: Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird at iba pang mga instance ng cloud database, hal. Redshift, at Azure, atbp. Magagamit na mga tampok: database at file synchronization, multi-master database replication, na-filter na synchronization, pagbabago at iba pa. Isa itong Java tool at nangangailangan ng karaniwang release ng JRE o JDK (bersyon 8.0 o mas mataas). Dito, ang mga pagbabago sa data sa mga trigger sa source database ay maaaring itala at ipadala sa naaangkop na target na database sa anyo ng mga batch.

Mga tampok ng SymmetricDS

Ang tool ay independyente sa platform, ibig sabihin, dalawa o higit pang magkakaibang database ang maaaring magpalitan ng data.
Ang mga relational database ay naka-synchronize gamit ang data change records, habang ang mga file system-based na database ay gumagamit ng file synchronization.
Dalawang-daan na pagtitiklop gamit ang mga paraan ng Push at Pull batay sa isang hanay ng mga panuntunan.
Posible ang paglipat ng data sa mga secure at mababang bandwidth na network.
Awtomatikong pagbawi kapag nagpatuloy ang operasyon ng mga node pagkatapos ng pagkabigo at awtomatikong paglutas ng salungatan.
Cloud compatible at malakas na extension API.

Halimbawa

Maaaring i-configure ang SymmetricDS sa isa sa dalawang paraan:
Isang master (magulang) na node na sentral na nagkoordina ng pagtitiklop ng data sa pagitan ng dalawang node ng alipin (bata), at ang komunikasyon sa pagitan ng mga child node ay nangyayari lamang sa pamamagitan ng magulang.
Ang isang aktibong node (Node 1) ay maaaring makipag-ugnayan para sa pagtitiklop sa isa pang aktibong node (Node 2) nang walang tagapamagitan.

Sa parehong mga opsyon, nangyayari ang pagpapalitan ng data gamit ang Push at Pull. Sa halimbawang ito isasaalang-alang namin ang isang aktibong-aktibong pagsasaayos. Masyadong mahaba upang ilarawan ang buong arkitektura, kaya gawin ang iyong pananaliksik. pamumunoupang matuto nang higit pa tungkol sa SymmetricDS device.

Ang pag-install ng SymmetricDS ay napakasimple: i-download ang open source na bersyon ng zip file kaya at ilabas ito kung saan mo gusto. Ang talahanayan sa ibaba ay nagbibigay ng impormasyon tungkol sa lokasyon ng pag-install at bersyon ng SymmetricDS sa halimbawang ito, pati na rin ang mga bersyon ng database, mga bersyon ng Linux, mga IP address, at mga port para sa parehong mga node.

Host
vm1
vm2

bersyon ng OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

Bersyon ng DB server
MySQL 5.7.26
PostgreSQL 10.5

DB port
3306
5832

IP address
192.168.1.107
192.168.1.112

SymmetricDS na bersyon
SymmetricDS 3.9
SymmetricDS 3.9

path ng pag-install ng SymmetricDS
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

Pangalan ng SymmetricDS node
corp-000
tindahan-001

Dito namin ini-install ang SymmetricDS sa /usr/local/symmetric-server-3.9.20, at iba't ibang mga subdirectory at file ang maiimbak doon. Interesado kami sa mga sample at subdirectory ng engine. Ang direktoryo ng mga sample ay naglalaman ng mga halimbawang configuration file na may mga katangian ng node, pati na rin ang mga halimbawang SQL script upang makapagsimula ka nang mabilis.

Sa direktoryo ng mga sample nakikita namin ang tatlong mga file ng pagsasaayos na may mga katangian ng node - ipinapakita ng pangalan ang likas na katangian ng node sa isang tiyak na pamamaraan.

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

Nasa SymmetricDS ang lahat ng kinakailangang configuration file para sa isang pangunahing 3-node na disenyo (opsyon 1), at ang parehong mga file ay maaaring gamitin para sa isang 2-node na disenyo (opsyon 2). Kopyahin ang kinakailangang configuration file mula sa samples directory papunta sa mga engine sa vm1 host. Ito ay lumalabas na ganito:

$> 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

Ang node na ito sa configuration ng SymmetricDS ay tinatawag na corp-000, at ang database connection ay pinangangasiwaan ng mysql jdbc driver, na gumagamit ng connection string sa itaas at ang mga kredensyal sa pag-log in. Kumokonekta kami sa replica_db database at ang mga talahanayan ay gagawin sa panahon ng paggawa ng schema. Ipinapakita ng sync.url kung saan kokontakin ang node para sa pag-synchronize.

Ang node 2 sa host vm2 ay naka-configure bilang store-001 at ang iba ay tinukoy sa node.properties file sa ibaba. Ang Node store-001 ay nagpapatakbo ng PostgreSQL database at ang pgdb_replica ay ang replication database. Ang registration.url ay nagbibigay-daan sa host vm2 na makipag-ugnayan sa host vm1 at makatanggap ng mga detalye ng configuration mula dito.

$> 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

Ang nakumpletong halimbawa ng SymmetricDS ay naglalaman ng mga parameter para sa pag-set up ng two-way replication sa pagitan ng dalawang database server (dalawang node). Ang mga hakbang sa ibaba ay ginagawa sa host vm1 (corp-000), na gagawa ng isang halimbawang schema na may 4 na talahanayan. Pagkatapos, ang pagpapatakbo ng create-sym-tables gamit ang symadmin command ay lumilikha ng mga talahanayan ng direktoryo kung saan ang mga panuntunan at direksyon ng pagtitiklop sa pagitan ng mga node ay iimbak. Sa wakas, ang sample na data ay na-load sa mga talahanayan.

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

Sa halimbawa, ang mga talahanayan ng item at item_selling_price ay awtomatikong na-configure upang kopyahin mula sa corp-000 hanggang sa store-001, at ang mga talahanayan ng pagbebenta (sale_transaction at sale_return_line_item) ay awtomatikong na-configure upang kopyahin mula sa store-001 hanggang corp-000. Ngayon ay gumagawa kami ng schema sa PostgreSQL database sa host vm2 (store-001) para ihanda ito sa pagtanggap ng data mula sa corp-000.

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

Siguraduhing suriin na ang MySQL database sa vm1 ay may mga halimbawang talahanayan at SymmetricDS catalog table. Tandaan na ang SymmetricDS system tables (prefixed with sym_) ay kasalukuyang available lang sa node corp-000 dahil doon namin pinatakbo ang create-sym-tables na command at pamamahalaan ang replication. At sa database sa node store-001 magkakaroon lamang ng 4 na halimbawang mga talahanayan na walang data.

Lahat. Ang kapaligiran ay handa nang magpatakbo ng mga proseso ng sym server sa parehong mga node tulad ng ipinapakita sa ibaba.

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

Ang mga log entry ay ipinapadala sa isang background log file (symmetric.log) sa logs folder sa direktoryo kung saan naka-install ang SymmetricDS, gayundin sa karaniwang output. Ang sym server ay maaari na ngayong simulan sa node store-001.

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

Kung patakbuhin mo ang proseso ng sym server sa vm2 host, lilikha din ito ng mga talahanayan ng SymmetricDS catalog sa database ng PostgreSQL. Kung pinapatakbo mo ang proseso ng sym server sa parehong mga node, nakikipag-ugnayan sila sa isa't isa upang kopyahin ang data mula sa corp-000 hanggang sa store-001. Kung pagkatapos ng ilang segundo itatanong namin ang lahat ng 4 na talahanayan sa magkabilang panig, makikita namin na matagumpay ang pagtitiklop. O maaari mong ipadala ang bootstrap sa node store-001 mula sa corp-000 gamit ang sumusunod na command.

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

Sa puntong ito, isang bagong tala ang ipinapasok sa talahanayan ng item sa database ng MySQL sa node corp-000 (host: vm1), at maaari mong suriin ang pagtitiklop nito sa database ng PostgreSQL sa node store-001 (host: vm2). Nakikita namin ang isang Pull operation upang ilipat ang data mula sa corp-000 patungo sa store-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)

Upang magsagawa ng Push operation upang ilipat ang data mula sa store-001 patungo sa corp-000, maglalagay kami ng tala sa talahanayan ng sale_transaction at i-verify na matagumpay ang pagtitiklop.

Resulta.

Nakikita namin ang matagumpay na pag-setup ng two-way replication ng mga halimbawang talahanayan sa pagitan ng MySQL at PostgreSQL database. Upang mag-set up ng pagtitiklop para sa mga bagong talahanayan ng user, sundin ang mga hakbang na ito: Lumilikha kami ng talahanayan t1 halimbawa at i-configure ang mga panuntunan sa pagtitiklop nito bilang mga sumusunod. Sa ganitong paraan, iko-configure lang namin ang replikasyon mula sa corp-000 hanggang store-001.

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)

Ang pagsasaayos ay pagkatapos ay aabisuhan tungkol sa pagbabago ng schema, iyon ay, ang pagdaragdag ng isang bagong talahanayan, gamit ang utos ng symadmin na may argumento ng sync-trigger, na muling nililikha ang mga trigger upang imapa ang mga kahulugan ng talahanayan. Ang send-schema ay isinasagawa upang magpadala ng mga pagbabago sa schema sa node store-001, at ang pagtitiklop ng talahanayan t1 ay na-configure.

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

Mga Pakinabang ng SymmetricDS

Madaling pag-install at pagsasaayos, kabilang ang isang handa na hanay ng mga file na may mga parameter para sa paglikha ng isang three-node o two-node circuit.
Mga cross-platform na database at platform independence, kabilang ang mga server, laptop at mobile device.
Ginagaya ang anumang database sa anumang iba pang database nang lokal, sa WAN o sa cloud.
Posibilidad ng pinakamainam na trabaho sa isang pares ng mga database o ilang libo para sa maginhawang pagtitiklop.
Bayad na bersyon na may GUI at mahusay na suporta.

Mga Kakulangan ng SymmetricDS

Kailangan mong manu-manong tukuyin ang mga panuntunan at direksyon ng pagtitiklop sa command line sa pamamagitan ng mga SQL statement upang mai-load ang mga talahanayan ng catalog, na maaaring hindi maginhawa.
Ang pag-set up ng maraming talahanayan para sa pagtitiklop ay maaaring nakakapagod maliban kung gagamit ka ng mga script upang lumikha ng mga SQL statement na tumutukoy sa mga panuntunan at direksyon ng pagtitiklop.
Napakaraming impormasyon ang naitala sa mga log, at kung minsan kailangan mong ayusin ang log file upang hindi ito tumagal ng masyadong maraming espasyo.

Mga resulta para sa SymmetricDS

Binibigyang-daan ka ng SymmetricDS na mag-set up ng two-way na pagtitiklop sa pagitan ng dalawa, tatlo, o kahit ilang libong node upang kopyahin at i-synchronize ang mga file. Ito ay isang natatanging tool na independiyenteng gumaganap ng maraming gawain, tulad ng awtomatikong pagbawi ng data pagkatapos ng mahabang panahon ng downtime sa isang node, secure at mahusay na pagpapalitan ng data sa pagitan ng mga node sa pamamagitan ng HTTPS, awtomatikong pamamahala ng salungatan batay sa isang hanay ng mga panuntunan, atbp. Ang SymmetricDS ay gumaganap replikasyon sa pagitan ng anumang mga database, samakatuwid, maaari itong magamit para sa isang malawak na iba't ibang mga sitwasyon, kabilang ang paglipat, paglipat, pamamahagi, pag-filter, at pagbabago ng data sa mga platform.

Ang halimbawa ay batay sa opisyal mabilis na gabay ng SymmetricDS. SA manwal ng gumagamit Inilalarawan nang detalyado ang iba't ibang konseptong kasangkot sa pag-set up ng replikasyon gamit ang SymmetricDS.

Pinagmulan: www.habr.com