ການຈໍາລອງແບບຂ້າມລະຫວ່າງ PostgreSQL ແລະ MySQL

ຂ້ອຍຈະອະທິບາຍການຈໍາລອງແບບຂ້າມລະຫວ່າງ PostgreSQL ແລະ MySQL, ເຊັ່ນດຽວກັນກັບວິທີການສ້າງການຈໍາລອງແບບຂ້າມລະຫວ່າງສອງເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນ. ໂດຍປົກກະຕິ, ຖານຂໍ້ມູນທີ່ຖືກຈໍາລອງແບບຂ້າມແມ່ນເອີ້ນວ່າ homogeneous, ແລະມັນເປັນວິທີທີ່ສະດວກໃນການເຄື່ອນຍ້າຍຈາກເຄື່ອງແມ່ຂ່າຍ RDBMS ຫນຶ່ງໄປຫາອື່ນ.

ຖານຂໍ້ມູນ PostgreSQL ແລະ MySQL ໂດຍທົ່ວໄປແມ່ນຖືວ່າມີຄວາມກ່ຽວຂ້ອງ, ແຕ່ດ້ວຍການຂະຫຍາຍເພີ່ມເຕີມພວກເຂົາສະເຫນີຄວາມສາມາດ NoSQL. ໃນທີ່ນີ້ພວກເຮົາຈະປຶກສາຫາລືການຈໍາລອງລະຫວ່າງ PostgreSQL ແລະ MySQL ຈາກທັດສະນະ DBMS ທີ່ກ່ຽວຂ້ອງ.

ພວກເຮົາຈະບໍ່ອະທິບາຍການເຮັດວຽກພາຍໃນທັງຫມົດ, ພຽງແຕ່ຫຼັກການພື້ນຖານເພື່ອໃຫ້ທ່ານໄດ້ຮັບຄວາມຄິດຂອງການຕັ້ງຄ່າການຈໍາລອງລະຫວ່າງເຄື່ອງແມ່ຂ່າຍຂອງຖານຂໍ້ມູນ, ຂໍ້ດີ, ຂໍ້ຈໍາກັດແລະກໍລະນີການນໍາໃຊ້.

ໂດຍປົກກະຕິ, ການຈໍາລອງລະຫວ່າງສອງເຊີບເວີຖານຂໍ້ມູນທີ່ຄືກັນແມ່ນເຮັດຢູ່ໃນໂຫມດຖານສອງຫຼືໃຊ້ການສອບຖາມລະຫວ່າງແມ່ບົດ (ຜູ້ເຜີຍແຜ່, ແມ່ບົດ, ຫຼືເຮັດວຽກ) ແລະທາດ (ຜູ້ຈອງ, ສະແຕນບາຍ, ຫຼືຕົວຕັ້ງຕົວຕີ). ຈຸດປະສົງຂອງການຈໍາລອງແມ່ນເພື່ອສະຫນອງການສໍາເນົາໃນເວລາທີ່ແທ້ຈິງຂອງຖານຂໍ້ມູນຕົ້ນສະບັບໃນດ້ານສໍາລອງ. ໃນກໍລະນີນີ້, ຂໍ້ມູນຖືກໂອນຈາກແມ່ແບບໄປຫາສໍາລອງ, ນັ້ນແມ່ນ, ຈາກການເຄື່ອນໄຫວໄປສູ່ຕົວຕັ້ງຕົວຕີ, ເພາະວ່າການຈໍາລອງແມ່ນປະຕິບັດໃນທິດທາງດຽວເທົ່ານັ້ນ. ແຕ່ທ່ານສາມາດຕັ້ງຄ່າ replication ລະຫວ່າງສອງຖານຂໍ້ມູນໃນທັງສອງທິດທາງ, ດັ່ງນັ້ນຂໍ້ມູນໄດ້ຖືກໂອນຈາກ slave ກັບແມ່ບົດໃນການຕັ້ງຄ່າທີ່ມີການເຄື່ອນໄຫວ. ທັງຫມົດນີ້, ລວມທັງການຈໍາລອງແບບ cascading, ແມ່ນເປັນໄປໄດ້ລະຫວ່າງເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນສອງຫຼືຫຼາຍກວ່ານັ້ນການຕັ້ງຄ່າ Active-active ຫຼື active-passive ແມ່ນຂຶ້ນກັບຄວາມຕ້ອງການ, ຄວາມພ້ອມຂອງຄວາມສາມາດດັ່ງກ່າວໃນການຕັ້ງຄ່າເບື້ອງຕົ້ນຫຼືການນໍາໃຊ້ການແກ້ໄຂການຕັ້ງຄ່າພາຍນອກແລະການຄ້າທີ່ມີຢູ່.

ການຕັ້ງຄ່າທີ່ອະທິບາຍແມ່ນເປັນໄປໄດ້ລະຫວ່າງເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນທີ່ແຕກຕ່າງກັນ. ເຊີບເວີສາມາດຖືກຕັ້ງຄ່າໃຫ້ຍອມຮັບຂໍ້ມູນທີ່ຈຳລອງຈາກເຊີບເວີຖານຂໍ້ມູນອື່ນ ແລະຍັງຮັກສາການຖ່າຍພາບແບບສົດໆຂອງຂໍ້ມູນທີ່ສຳເນົາໄວ້. MySQL ແລະ PostgreSQL ສະເຫນີການຕັ້ງຄ່າເຫຼົ່ານີ້ສ່ວນໃຫຍ່ຢູ່ໃນເຮືອນຫຼືໂດຍຜ່ານສ່ວນຂະຫຍາຍຂອງພາກສ່ວນທີສາມ, ລວມທັງວິທີການບັນທຶກຄູ່, ການລັອກແຜ່ນ, ແລະວິທີການທີ່ອີງໃສ່ແຖວ.

ການຈໍາລອງແບບຂ້າມລະຫວ່າງ MySQL ແລະ PostgreSQL ແມ່ນຈໍາເປັນສໍາລັບການຍົກຍ້າຍຫນຶ່ງຄັ້ງຈາກເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນຫນຶ່ງໄປຫາອື່ນ. ຖານຂໍ້ມູນເຫຼົ່ານີ້ໃຊ້ໂປໂຕຄອນທີ່ແຕກຕ່າງກັນ, ດັ່ງນັ້ນມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະເຊື່ອມໂຍງພວກມັນໂດຍກົງ. ເພື່ອສ້າງການແລກປ່ຽນຂໍ້ມູນ, ທ່ານສາມາດນໍາໃຊ້ເຄື່ອງມືແຫຼ່ງເປີດພາຍນອກ, ຕົວຢ່າງ pg_chameleon.

pg_chameleon ແມ່ນຫຍັງ

pg_chameleon ແມ່ນລະບົບການຈໍາລອງຈາກ MySQL ກັບ PostgreSQL ໃນ Python 3. ມັນໃຊ້ຫ້ອງສະຫມຸດ mysql-replication ແຫຼ່ງເປີດ, ຍັງຢູ່ໃນ Python. ຮູບພາບແຖວຖືກສະກັດອອກຈາກຕາຕະລາງ MySQL ແລະເກັບໄວ້ເປັນວັດຖຸ JSONB ໃນຖານຂໍ້ມູນ PostgreSQL, ແລະຫຼັງຈາກນັ້ນຖອດລະຫັດໂດຍຟັງຊັນ pl/pgsql ແລະຜະລິດຄືນໃຫມ່ໃນຖານຂໍ້ມູນ PostgreSQL.

ຄຸນນະສົມບັດຂອງ pg_chameleon

schemas MySQL ຫຼາຍອັນຈາກກຸ່ມດຽວກັນສາມາດ replicated ກັບຖານຂໍ້ມູນ PostgreSQL ເປົ້າຫມາຍດຽວໃນການຕັ້ງຄ່າຫນຶ່ງຫາຫຼາຍ.
ຊື່ schema ທີ່ມາ ແລະເປົ້າໝາຍບໍ່ສາມາດຄືກັນໄດ້.
ຂໍ້ມູນການຈໍາລອງສາມາດດຶງມາຈາກການຈໍາລອງ MySQL ແບບ cascaded.
ຕາຕະລາງທີ່ບໍ່ສາມາດເຮັດເລື້ມຄືນຫຼືສ້າງຄວາມຜິດພາດແມ່ນໄດ້ຖືກຍົກເວັ້ນ.
ແຕ່ລະຫນ້າທີ່ການຈໍາລອງຖືກຄວບຄຸມໂດຍ daemon.
ຄວບຄຸມຜ່ານຕົວກໍານົດການທີ່ອີງໃສ່ YAML ແລະໄຟລ໌ການຕັ້ງຄ່າ.

ຕົວຢ່າງ:

ເຈົ້າພາບ
vm1
vm2

ລຸ້ນ OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

DB ເວີຊັ່ນເຊີບເວີ
MySQL 5.7.26
PostgreSQL 10.5

ພອດ DB
3306
5433

ທີ່ຢູ່ IP
192.168.56.102
192.168.56.106

ເພື່ອເລີ່ມຕົ້ນ, ກະກຽມອົງປະກອບທີ່ຈໍາເປັນທັງຫມົດເພື່ອຕິດຕັ້ງ pg_chameleon. ຕົວຢ່າງນີ້ຕິດຕັ້ງ Python 3.6.8, ເຊິ່ງສ້າງແລະເປີດໃຊ້ສະພາບແວດລ້ອມ virtual.

$> 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 ສໍາເລັດແລ້ວ, ທ່ານຈໍາເປັນຕ້ອງເຮັດສໍາເລັດຄວາມຕ້ອງການທີ່ຍັງເຫຼືອ, ເຊັ່ນ: ການສ້າງແລະເປີດໃຊ້ສະພາບແວດລ້ອມ virtual. ນອກຈາກນັ້ນ, ໂມດູນ pip ໄດ້ຖືກປັບປຸງເປັນສະບັບຫລ້າສຸດແລະຖືກນໍາໃຊ້ເພື່ອຕິດຕັ້ງ pg_chameleon. ຄໍາສັ່ງຂ້າງລຸ່ມນີ້ຕັ້ງໃຈຕິດຕັ້ງ pg_chameleon 2.0.9, ເຖິງແມ່ນວ່າສະບັບຫລ້າສຸດແມ່ນ 2.0.10. ນີ້ເປັນສິ່ງຈໍາເປັນເພື່ອຫຼີກເວັ້ນການແມງໄມ້ໃຫມ່ໃນສະບັບປັບປຸງ.

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

ຫຼັງຈາກນັ້ນ, ພວກເຮົາໂທຫາ pg_chameleon (chameleon ແມ່ນຄໍາສັ່ງ) ດ້ວຍການໂຕ້ຖຽງ set_configuration_files ເພື່ອເປີດໃຊ້ pg_chameleon ແລະສ້າງໄດເລກະທໍລີເລີ່ມຕົ້ນແລະໄຟລ໌ການຕັ້ງຄ່າ.

(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

ຕອນນີ້ພວກເຮົາສ້າງສຳເນົາຂອງ config-example.yml ເປັນ default.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:

ໄຟລ໌ການຕັ້ງຄ່າໃນຕົວຢ່າງນີ້ແມ່ນໄຟລ໌ pg_chameleon ຕົວຢ່າງທີ່ມີການດັດແກ້ເລັກນ້ອຍເພື່ອໃຫ້ເຫມາະສົມກັບແຫຼ່ງແລະສະພາບແວດລ້ອມເປົ້າຫມາຍ, ແລະຂ້າງລຸ່ມນີ້ແມ່ນພາບລວມຂອງສ່ວນຕ່າງໆຂອງໄຟລ໌ການຕັ້ງຄ່າ.

ໃນໄຟລ໌ການຕັ້ງຄ່າ default.yml ມີພາກສ່ວນຂອງການຕັ້ງຄ່າທົ່ວໂລກ, ບ່ອນທີ່ທ່ານສາມາດຈັດການການຕັ້ງຄ່າເຊັ່ນ: ສະຖານທີ່ຂອງໄຟລ໌ລັອກ, ສະຖານທີ່ຂອງບັນທຶກ, ໄລຍະເວລາການເກັບຮັກສາສໍາລັບບັນທຶກ, ແລະອື່ນໆ. ຕໍ່ໄປແມ່ນພາກສ່ວນ override ປະເພດ, ບ່ອນທີ່ ຊຸດຂອງກົດລະບຽບສໍາລັບການ overriding ປະເພດໃນລະຫວ່າງການ replication. ຕົວຢ່າງຄ່າເລີ່ມຕົ້ນເປັນປະເພດກົດລະບຽບການ overriding ທີ່ປ່ຽນ tinyint(1) ເປັນຄ່າ boolean. ໃນພາກຕໍ່ໄປ, ພວກເຮົາກໍານົດລາຍລະອຽດການເຊື່ອມຕໍ່ກັບຖານຂໍ້ມູນເປົ້າຫມາຍ. ໃນກໍລະນີຂອງພວກເຮົາ, ນີ້ແມ່ນຖານຂໍ້ມູນ PostgreSQL, ກໍານົດ pg_conn. ໃນພາກສຸດທ້າຍ, ພວກເຮົາຊີ້ບອກຂໍ້ມູນແຫຼ່ງ, ນັ້ນແມ່ນ, ຕົວກໍານົດການເຊື່ອມຕໍ່ຂອງຖານຂໍ້ມູນແຫຼ່ງ, ໂຄງການສ້າງແຜນທີ່ລະຫວ່າງຖານຂໍ້ມູນແຫຼ່ງແລະເປົ້າຫມາຍ, ຕາຕະລາງທີ່ຕ້ອງການຂ້າມ, ເວລາລໍຖ້າ, ຫນ່ວຍຄວາມຈໍາ, ຂະຫນາດຊຸດ. ໃຫ້ສັງເກດວ່າ "ແຫຼ່ງ" ແມ່ນຫຼາຍ, ຊຶ່ງຫມາຍຄວາມວ່າພວກເຮົາສາມາດເພີ່ມຖານຂໍ້ມູນແຫຼ່ງຫຼາຍໄປຫາຖານຂໍ້ມູນເປົ້າຫມາຍດຽວເພື່ອກໍານົດການຕັ້ງຄ່າຫຼາຍຕໍ່ຫນຶ່ງ.

ຕົວຢ່າງຖານຂໍ້ມູນ world_x ມີ 4 ຕາຕະລາງທີ່ມີແຖວທີ່ຊຸມຊົນ MySQL ສະເຫນີເປັນຕົວຢ່າງ. ມັນສາມາດດາວໂຫຼດໄດ້ ທີ່ນີ້. ຖານຂໍ້ມູນຕົວຢ່າງມາເປັນ tar ແລະ compressed archive ກັບຄໍາແນະນໍາສໍາລັບການສ້າງແລະນໍາເຂົ້າແຖວ.

ໃນຖານຂໍ້ມູນ MySQL ແລະ PostgreSQL, ຜູ້ໃຊ້ພິເສດແມ່ນຖືກສ້າງຂຶ້ນດ້ວຍຊື່ດຽວກັນ usr_replica. ໃນ MySQL, ມັນໄດ້ຖືກມອບໃຫ້ສິດອ່ານເພີ່ມເຕີມຕໍ່ກັບຕາຕະລາງທີ່ເຮັດສໍາເນົາທັງຫມົດ.

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;

ໃນດ້ານ PostgreSQL, ຖານຂໍ້ມູນ db_replica ຖືກສ້າງຂື້ນທີ່ຈະຍອມຮັບການປ່ຽນແປງຈາກຖານຂໍ້ມູນ MySQL. ຜູ້ໃຊ້ usr_replica ໃນ PostgreSQL ໄດ້ຖືກຕັ້ງຄ່າໂດຍອັດຕະໂນມັດເປັນເຈົ້າຂອງສອງ schemas, pgworld_x ແລະ sch_chameleon, ເຊິ່ງປະກອບດ້ວຍຕາຕະລາງການຈໍາລອງຕົວຈິງແລະຕາຕະລາງການຈໍາລອງແບບຈໍາລອງຕາມລໍາດັບ. ການໂຕ້ຖຽງ create_replica_schema ແມ່ນຮັບຜິດຊອບສໍາລັບການຕັ້ງຄ່າອັດຕະໂນມັດ, ດັ່ງທີ່ທ່ານຈະເຫັນຂ້າງລຸ່ມນີ້.

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

ຖານຂໍ້ມູນ MySQL ຖືກຕັ້ງຄ່າດ້ວຍການປ່ຽນແປງພາລາມິເຕີບາງຢ່າງເພື່ອກະກຽມມັນສໍາລັບການຈໍາລອງດັ່ງທີ່ສະແດງຂ້າງລຸ່ມນີ້. ທ່ານຈະຕ້ອງປິດເປີດເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນຄືນໃໝ່ເພື່ອໃຫ້ການປ່ຽນແປງມີຜົນ.

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

ໃນປັດຈຸບັນມັນເປັນສິ່ງສໍາຄັນທີ່ຈະກວດສອບການເຊື່ອມຕໍ່ກັບເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນທັງສອງເພື່ອບໍ່ໃຫ້ມີບັນຫາໃນເວລາທີ່ແລ່ນຄໍາສັ່ງ pg_chameleon.

ຢູ່ໃນໂຫມດ PostgreSQL:

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

ໃນ MySQL node:

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

ສາມຄໍາສັ່ງ pg_chameleon (chameleon) ຕໍ່ໄປກະກຽມສະພາບແວດລ້ອມ, ເພີ່ມແຫຼ່ງ, ແລະເລີ່ມຕົ້ນການຈໍາລອງ. ການໂຕ້ຖຽງ create_replica_schema ກັບ pg_chameleon ສ້າງ schema ເລີ່ມຕົ້ນ (sch_chameleon) ແລະ schema replication (pgworld_x) ໃນຖານຂໍ້ມູນ PostgreSQL, ດັ່ງທີ່ພວກເຮົາໄດ້ສົນທະນາແລ້ວ. ການໂຕ້ຖຽງ add_source ເພີ່ມຖານຂໍ້ມູນແຫຼ່ງໃຫ້ກັບການຕັ້ງຄ່າໂດຍການອ່ານໄຟລ໌ການຕັ້ງຄ່າ (default.yml), ແລະໃນກໍລະນີຂອງພວກເຮົາມັນແມ່ນ mysql, ແລະ init_replica ເລີ່ມຕົ້ນການຕັ້ງຄ່າໂດຍອີງໃສ່ພາລາມິເຕີໃນໄຟລ໌ການຕັ້ງຄ່າ.

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

ຜົນໄດ້ຮັບຂອງສາມຄໍາສັ່ງເຫຼົ່ານີ້ຊີ້ໃຫ້ເຫັນຢ່າງຊັດເຈນວ່າພວກເຂົາຖືກປະຕິບັດຢ່າງສໍາເລັດຜົນ. ການຂັດຂ້ອງ ຫຼືຂໍ້ຜິດພາດຂອງໄວຍະກອນຈະຖືກລາຍງານໃນຂໍ້ຄວາມທີ່ງ່າຍດາຍ, ຈະແຈ້ງພ້ອມກັບຄຳແນະນຳກ່ຽວກັບວິທີແກ້ໄຂບັນຫາ.

ສຸດທ້າຍ, ພວກເຮົາເລີ່ມການຈໍາລອງໂດຍໃຊ້ start_replica ແລະໄດ້ຮັບຂໍ້ຄວາມສໍາເລັດ.

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

ສະຖານະການຈໍາລອງສາມາດສອບຖາມໄດ້ໂດຍໃຊ້ show_status argument, ແລະສາມາດເບິ່ງຂໍ້ຜິດພາດໄດ້ໂດຍໃຊ້ show_errors argument.

ຜົນໄດ້ຮັບ.

ດັ່ງທີ່ພວກເຮົາໄດ້ກ່າວແລ້ວ, ແຕ່ລະຫນ້າທີ່ການຈໍາລອງຖືກຄວບຄຸມໂດຍ daemon. ເພື່ອເບິ່ງພວກມັນ, ພວກເຮົາສອບຖາມຕາຕະລາງຂະບວນການດ້ວຍຄໍາສັ່ງ Linux ps, ດັ່ງທີ່ສະແດງຂ້າງລຸ່ມນີ້.

ຜົນໄດ້ຮັບ.

Replication ບໍ່ໄດ້ຖືກພິຈາລະນາ configured ຈົນກ່ວາພວກເຮົາທົດສອບມັນໃນເວລາທີ່ແທ້ຈິງ, ດັ່ງທີ່ສະແດງຂ້າງລຸ່ມນີ້. ພວກເຮົາສ້າງຕາຕະລາງ, ໃສ່ສອງສາມບັນທຶກເຂົ້າໄປໃນຖານຂໍ້ມູນ MySQL, ແລະໂທຫາ sync_tables argument ໃນ pg_chameleon ເພື່ອປັບປຸງ daemons ແລະ replicate ຕາຕະລາງທີ່ມີບັນທຶກກັບຖານຂໍ້ມູນ PostgreSQL.

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.

ເພື່ອຢືນຢັນຜົນການທົດສອບ, ພວກເຮົາສອບຖາມຕາຕະລາງຈາກຖານຂໍ້ມູນ PostgreSQL ແລະອອກແຖວ.

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

ຖ້າພວກເຮົາກໍາລັງເຮັດການເຄື່ອນຍ້າຍ, ຄໍາສັ່ງ pg_chameleon ຕໍ່ໄປນີ້ຈະເປັນຈຸດສິ້ນສຸດຂອງມັນ. ຄໍາສັ່ງຕ້ອງໄດ້ຮັບການປະຕິບັດຫຼັງຈາກທີ່ພວກເຮົາແນ່ໃຈວ່າແຖວຂອງຕາຕະລາງເປົ້າຫມາຍທັງຫມົດໄດ້ຖືກ replicated, ແລະຜົນໄດ້ຮັບຈະເປັນຖານຂໍ້ມູນ PostgreSQL ທີ່ຖືກຍົກຍ້າຍຢ່າງລະມັດລະວັງໂດຍບໍ່ມີການອ້າງອີງເຖິງຖານຂໍ້ມູນແຫຼ່ງຫຼືໂຄງການ replication (sch_chameleon).

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

ຂໍ້ໄດ້ປຽບຂອງ pg_chameleon

ການ​ຕັ້ງ​ຄ່າ​ງ່າຍ​ແລະ​ການ​ຕັ້ງ​ຄ່າ​.
ແກ້ໄຂບັນຫາໄດ້ງ່າຍແລະກໍານົດຄວາມຜິດປົກກະຕິດ້ວຍຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດທີ່ຊັດເຈນ.
ຕາຕະລາງພິເສດເພີ່ມເຕີມສາມາດຖືກເພີ່ມເຂົ້າໃນການຈໍາລອງຫຼັງຈາກການເລີ່ມຕົ້ນໂດຍບໍ່ຈໍາເປັນຕ້ອງມີການປ່ຽນແປງສ່ວນທີ່ເຫຼືອຂອງການຕັ້ງຄ່າ.
ມັນເປັນໄປໄດ້ທີ່ຈະກໍາຫນົດຄ່າຖານຂໍ້ມູນຫຼາຍແຫຼ່ງສໍາລັບຖານຂໍ້ມູນເປົ້າຫມາຍດຽວ, ແລະນີ້ເປັນປະໂຫຍດຫຼາຍຖ້າຫາກວ່າທ່ານກໍາລັງສົມທົບຂໍ້ມູນຈາກຖານຂໍ້ມູນ MySQL ຫນຶ່ງຫຼືຫຼາຍເຂົ້າໄປໃນຖານຂໍ້ມູນ PostgreSQL ດຽວ.
ທ່ານບໍ່ ຈຳ ເປັນຕ້ອງເຮັດເລື້ມຄືນຕາຕະລາງທີ່ເລືອກ.

ຂໍ້ເສຍຂອງ pg_chameleon

ສະ​ຫນັບ​ສະ​ຫນູນ​ພຽງ​ແຕ່​ກັບ MySQL 5.5 ແລະ​ຂ້າງ​ເທິງ​ເປັນ​ແຫຼ່ງ​ແລະ PostgreSQL 9.5 ແລະ​ຂ້າງ​ເທິງ​ເປັນ​ຖານ​ຂໍ້​ມູນ​ເປົ້າ​ຫມາຍ​.
ແຕ່ລະຕາຕະລາງຕ້ອງມີລະຫັດຕົ້ນຕໍຫຼືເປັນເອກະລັກ, ຖ້າບໍ່ດັ່ງນັ້ນ, ຕາຕະລາງຈະຖືກເລີ່ມຕົ້ນໃນລະຫວ່າງຂະບວນການ init_replica ແຕ່ບໍ່ໄດ້ເຮັດຊ້ໍາກັນ.
ການຈໍາລອງແບບທາງດຽວ - ພຽງແຕ່ຈາກ MySQL ຫາ PostgreSQL. ດັ່ງນັ້ນ, ມັນເຫມາະສົມສໍາລັບວົງຈອນ "active-passive" ເທົ່ານັ້ນ.
ແຫຼ່ງຂໍ້ມູນສາມາດເປັນຖານຂໍ້ມູນ MySQL ເທົ່ານັ້ນ, ແລະການຮອງຮັບຖານຂໍ້ມູນ PostgreSQL ເປັນແຫຼ່ງພຽງແຕ່ການທົດລອງແລະມີຂໍ້ຈໍາກັດ (ຮຽນຮູ້ເພີ່ມເຕີມ ທີ່ນີ້)

ຜົນການຄົ້ນຫາສໍາລັບ pg_chameleon

ວິທີການຈໍາລອງໃນ pg_chameleon ແມ່ນດີເລີດສໍາລັບການຍ້າຍຖານຂໍ້ມູນຈາກ MySQL ໄປ PostgreSQL. ການຫຼຸດລົງທີ່ສໍາຄັນແມ່ນວ່າການຈໍາລອງແມ່ນພຽງແຕ່ວິທີດຽວ, ດັ່ງນັ້ນຜູ້ຊ່ຽວຊານດ້ານຖານຂໍ້ມູນບໍ່ຫນ້າຈະຕ້ອງການທີ່ຈະໃຊ້ມັນສໍາລັບສິ່ງອື່ນນອກເຫນືອຈາກການເຄື່ອນຍ້າຍ. ແຕ່ບັນຫາຂອງການຈໍາລອງແບບດຽວສາມາດແກ້ໄຂໄດ້ດ້ວຍເຄື່ອງມືແຫຼ່ງເປີດອື່ນ - SymmetricDS.

ອ່ານເພີ່ມເຕີມໃນເອກະສານທາງການ ທີ່ນີ້. ການຊ່ວຍເຫຼືອເສັ້ນຄໍາສັ່ງສາມາດພົບໄດ້ ທີ່ນີ້.

ພາບລວມຂອງ SymmetricDS

SymmetricDS ເປັນເຄື່ອງມືແຫຼ່ງເປີດທີ່ replicates ຖານຂໍ້ມູນໃດໆກັບຖານຂໍ້ມູນທົ່ວໄປອື່ນໆ: Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird ແລະຕົວຢ່າງຖານຂໍ້ມູນຟັງອື່ນໆ, e.g. Redshift, ແລະ Azure, ແລະອື່ນໆ ຄຸນນະສົມບັດທີ່ມີຢູ່: ຖານຂໍ້ມູນແລະໄຟລ໌ synchronization, multi-master database replication, filtered synchronization, transformation ແລະອື່ນໆ. ນີ້ແມ່ນເຄື່ອງມື Java ແລະຮຽກຮ້ອງໃຫ້ມີການປ່ອຍມາດຕະຖານຂອງ JRE ຫຼື JDK (ຮຸ່ນ 8.0 ຫຼືສູງກວ່າ). ທີ່ນີ້, ຂໍ້ມູນການປ່ຽນແປງຜົນກະທົບຕໍ່ໃນຖານຂໍ້ມູນແຫຼ່ງສາມາດຖືກບັນທຶກແລະຖືກສົ່ງໄປຫາຖານຂໍ້ມູນເປົ້າຫມາຍທີ່ເຫມາະສົມໃນຮູບແບບຂອງ batches.

ລັກສະນະ SymmetricDS

ເຄື່ອງມືແມ່ນເວທີເອກະລາດ, ຊຶ່ງຫມາຍຄວາມວ່າສອງຫຼືຫຼາຍກວ່າຖານຂໍ້ມູນທີ່ແຕກຕ່າງກັນສາມາດແລກປ່ຽນຂໍ້ມູນ.
ຖານຂໍ້ມູນທີ່ກ່ຽວຂ້ອງຖືກ synchronized ໂດຍໃຊ້ບັນທຶກການປ່ຽນແປງຂໍ້ມູນ, ໃນຂະນະທີ່ຖານຂໍ້ມູນລະບົບໄຟລ໌ໃຊ້ synchronization ໄຟລ໌.
ການຈໍາລອງແບບສອງທາງໂດຍໃຊ້ວິທີການ Push ແລະ Pull ໂດຍອີງໃສ່ກົດລະບຽບທີ່ກໍານົດໄວ້.
ການໂອນຂໍ້ມູນແມ່ນເປັນໄປໄດ້ຜ່ານເຄືອຂ່າຍຄວາມປອດໄພ ແລະ ແບນວິດຕໍ່າ.
ການຟື້ນຕົວອັດຕະໂນມັດເມື່ອ nodes ດໍາເນີນການຕໍ່ຫຼັງຈາກຄວາມລົ້ມເຫຼວແລະການແກ້ໄຂຂໍ້ຂັດແຍ່ງອັດຕະໂນມັດ.
Cloud ທີ່ເຂົ້າກັນໄດ້ ແລະ APIs ສ່ວນຂະຫຍາຍທີ່ມີປະສິດທິພາບ.

ຕົວຢ່າງ:

SymmetricDS ສາມາດຖືກຕັ້ງຄ່າໃນຫນຶ່ງໃນສອງວິທີ:
ແມ່ບົດ (ພໍ່ແມ່) node ທີ່ປະສານງານສູນກາງການຈໍາລອງຂໍ້ມູນລະຫວ່າງສອງ slave (child) nodes, ແລະການສື່ສານລະຫວ່າງ node ຂອງເດັກນ້ອຍເກີດຂຶ້ນໂດຍຜ່ານພໍ່ແມ່ເທົ່ານັ້ນ.
node ທີ່ໃຊ້ວຽກ (Node 1) ສາມາດຕິດຕໍ່ສື່ສານສໍາລັບການຈໍາລອງກັບ node ອື່ນທີ່ໃຊ້ວຽກ (Node 2) ໂດຍບໍ່ມີຕົວກາງ.

ໃນທັງສອງທາງເລືອກ, ການແລກປ່ຽນຂໍ້ມູນເກີດຂື້ນໂດຍໃຊ້ Push ແລະ Pull. ໃນຕົວຢ່າງນີ້ພວກເຮົາຈະພິຈາລະນາການຕັ້ງຄ່າທີ່ມີການເຄື່ອນໄຫວ. ມັນຈະໃຊ້ເວລາດົນເກີນໄປທີ່ຈະອະທິບາຍສະຖາປັດຕະຍະກໍາທັງຫມົດ, ສະນັ້ນເຮັດການຄົ້ນຄວ້າຂອງທ່ານ. ຄູ່ມືເພື່ອຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບອຸປະກອນ SymmetricDS.

ການຕິດຕັ້ງ SymmetricDS ແມ່ນງ່າຍດາຍຫຼາຍ: ດາວໂຫລດເວີຊັນເປີດຂອງໄຟລ໌ zip ຈາກນີ້ ແລະເອົາມັນອອກໄປບ່ອນໃດກໍ່ຕາມທີ່ທ່ານຕ້ອງການ. ຕາຕະລາງຂ້າງລຸ່ມນີ້ສະຫນອງຂໍ້ມູນກ່ຽວກັບສະຖານທີ່ຕິດຕັ້ງແລະສະບັບຂອງ SymmetricDS ໃນຕົວຢ່າງນີ້, ເຊັ່ນດຽວກັນກັບສະບັບຖານຂໍ້ມູນ, ສະບັບ Linux, ທີ່ຢູ່ IP, ແລະພອດສໍາລັບທັງສອງ nodes.

ເຈົ້າພາບ
vm1
vm2

ລຸ້ນ OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

DB ເວີຊັ່ນເຊີບເວີ
MySQL 5.7.26
PostgreSQL 10.5

ພອດ DB
3306
5832

ທີ່ຢູ່ IP
192.168.1.107
192.168.1.112

ລຸ້ນ SymmetricDS
SymmetricDS 3.9
SymmetricDS 3.9

ເສັ້ນທາງການຕິດຕັ້ງ SymmetricDS
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

ຊື່ SymmetricDS node
Corp-000
ຮ້ານ-001

ໃນທີ່ນີ້ພວກເຮົາຕິດຕັ້ງ SymmetricDS ໃນ /usr/local/symmetric-server-3.9.20, ແລະໄດເລກະທໍລີຍ່ອຍຕ່າງໆແລະໄຟລ໌ຈະຖືກເກັບໄວ້ຢູ່ທີ່ນັ້ນ. ພວກເຮົາມີຄວາມສົນໃຈໃນຕົວຊີ້ບອກຍ່ອຍຂອງເຄື່ອງຈັກແລະຕົວຢ່າງ. ໄດເລກະທໍລີຕົວຢ່າງມີໄຟລ໌ການຕັ້ງຄ່າຕົວຢ່າງທີ່ມີຄຸນສົມບັດຂອງ node, ເຊັ່ນດຽວກັນກັບຕົວຢ່າງ SQL scripts ເພື່ອເຮັດໃຫ້ທ່ານເລີ່ມຕົ້ນຢ່າງໄວວາ.

ໃນບັນຊີຕົວຢ່າງພວກເຮົາເຫັນສາມໄຟລ໌ການຕັ້ງຄ່າທີ່ມີຄຸນສົມບັດຂອງ node - ຊື່ສະແດງໃຫ້ເຫັນລັກສະນະຂອງ node ໃນໂຄງການສະເພາະໃດຫນຶ່ງ.

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

SymmetricDS ມີໄຟລ໌ການຕັ້ງຄ່າທີ່ຈໍາເປັນທັງຫມົດສໍາລັບການອອກແບບ 3-node ພື້ນຖານ (ທາງເລືອກ 1), ແລະໄຟລ໌ດຽວກັນສາມາດຖືກນໍາໃຊ້ສໍາລັບການອອກແບບ 2-node (ທາງເລືອກ 2). ຄັດລອກໄຟລ໌ການຕັ້ງຄ່າທີ່ຕ້ອງການຈາກໄດເລກະທໍລີຕົວຢ່າງໄປຫາເຄື່ອງຈັກໃນໂຮດ vm1. ມັນ​ໄດ້​ກາຍ​ເປັນ​ດັ່ງ​ນີ້​:

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

node ໃນ SymmetricDS configuration ເອີ້ນວ່າ corp-000, ແລະການເຊື່ອມຕໍ່ຖານຂໍ້ມູນແມ່ນຈັດການໂດຍໄດເວີ mysql jdbc, ເຊິ່ງໃຊ້ສາຍເຊື່ອມຕໍ່ຂ້າງເທິງແລະຂໍ້ມູນການເຂົ້າສູ່ລະບົບ. ພວກເຮົາເຊື່ອມຕໍ່ກັບຖານຂໍ້ມູນ replica_db ແລະຕາຕະລາງຈະຖືກສ້າງຂື້ນໃນລະຫວ່າງການສ້າງ schema. sync.url ສະແດງບ່ອນທີ່ຈະຕິດຕໍ່ກັບ node ສໍາລັບການ synchronization.

Node 2 ໃນ host vm2 ຖືກຕັ້ງຄ່າເປັນ store-001 ແລະສ່ວນທີ່ເຫຼືອແມ່ນລະບຸໄວ້ໃນໄຟລ໌ node.properties ຂ້າງລຸ່ມນີ້. Node store-001 ແລ່ນຖານຂໍ້ມູນ PostgreSQL ແລະ pgdb_replica ແມ່ນຖານຂໍ້ມູນ replication. register.url ອະນຸຍາດໃຫ້ໂຮສ vm2 ຕິດຕໍ່ກັບເຈົ້າພາບ vm1 ແລະໄດ້ຮັບລາຍລະອຽດການຕັ້ງຄ່າຈາກມັນ.

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

ຕົວຢ່າງ SymmetricDS ທີ່ສໍາເລັດມີພາລາມິເຕີສໍາລັບການຕັ້ງຄ່າການຈໍາລອງແບບສອງທາງລະຫວ່າງສອງເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນ (ສອງໂຫນດ). ຂັ້ນຕອນຂ້າງລຸ່ມນີ້ແມ່ນປະຕິບັດໃນ host vm1 (corp-000), ເຊິ່ງຈະສ້າງ schema ຕົວຢ່າງທີ່ມີ 4 ຕາຕະລາງ. ຫຼັງຈາກນັ້ນ, ແລ່ນ create-sym-tables ດ້ວຍຄໍາສັ່ງ symadmin ສ້າງຕາຕະລາງໄດເລກະທໍລີທີ່ກົດລະບຽບແລະທິດທາງຂອງການຈໍາລອງລະຫວ່າງ nodes ຈະຖືກເກັບໄວ້. ສຸດທ້າຍ, ຂໍ້ມູນຕົວຢ່າງຖືກໂຫລດເຂົ້າໄປໃນຕາຕະລາງ.

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

ໃນຕົວຢ່າງ, ລາຍການແລະຕາຕະລາງ item_selling_price ໄດ້ຖືກຕັ້ງຄ່າອັດຕະໂນມັດເພື່ອ replicate ຈາກ corp-000 ກັບ store-001, ແລະຕາຕະລາງການຂາຍ (sale_transaction ແລະ sale_return_line_item) ໄດ້ຖືກຕັ້ງຄ່າອັດຕະໂນມັດເພື່ອ replicate ຈາກ store-001 ຫາ corp-000. ໃນປັດຈຸບັນພວກເຮົາສ້າງ schema ໃນຖານຂໍ້ມູນ PostgreSQL ໃນ host vm2 (store-001) ເພື່ອກະກຽມມັນເພື່ອຮັບຂໍ້ມູນຈາກ corp-000.

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

ໃຫ້ແນ່ໃຈວ່າກວດເບິ່ງວ່າຖານຂໍ້ມູນ MySQL ໃນ vm1 ມີຕາຕະລາງຕົວຢ່າງແລະຕາຕະລາງຕາຕະລາງ SymmetricDS. ໃຫ້ສັງເກດວ່າຕາຕະລາງລະບົບ SymmetricDS (ນໍາຫນ້າດ້ວຍ sym_) ປະຈຸບັນມີພຽງແຕ່ຢູ່ໃນ node corp-000 ເພາະວ່ານັ້ນແມ່ນບ່ອນທີ່ພວກເຮົາດໍາເນີນການຄໍາສັ່ງ create-sym-tables ແລະຈະຈັດການການຈໍາລອງ. ແລະໃນຖານຂໍ້ມູນໃນ node store-001 ຈະມີພຽງ 4 ຕາຕະລາງຕົວຢ່າງທີ່ບໍ່ມີຂໍ້ມູນ.

ທັງໝົດ. ສະພາບແວດລ້ອມແມ່ນພ້ອມທີ່ຈະດໍາເນີນການຂະບວນການເຊີຟເວີ sym ໃນທັງສອງ nodes ດັ່ງທີ່ສະແດງຂ້າງລຸ່ມນີ້.

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

ລາຍການບັນທຶກຖືກສົ່ງໄປຫາໄຟລ໌ບັນທຶກພື້ນຫຼັງ (symmetric.log) ໃນໂຟນເດີບັນທຶກໃນໄດເລກະທໍລີທີ່ SymmetricDS ຖືກຕິດຕັ້ງ, ເຊັ່ນດຽວກັນກັບຜົນຜະລິດມາດຕະຖານ. ຕອນນີ້ເຊີບເວີ sym ສາມາດເລີ່ມຕົ້ນໄດ້ໃນ node store-001.

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

ຖ້າທ່ານດໍາເນີນການຂະບວນການເຊີຟເວີ sym ໃນໂຮດ vm2, ມັນຍັງຈະສ້າງຕາຕະລາງລາຍການ SymmetricDS ໃນຖານຂໍ້ມູນ PostgreSQL. ຖ້າທ່ານດໍາເນີນການຂະບວນການເຊີຟເວີ sym ໃນທັງສອງ nodes, ພວກເຂົາປະສານງານກັບກັນແລະກັນເພື່ອ replicate ຂໍ້ມູນຈາກ corp-000 ກັບ store-001. ຖ້າຫຼັງຈາກສອງສາມວິນາທີທີ່ພວກເຮົາສອບຖາມທັງຫມົດ 4 ຕາຕະລາງທັງສອງດ້ານ, ພວກເຮົາຈະເຫັນວ່າການຈໍາລອງໄດ້ປະສົບຜົນສໍາເລັດ. ຫຼືທ່ານສາມາດສົ່ງ bootstrap ໄປຫາ node store-001 ຈາກ corp-000 ດ້ວຍຄໍາສັ່ງຕໍ່ໄປນີ້.

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

ໃນຈຸດນີ້, ບັນທຶກໃຫມ່ຖືກໃສ່ເຂົ້າໄປໃນຕາຕະລາງລາຍການໃນຖານຂໍ້ມູນ MySQL ໃນ node corp-000 (host: vm1), ແລະທ່ານສາມາດກວດເບິ່ງການຈໍາລອງຂອງມັນກັບຖານຂໍ້ມູນ PostgreSQL ໃນ node store-001 (host: vm2). ພວກເຮົາເຫັນການດໍາເນີນງານ Pull ເພື່ອຍ້າຍຂໍ້ມູນຈາກ corp-000 ໄປ 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)

ເພື່ອດໍາເນີນການ Push ເພື່ອຍ້າຍຂໍ້ມູນຈາກ store-001 ໄປ corp-000, ພວກເຮົາໃສ່ບັນທຶກເຂົ້າໄປໃນຕາຕະລາງ sale_transaction ແລະກວດສອບວ່າການຈໍາລອງແມ່ນສໍາເລັດ.

ຜົນໄດ້ຮັບ.

ພວກເຮົາເຫັນການຕິດຕັ້ງສົບຜົນສໍາເລັດຂອງການຈໍາລອງແບບສອງທາງຂອງຕາຕະລາງຕົວຢ່າງລະຫວ່າງຖານຂໍ້ມູນ MySQL ແລະ PostgreSQL. ເພື່ອຕັ້ງຄ່າການຈໍາລອງສໍາລັບຕາຕະລາງຜູ້ໃຊ້ໃຫມ່, ປະຕິບັດຕາມຂັ້ນຕອນເຫຼົ່ານີ້: ພວກເຮົາສ້າງຕາຕະລາງ t1 ຕົວຢ່າງແລະກໍານົດກົດລະບຽບການຈໍາລອງຂອງມັນດັ່ງຕໍ່ໄປນີ້. ດ້ວຍວິທີນີ້, ພວກເຮົາກໍານົດພຽງແຕ່ replication ຈາກ corp-000 ຫາ 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)

ຫຼັງຈາກນັ້ນ, ການຕັ້ງຄ່າໄດ້ຖືກແຈ້ງໃຫ້ຊາບກ່ຽວກັບການປ່ຽນແປງຂອງ schema, ນັ້ນແມ່ນ, ການເພີ່ມຕາຕະລາງໃຫມ່, ໂດຍໃຊ້ຄໍາສັ່ງ symadmin ກັບການໂຕ້ຖຽງ sync-triggers, ເຊິ່ງສ້າງ triggers ເພື່ອສ້າງແຜນທີ່ກໍານົດຄໍານິຍາມຂອງຕາຕະລາງ. send-schema ຖືກປະຕິບັດເພື່ອສົ່ງການປ່ຽນແປງ schema ໄປຫາ node store-001, ແລະການຈໍາລອງຂອງຕາຕະລາງ t1 ໄດ້ຖືກຕັ້ງຄ່າ.

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

ຜົນປະໂຫຍດຂອງ SymmetricDS

ການຕິດຕັ້ງແລະການຕັ້ງຄ່າງ່າຍ, ລວມທັງຊຸດໄຟລ໌ທີ່ກຽມພ້ອມທີ່ມີພາລາມິເຕີສໍາລັບການສ້າງວົງຈອນສາມໂຫນດຫຼືສອງໂຫນດ.
ຖານຂໍ້ມູນຂ້າມເວທີ ແລະຄວາມເປັນເອກະລາດຂອງເວທີ, ລວມທັງເຊີບເວີ, ແລັບທັອບ ແລະອຸປະກອນມືຖື.
Replicate ຖານຂໍ້ມູນໃດໆກັບຖານຂໍ້ມູນອື່ນໆຢູ່ໃນທ້ອງຖິ່ນ, ໃນ WAN ຫຼືໃນຄລາວ.
ຄວາມເປັນໄປໄດ້ຂອງການເຮັດວຽກທີ່ດີທີ່ສຸດກັບສອງສາມຖານຂໍ້ມູນຫຼືຫຼາຍພັນສໍາລັບການຈໍາລອງທີ່ສະດວກ.
ສະບັບຈ່າຍດ້ວຍ GUI ແລະສະຫນັບສະຫນູນທີ່ດີເລີດ.

ຂໍ້ເສຍຂອງ SymmetricDS

ທ່ານຈໍາເປັນຕ້ອງກໍານົດກົດລະບຽບແລະທິດທາງຂອງ replication ດ້ວຍຕົນເອງໃນເສັ້ນຄໍາສັ່ງໂດຍຜ່ານຄໍາສັ່ງ SQL ເພື່ອໂຫລດຕາຕະລາງລາຍການ, ເຊິ່ງອາດຈະບໍ່ສະດວກ.
ການຕັ້ງຄ່າຕາຕະລາງຈໍານວນຫຼາຍສໍາລັບການຈໍາລອງສາມາດເປັນຫນ້າເບື່ອເວັ້ນເສຍແຕ່ວ່າທ່ານໃຊ້ສະຄິບເພື່ອສ້າງຄໍາຖະແຫຼງ SQL ທີ່ກໍານົດກົດລະບຽບແລະທິດທາງຂອງການຈໍາລອງ.
ມີຂໍ້ມູນຫຼາຍເກີນໄປທີ່ຖືກບັນທຶກໄວ້ໃນບັນທຶກ, ແລະບາງຄັ້ງທ່ານຈໍາເປັນຕ້ອງຈັດລະບຽບໄຟລ໌ບັນທຶກເພື່ອບໍ່ໃຫ້ມັນໃຊ້ພື້ນທີ່ຫຼາຍເກີນໄປ.

ຜົນໄດ້ຮັບສໍາລັບ SymmetricDS

SymmetricDS ຊ່ວຍໃຫ້ທ່ານສາມາດຕັ້ງຄ່າການຈໍາລອງແບບສອງທາງລະຫວ່າງສອງ, ສາມ, ຫຼືແມ້ກະທັ້ງຫຼາຍພັນໂຫນດເພື່ອເຮັດເລື້ມຄືນແລະ synchronize ໄຟລ໌. ນີ້ແມ່ນເຄື່ອງມືທີ່ເປັນເອກະລັກທີ່ປະຕິບັດວຽກງານຫຼາຍຢ່າງເປັນເອກະລາດ, ເຊັ່ນ: ການຟື້ນຕົວຂໍ້ມູນອັດຕະໂນມັດຫຼັງຈາກໄລຍະເວລາຢຸດເຮັດວຽກຢູ່ໃນ node, ຄວາມປອດໄພແລະປະສິດທິພາບການແລກປ່ຽນຂໍ້ມູນລະຫວ່າງ nodes ຜ່ານ HTTPS, ການຈັດການຂໍ້ຂັດແຍ່ງອັດຕະໂນມັດໂດຍອີງໃສ່ຊຸດຂອງກົດລະບຽບ, ແລະອື່ນໆ SymmetricDS ປະຕິບັດ. ການຈໍາລອງລະຫວ່າງຖານຂໍ້ມູນໃດໆ, ດັ່ງນັ້ນ, ມັນສາມາດຖືກນໍາໃຊ້ສໍາລັບສະຖານະການທີ່ຫລາກຫລາຍ, ລວມທັງການເຄື່ອນຍ້າຍ, ການເຄື່ອນຍ້າຍ, ການແຈກຢາຍ, ການກັ່ນຕອງແລະການຫັນປ່ຽນຂໍ້ມູນໃນທົ່ວແພລະຕະຟອມ.

ຕົວຢ່າງແມ່ນອີງໃສ່ເຈົ້າຫນ້າທີ່ ຄູ່ມືດ່ວນ ໂດຍ SymmetricDS. IN ຄູ່​ມື​ຜູ້​ໃຊ້ ອະທິບາຍຢ່າງລະອຽດກ່ຽວກັບແນວຄວາມຄິດຕ່າງໆທີ່ກ່ຽວຂ້ອງກັບການສ້າງຕັ້ງການຈໍາລອງກັບ SymmetricDS.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com